1539 lines
51 KiB
TypeScript
1539 lines
51 KiB
TypeScript
/* eslint-disable */
|
|
import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
|
|
export type Maybe<T> = T | null;
|
|
export type InputMaybe<T> = Maybe<T>;
|
|
export type Exact<T extends { [key: string]: unknown }> = {
|
|
[K in keyof T]: T[K];
|
|
};
|
|
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
|
|
[SubKey in K]?: Maybe<T[SubKey]>;
|
|
};
|
|
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
|
|
[SubKey in K]: Maybe<T[SubKey]>;
|
|
};
|
|
export type MakeEmpty<
|
|
T extends { [key: string]: unknown },
|
|
K extends keyof T,
|
|
> = { [_ in K]?: never };
|
|
export type Incremental<T> =
|
|
| T
|
|
| {
|
|
[P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
|
|
};
|
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
export type Scalars = {
|
|
ID: { input: string; output: string };
|
|
String: { input: string; output: string };
|
|
Boolean: { input: boolean; output: boolean };
|
|
Int: { input: number; output: number };
|
|
Float: { input: number; output: number };
|
|
};
|
|
|
|
export type Bangumi = {
|
|
__typename?: 'Bangumi';
|
|
createdAt: Scalars['String']['output'];
|
|
deleted: Scalars['Boolean']['output'];
|
|
displayName: Scalars['String']['output'];
|
|
episode: EpisodesConnection;
|
|
fansub?: Maybe<Scalars['String']['output']>;
|
|
homepage?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['Int']['output'];
|
|
mikanBangumiId?: Maybe<Scalars['String']['output']>;
|
|
mikanFansubId?: Maybe<Scalars['String']['output']>;
|
|
posterLink?: Maybe<Scalars['String']['output']>;
|
|
rawName: Scalars['String']['output'];
|
|
rssLink?: Maybe<Scalars['String']['output']>;
|
|
savePath?: Maybe<Scalars['String']['output']>;
|
|
season: Scalars['Int']['output'];
|
|
seasonRaw?: Maybe<Scalars['String']['output']>;
|
|
subscriber?: Maybe<Subscribers>;
|
|
subscriberId: Scalars['Int']['output'];
|
|
subscription: SubscriptionsConnection;
|
|
subscriptionBangumi: SubscriptionBangumiConnection;
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type BangumiEpisodeArgs = {
|
|
filters?: InputMaybe<EpisodesFilterInput>;
|
|
orderBy?: InputMaybe<EpisodesOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type BangumiSubscriptionArgs = {
|
|
filters?: InputMaybe<SubscriptionsFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionsOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type BangumiSubscriptionBangumiArgs = {
|
|
filters?: InputMaybe<SubscriptionBangumiFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionBangumiOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type BangumiBasic = {
|
|
__typename?: 'BangumiBasic';
|
|
createdAt: Scalars['String']['output'];
|
|
deleted: Scalars['Boolean']['output'];
|
|
displayName: Scalars['String']['output'];
|
|
fansub?: Maybe<Scalars['String']['output']>;
|
|
homepage?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['Int']['output'];
|
|
mikanBangumiId?: Maybe<Scalars['String']['output']>;
|
|
mikanFansubId?: Maybe<Scalars['String']['output']>;
|
|
posterLink?: Maybe<Scalars['String']['output']>;
|
|
rawName: Scalars['String']['output'];
|
|
rssLink?: Maybe<Scalars['String']['output']>;
|
|
savePath?: Maybe<Scalars['String']['output']>;
|
|
season: Scalars['Int']['output'];
|
|
seasonRaw?: Maybe<Scalars['String']['output']>;
|
|
subscriberId: Scalars['Int']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type BangumiConnection = {
|
|
__typename?: 'BangumiConnection';
|
|
edges: Array<BangumiEdge>;
|
|
nodes: Array<Bangumi>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type BangumiEdge = {
|
|
__typename?: 'BangumiEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: Bangumi;
|
|
};
|
|
|
|
export type BangumiFilterInput = {
|
|
and?: InputMaybe<Array<BangumiFilterInput>>;
|
|
createdAt?: InputMaybe<TextFilterInput>;
|
|
deleted?: InputMaybe<BooleanFilterInput>;
|
|
displayName?: InputMaybe<StringFilterInput>;
|
|
fansub?: InputMaybe<StringFilterInput>;
|
|
homepage?: InputMaybe<StringFilterInput>;
|
|
id?: InputMaybe<IntegerFilterInput>;
|
|
mikanBangumiId?: InputMaybe<StringFilterInput>;
|
|
mikanFansubId?: InputMaybe<StringFilterInput>;
|
|
or?: InputMaybe<Array<BangumiFilterInput>>;
|
|
posterLink?: InputMaybe<StringFilterInput>;
|
|
rawName?: InputMaybe<StringFilterInput>;
|
|
rssLink?: InputMaybe<StringFilterInput>;
|
|
savePath?: InputMaybe<StringFilterInput>;
|
|
season?: InputMaybe<IntegerFilterInput>;
|
|
seasonRaw?: InputMaybe<StringFilterInput>;
|
|
subscriberId?: InputMaybe<SubscriberIdFilterInput>;
|
|
updatedAt?: InputMaybe<TextFilterInput>;
|
|
};
|
|
|
|
export type BangumiInsertInput = {
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
deleted: Scalars['Boolean']['input'];
|
|
displayName: Scalars['String']['input'];
|
|
fansub?: InputMaybe<Scalars['String']['input']>;
|
|
homepage?: InputMaybe<Scalars['String']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
mikanBangumiId?: InputMaybe<Scalars['String']['input']>;
|
|
mikanFansubId?: InputMaybe<Scalars['String']['input']>;
|
|
posterLink?: InputMaybe<Scalars['String']['input']>;
|
|
rawName: Scalars['String']['input'];
|
|
rssLink?: InputMaybe<Scalars['String']['input']>;
|
|
savePath?: InputMaybe<Scalars['String']['input']>;
|
|
season: Scalars['Int']['input'];
|
|
seasonRaw?: InputMaybe<Scalars['String']['input']>;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type BangumiOrderInput = {
|
|
createdAt?: InputMaybe<OrderByEnum>;
|
|
deleted?: InputMaybe<OrderByEnum>;
|
|
displayName?: InputMaybe<OrderByEnum>;
|
|
extra?: InputMaybe<OrderByEnum>;
|
|
fansub?: InputMaybe<OrderByEnum>;
|
|
filter?: InputMaybe<OrderByEnum>;
|
|
homepage?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
mikanBangumiId?: InputMaybe<OrderByEnum>;
|
|
mikanFansubId?: InputMaybe<OrderByEnum>;
|
|
posterLink?: InputMaybe<OrderByEnum>;
|
|
rawName?: InputMaybe<OrderByEnum>;
|
|
rssLink?: InputMaybe<OrderByEnum>;
|
|
savePath?: InputMaybe<OrderByEnum>;
|
|
season?: InputMaybe<OrderByEnum>;
|
|
seasonRaw?: InputMaybe<OrderByEnum>;
|
|
subscriberId?: InputMaybe<OrderByEnum>;
|
|
updatedAt?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type BangumiUpdateInput = {
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
deleted?: InputMaybe<Scalars['Boolean']['input']>;
|
|
displayName?: InputMaybe<Scalars['String']['input']>;
|
|
fansub?: InputMaybe<Scalars['String']['input']>;
|
|
homepage?: InputMaybe<Scalars['String']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
mikanBangumiId?: InputMaybe<Scalars['String']['input']>;
|
|
mikanFansubId?: InputMaybe<Scalars['String']['input']>;
|
|
posterLink?: InputMaybe<Scalars['String']['input']>;
|
|
rawName?: InputMaybe<Scalars['String']['input']>;
|
|
rssLink?: InputMaybe<Scalars['String']['input']>;
|
|
savePath?: InputMaybe<Scalars['String']['input']>;
|
|
season?: InputMaybe<Scalars['Int']['input']>;
|
|
seasonRaw?: InputMaybe<Scalars['String']['input']>;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type BooleanFilterInput = {
|
|
eq?: InputMaybe<Scalars['Boolean']['input']>;
|
|
gt?: InputMaybe<Scalars['Boolean']['input']>;
|
|
gte?: InputMaybe<Scalars['Boolean']['input']>;
|
|
is_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
|
|
is_not_in?: InputMaybe<Array<Scalars['Boolean']['input']>>;
|
|
is_not_null?: InputMaybe<Scalars['Boolean']['input']>;
|
|
is_null?: InputMaybe<Scalars['Boolean']['input']>;
|
|
lt?: InputMaybe<Scalars['Boolean']['input']>;
|
|
lte?: InputMaybe<Scalars['Boolean']['input']>;
|
|
ne?: InputMaybe<Scalars['Boolean']['input']>;
|
|
};
|
|
|
|
export type CursorInput = {
|
|
cursor?: InputMaybe<Scalars['String']['input']>;
|
|
limit: Scalars['Int']['input'];
|
|
};
|
|
|
|
export enum DownloadMimeEnum {
|
|
Applicationoctetstream = 'applicationoctetstream',
|
|
Applicationxbittorrent = 'applicationxbittorrent',
|
|
}
|
|
|
|
export type DownloadMimeEnumFilterInput = {
|
|
eq?: InputMaybe<DownloadMimeEnum>;
|
|
gt?: InputMaybe<DownloadMimeEnum>;
|
|
gte?: InputMaybe<DownloadMimeEnum>;
|
|
is_in?: InputMaybe<Array<DownloadMimeEnum>>;
|
|
is_not_in?: InputMaybe<Array<DownloadMimeEnum>>;
|
|
is_not_null?: InputMaybe<DownloadMimeEnum>;
|
|
is_null?: InputMaybe<DownloadMimeEnum>;
|
|
lt?: InputMaybe<DownloadMimeEnum>;
|
|
lte?: InputMaybe<DownloadMimeEnum>;
|
|
ne?: InputMaybe<DownloadMimeEnum>;
|
|
};
|
|
|
|
export enum DownloadStatusEnum {
|
|
Completed = 'completed',
|
|
Deleted = 'deleted',
|
|
Downloading = 'downloading',
|
|
Failed = 'failed',
|
|
Paused = 'paused',
|
|
Pending = 'pending',
|
|
}
|
|
|
|
export type DownloadStatusEnumFilterInput = {
|
|
eq?: InputMaybe<DownloadStatusEnum>;
|
|
gt?: InputMaybe<DownloadStatusEnum>;
|
|
gte?: InputMaybe<DownloadStatusEnum>;
|
|
is_in?: InputMaybe<Array<DownloadStatusEnum>>;
|
|
is_not_in?: InputMaybe<Array<DownloadStatusEnum>>;
|
|
is_not_null?: InputMaybe<DownloadStatusEnum>;
|
|
is_null?: InputMaybe<DownloadStatusEnum>;
|
|
lt?: InputMaybe<DownloadStatusEnum>;
|
|
lte?: InputMaybe<DownloadStatusEnum>;
|
|
ne?: InputMaybe<DownloadStatusEnum>;
|
|
};
|
|
|
|
export enum DownloaderCategoryEnum {
|
|
Dandanplay = 'dandanplay',
|
|
Qbittorrent = 'qbittorrent',
|
|
}
|
|
|
|
export type DownloaderCategoryEnumFilterInput = {
|
|
eq?: InputMaybe<DownloaderCategoryEnum>;
|
|
gt?: InputMaybe<DownloaderCategoryEnum>;
|
|
gte?: InputMaybe<DownloaderCategoryEnum>;
|
|
is_in?: InputMaybe<Array<DownloaderCategoryEnum>>;
|
|
is_not_in?: InputMaybe<Array<DownloaderCategoryEnum>>;
|
|
is_not_null?: InputMaybe<DownloaderCategoryEnum>;
|
|
is_null?: InputMaybe<DownloaderCategoryEnum>;
|
|
lt?: InputMaybe<DownloaderCategoryEnum>;
|
|
lte?: InputMaybe<DownloaderCategoryEnum>;
|
|
ne?: InputMaybe<DownloaderCategoryEnum>;
|
|
};
|
|
|
|
export type Downloaders = {
|
|
__typename?: 'Downloaders';
|
|
category: DownloaderCategoryEnum;
|
|
createdAt: Scalars['String']['output'];
|
|
download: DownloadsConnection;
|
|
endpoint: Scalars['String']['output'];
|
|
id: Scalars['Int']['output'];
|
|
password: Scalars['String']['output'];
|
|
savePath: Scalars['String']['output'];
|
|
subscriber?: Maybe<Subscribers>;
|
|
subscriberId: Scalars['Int']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
username: Scalars['String']['output'];
|
|
};
|
|
|
|
export type DownloadersDownloadArgs = {
|
|
filters?: InputMaybe<DownloadsFilterInput>;
|
|
orderBy?: InputMaybe<DownloadsOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type DownloadersBasic = {
|
|
__typename?: 'DownloadersBasic';
|
|
category: DownloaderCategoryEnum;
|
|
createdAt: Scalars['String']['output'];
|
|
endpoint: Scalars['String']['output'];
|
|
id: Scalars['Int']['output'];
|
|
password: Scalars['String']['output'];
|
|
savePath: Scalars['String']['output'];
|
|
subscriberId: Scalars['Int']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
username: Scalars['String']['output'];
|
|
};
|
|
|
|
export type DownloadersConnection = {
|
|
__typename?: 'DownloadersConnection';
|
|
edges: Array<DownloadersEdge>;
|
|
nodes: Array<Downloaders>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type DownloadersEdge = {
|
|
__typename?: 'DownloadersEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: Downloaders;
|
|
};
|
|
|
|
export type DownloadersFilterInput = {
|
|
and?: InputMaybe<Array<DownloadersFilterInput>>;
|
|
category?: InputMaybe<DownloaderCategoryEnumFilterInput>;
|
|
createdAt?: InputMaybe<TextFilterInput>;
|
|
endpoint?: InputMaybe<StringFilterInput>;
|
|
id?: InputMaybe<IntegerFilterInput>;
|
|
or?: InputMaybe<Array<DownloadersFilterInput>>;
|
|
password?: InputMaybe<StringFilterInput>;
|
|
savePath?: InputMaybe<StringFilterInput>;
|
|
subscriberId?: InputMaybe<SubscriberIdFilterInput>;
|
|
updatedAt?: InputMaybe<TextFilterInput>;
|
|
username?: InputMaybe<StringFilterInput>;
|
|
};
|
|
|
|
export type DownloadersInsertInput = {
|
|
category: DownloaderCategoryEnum;
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
endpoint: Scalars['String']['input'];
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
password: Scalars['String']['input'];
|
|
savePath: Scalars['String']['input'];
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
username: Scalars['String']['input'];
|
|
};
|
|
|
|
export type DownloadersOrderInput = {
|
|
category?: InputMaybe<OrderByEnum>;
|
|
createdAt?: InputMaybe<OrderByEnum>;
|
|
endpoint?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
password?: InputMaybe<OrderByEnum>;
|
|
savePath?: InputMaybe<OrderByEnum>;
|
|
subscriberId?: InputMaybe<OrderByEnum>;
|
|
updatedAt?: InputMaybe<OrderByEnum>;
|
|
username?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type DownloadersUpdateInput = {
|
|
category?: InputMaybe<DownloaderCategoryEnum>;
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
endpoint?: InputMaybe<Scalars['String']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
password?: InputMaybe<Scalars['String']['input']>;
|
|
savePath?: InputMaybe<Scalars['String']['input']>;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
username?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type Downloads = {
|
|
__typename?: 'Downloads';
|
|
allSize?: Maybe<Scalars['Int']['output']>;
|
|
createdAt: Scalars['String']['output'];
|
|
currSize?: Maybe<Scalars['Int']['output']>;
|
|
displayName: Scalars['String']['output'];
|
|
downloader?: Maybe<Downloaders>;
|
|
downloaderId: Scalars['Int']['output'];
|
|
episode?: Maybe<Episodes>;
|
|
episodeId: Scalars['Int']['output'];
|
|
homepage?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['Int']['output'];
|
|
mime: DownloadMimeEnum;
|
|
rawName: Scalars['String']['output'];
|
|
savePath?: Maybe<Scalars['String']['output']>;
|
|
status: DownloadStatusEnum;
|
|
subscriber?: Maybe<Subscribers>;
|
|
subscriberId: Scalars['Int']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
url: Scalars['String']['output'];
|
|
};
|
|
|
|
export type DownloadsBasic = {
|
|
__typename?: 'DownloadsBasic';
|
|
allSize?: Maybe<Scalars['Int']['output']>;
|
|
createdAt: Scalars['String']['output'];
|
|
currSize?: Maybe<Scalars['Int']['output']>;
|
|
displayName: Scalars['String']['output'];
|
|
downloaderId: Scalars['Int']['output'];
|
|
episodeId: Scalars['Int']['output'];
|
|
homepage?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['Int']['output'];
|
|
mime: DownloadMimeEnum;
|
|
rawName: Scalars['String']['output'];
|
|
savePath?: Maybe<Scalars['String']['output']>;
|
|
status: DownloadStatusEnum;
|
|
subscriberId: Scalars['Int']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
url: Scalars['String']['output'];
|
|
};
|
|
|
|
export type DownloadsConnection = {
|
|
__typename?: 'DownloadsConnection';
|
|
edges: Array<DownloadsEdge>;
|
|
nodes: Array<Downloads>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type DownloadsEdge = {
|
|
__typename?: 'DownloadsEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: Downloads;
|
|
};
|
|
|
|
export type DownloadsFilterInput = {
|
|
allSize?: InputMaybe<IntegerFilterInput>;
|
|
and?: InputMaybe<Array<DownloadsFilterInput>>;
|
|
createdAt?: InputMaybe<TextFilterInput>;
|
|
currSize?: InputMaybe<IntegerFilterInput>;
|
|
displayName?: InputMaybe<StringFilterInput>;
|
|
downloaderId?: InputMaybe<IntegerFilterInput>;
|
|
episodeId?: InputMaybe<IntegerFilterInput>;
|
|
homepage?: InputMaybe<StringFilterInput>;
|
|
id?: InputMaybe<IntegerFilterInput>;
|
|
mime?: InputMaybe<DownloadMimeEnumFilterInput>;
|
|
or?: InputMaybe<Array<DownloadsFilterInput>>;
|
|
rawName?: InputMaybe<StringFilterInput>;
|
|
savePath?: InputMaybe<StringFilterInput>;
|
|
status?: InputMaybe<DownloadStatusEnumFilterInput>;
|
|
subscriberId?: InputMaybe<SubscriberIdFilterInput>;
|
|
updatedAt?: InputMaybe<TextFilterInput>;
|
|
url?: InputMaybe<StringFilterInput>;
|
|
};
|
|
|
|
export type DownloadsInsertInput = {
|
|
allSize?: InputMaybe<Scalars['Int']['input']>;
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
currSize?: InputMaybe<Scalars['Int']['input']>;
|
|
displayName: Scalars['String']['input'];
|
|
downloaderId: Scalars['Int']['input'];
|
|
episodeId: Scalars['Int']['input'];
|
|
homepage?: InputMaybe<Scalars['String']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
mime: DownloadMimeEnum;
|
|
rawName: Scalars['String']['input'];
|
|
savePath?: InputMaybe<Scalars['String']['input']>;
|
|
status: DownloadStatusEnum;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
url: Scalars['String']['input'];
|
|
};
|
|
|
|
export type DownloadsOrderInput = {
|
|
allSize?: InputMaybe<OrderByEnum>;
|
|
createdAt?: InputMaybe<OrderByEnum>;
|
|
currSize?: InputMaybe<OrderByEnum>;
|
|
displayName?: InputMaybe<OrderByEnum>;
|
|
downloaderId?: InputMaybe<OrderByEnum>;
|
|
episodeId?: InputMaybe<OrderByEnum>;
|
|
homepage?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
mime?: InputMaybe<OrderByEnum>;
|
|
rawName?: InputMaybe<OrderByEnum>;
|
|
savePath?: InputMaybe<OrderByEnum>;
|
|
status?: InputMaybe<OrderByEnum>;
|
|
subscriberId?: InputMaybe<OrderByEnum>;
|
|
updatedAt?: InputMaybe<OrderByEnum>;
|
|
url?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type DownloadsUpdateInput = {
|
|
allSize?: InputMaybe<Scalars['Int']['input']>;
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
currSize?: InputMaybe<Scalars['Int']['input']>;
|
|
displayName?: InputMaybe<Scalars['String']['input']>;
|
|
downloaderId?: InputMaybe<Scalars['Int']['input']>;
|
|
episodeId?: InputMaybe<Scalars['Int']['input']>;
|
|
homepage?: InputMaybe<Scalars['String']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
mime?: InputMaybe<DownloadMimeEnum>;
|
|
rawName?: InputMaybe<Scalars['String']['input']>;
|
|
savePath?: InputMaybe<Scalars['String']['input']>;
|
|
status?: InputMaybe<DownloadStatusEnum>;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
url?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type Episodes = {
|
|
__typename?: 'Episodes';
|
|
bangumi?: Maybe<Bangumi>;
|
|
bangumiId: Scalars['Int']['output'];
|
|
createdAt: Scalars['String']['output'];
|
|
deleted: Scalars['Boolean']['output'];
|
|
displayName: Scalars['String']['output'];
|
|
download: SubscriptionsConnection;
|
|
episodeIndex: Scalars['Int']['output'];
|
|
fansub?: Maybe<Scalars['String']['output']>;
|
|
homepage?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['Int']['output'];
|
|
mikanEpisodeId?: Maybe<Scalars['String']['output']>;
|
|
posterLink?: Maybe<Scalars['String']['output']>;
|
|
rawName: Scalars['String']['output'];
|
|
resolution?: Maybe<Scalars['String']['output']>;
|
|
savePath?: Maybe<Scalars['String']['output']>;
|
|
season: Scalars['Int']['output'];
|
|
seasonRaw?: Maybe<Scalars['String']['output']>;
|
|
source?: Maybe<Scalars['String']['output']>;
|
|
subscriber?: Maybe<Subscribers>;
|
|
subscriberId: Scalars['Int']['output'];
|
|
subscription: DownloadsConnection;
|
|
subscriptionEpisode: SubscriptionEpisodeConnection;
|
|
subtitle?: Maybe<Scalars['String']['output']>;
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type EpisodesDownloadArgs = {
|
|
filters?: InputMaybe<SubscriptionsFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionsOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type EpisodesSubscriptionArgs = {
|
|
filters?: InputMaybe<DownloadsFilterInput>;
|
|
orderBy?: InputMaybe<DownloadsOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type EpisodesSubscriptionEpisodeArgs = {
|
|
filters?: InputMaybe<SubscriptionEpisodeFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionEpisodeOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type EpisodesBasic = {
|
|
__typename?: 'EpisodesBasic';
|
|
bangumiId: Scalars['Int']['output'];
|
|
createdAt: Scalars['String']['output'];
|
|
deleted: Scalars['Boolean']['output'];
|
|
displayName: Scalars['String']['output'];
|
|
episodeIndex: Scalars['Int']['output'];
|
|
fansub?: Maybe<Scalars['String']['output']>;
|
|
homepage?: Maybe<Scalars['String']['output']>;
|
|
id: Scalars['Int']['output'];
|
|
mikanEpisodeId?: Maybe<Scalars['String']['output']>;
|
|
posterLink?: Maybe<Scalars['String']['output']>;
|
|
rawName: Scalars['String']['output'];
|
|
resolution?: Maybe<Scalars['String']['output']>;
|
|
savePath?: Maybe<Scalars['String']['output']>;
|
|
season: Scalars['Int']['output'];
|
|
seasonRaw?: Maybe<Scalars['String']['output']>;
|
|
source?: Maybe<Scalars['String']['output']>;
|
|
subscriberId: Scalars['Int']['output'];
|
|
subtitle?: Maybe<Scalars['String']['output']>;
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type EpisodesConnection = {
|
|
__typename?: 'EpisodesConnection';
|
|
edges: Array<EpisodesEdge>;
|
|
nodes: Array<Episodes>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type EpisodesEdge = {
|
|
__typename?: 'EpisodesEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: Episodes;
|
|
};
|
|
|
|
export type EpisodesFilterInput = {
|
|
and?: InputMaybe<Array<EpisodesFilterInput>>;
|
|
bangumiId?: InputMaybe<IntegerFilterInput>;
|
|
createdAt?: InputMaybe<TextFilterInput>;
|
|
deleted?: InputMaybe<BooleanFilterInput>;
|
|
displayName?: InputMaybe<StringFilterInput>;
|
|
episodeIndex?: InputMaybe<IntegerFilterInput>;
|
|
fansub?: InputMaybe<StringFilterInput>;
|
|
homepage?: InputMaybe<StringFilterInput>;
|
|
id?: InputMaybe<IntegerFilterInput>;
|
|
mikanEpisodeId?: InputMaybe<StringFilterInput>;
|
|
or?: InputMaybe<Array<EpisodesFilterInput>>;
|
|
posterLink?: InputMaybe<StringFilterInput>;
|
|
rawName?: InputMaybe<StringFilterInput>;
|
|
resolution?: InputMaybe<StringFilterInput>;
|
|
savePath?: InputMaybe<StringFilterInput>;
|
|
season?: InputMaybe<IntegerFilterInput>;
|
|
seasonRaw?: InputMaybe<StringFilterInput>;
|
|
source?: InputMaybe<StringFilterInput>;
|
|
subscriberId?: InputMaybe<SubscriberIdFilterInput>;
|
|
subtitle?: InputMaybe<StringFilterInput>;
|
|
updatedAt?: InputMaybe<TextFilterInput>;
|
|
};
|
|
|
|
export type EpisodesInsertInput = {
|
|
bangumiId: Scalars['Int']['input'];
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
deleted: Scalars['Boolean']['input'];
|
|
displayName: Scalars['String']['input'];
|
|
episodeIndex: Scalars['Int']['input'];
|
|
fansub?: InputMaybe<Scalars['String']['input']>;
|
|
homepage?: InputMaybe<Scalars['String']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
mikanEpisodeId?: InputMaybe<Scalars['String']['input']>;
|
|
posterLink?: InputMaybe<Scalars['String']['input']>;
|
|
rawName: Scalars['String']['input'];
|
|
resolution?: InputMaybe<Scalars['String']['input']>;
|
|
savePath?: InputMaybe<Scalars['String']['input']>;
|
|
season: Scalars['Int']['input'];
|
|
seasonRaw?: InputMaybe<Scalars['String']['input']>;
|
|
source?: InputMaybe<Scalars['String']['input']>;
|
|
subtitle?: InputMaybe<Scalars['String']['input']>;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type EpisodesOrderInput = {
|
|
bangumiId?: InputMaybe<OrderByEnum>;
|
|
createdAt?: InputMaybe<OrderByEnum>;
|
|
deleted?: InputMaybe<OrderByEnum>;
|
|
displayName?: InputMaybe<OrderByEnum>;
|
|
episodeIndex?: InputMaybe<OrderByEnum>;
|
|
extra?: InputMaybe<OrderByEnum>;
|
|
fansub?: InputMaybe<OrderByEnum>;
|
|
homepage?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
mikanEpisodeId?: InputMaybe<OrderByEnum>;
|
|
posterLink?: InputMaybe<OrderByEnum>;
|
|
rawName?: InputMaybe<OrderByEnum>;
|
|
resolution?: InputMaybe<OrderByEnum>;
|
|
savePath?: InputMaybe<OrderByEnum>;
|
|
season?: InputMaybe<OrderByEnum>;
|
|
seasonRaw?: InputMaybe<OrderByEnum>;
|
|
source?: InputMaybe<OrderByEnum>;
|
|
subscriberId?: InputMaybe<OrderByEnum>;
|
|
subtitle?: InputMaybe<OrderByEnum>;
|
|
updatedAt?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type EpisodesUpdateInput = {
|
|
bangumiId?: InputMaybe<Scalars['Int']['input']>;
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
deleted?: InputMaybe<Scalars['Boolean']['input']>;
|
|
displayName?: InputMaybe<Scalars['String']['input']>;
|
|
episodeIndex?: InputMaybe<Scalars['Int']['input']>;
|
|
fansub?: InputMaybe<Scalars['String']['input']>;
|
|
homepage?: InputMaybe<Scalars['String']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
mikanEpisodeId?: InputMaybe<Scalars['String']['input']>;
|
|
posterLink?: InputMaybe<Scalars['String']['input']>;
|
|
rawName?: InputMaybe<Scalars['String']['input']>;
|
|
resolution?: InputMaybe<Scalars['String']['input']>;
|
|
savePath?: InputMaybe<Scalars['String']['input']>;
|
|
season?: InputMaybe<Scalars['Int']['input']>;
|
|
seasonRaw?: InputMaybe<Scalars['String']['input']>;
|
|
source?: InputMaybe<Scalars['String']['input']>;
|
|
subtitle?: InputMaybe<Scalars['String']['input']>;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type IntegerFilterInput = {
|
|
between?: InputMaybe<Array<Scalars['Int']['input']>>;
|
|
eq?: InputMaybe<Scalars['Int']['input']>;
|
|
gt?: InputMaybe<Scalars['Int']['input']>;
|
|
gte?: InputMaybe<Scalars['Int']['input']>;
|
|
is_in?: InputMaybe<Array<Scalars['Int']['input']>>;
|
|
is_not_in?: InputMaybe<Array<Scalars['Int']['input']>>;
|
|
is_not_null?: InputMaybe<Scalars['Int']['input']>;
|
|
is_null?: InputMaybe<Scalars['Int']['input']>;
|
|
lt?: InputMaybe<Scalars['Int']['input']>;
|
|
lte?: InputMaybe<Scalars['Int']['input']>;
|
|
ne?: InputMaybe<Scalars['Int']['input']>;
|
|
not_between?: InputMaybe<Array<Scalars['Int']['input']>>;
|
|
};
|
|
|
|
export type Mutation = {
|
|
__typename?: 'Mutation';
|
|
_ping?: Maybe<Scalars['String']['output']>;
|
|
bangumiCreateBatch: Array<BangumiBasic>;
|
|
bangumiCreateOne: BangumiBasic;
|
|
bangumiDelete: Scalars['Int']['output'];
|
|
bangumiUpdate: Array<BangumiBasic>;
|
|
downloadersCreateBatch: Array<DownloadersBasic>;
|
|
downloadersCreateOne: DownloadersBasic;
|
|
downloadersDelete: Scalars['Int']['output'];
|
|
downloadersUpdate: Array<DownloadersBasic>;
|
|
downloadsCreateBatch: Array<DownloadsBasic>;
|
|
downloadsCreateOne: DownloadsBasic;
|
|
downloadsDelete: Scalars['Int']['output'];
|
|
downloadsUpdate: Array<DownloadsBasic>;
|
|
episodesCreateBatch: Array<EpisodesBasic>;
|
|
episodesCreateOne: EpisodesBasic;
|
|
episodesDelete: Scalars['Int']['output'];
|
|
episodesUpdate: Array<EpisodesBasic>;
|
|
subscriptionBangumiCreateBatch: Array<SubscriptionBangumiBasic>;
|
|
subscriptionBangumiCreateOne: SubscriptionBangumiBasic;
|
|
subscriptionBangumiDelete: Scalars['Int']['output'];
|
|
subscriptionBangumiUpdate: Array<SubscriptionBangumiBasic>;
|
|
subscriptionEpisodeCreateBatch: Array<SubscriptionEpisodeBasic>;
|
|
subscriptionEpisodeCreateOne: SubscriptionEpisodeBasic;
|
|
subscriptionEpisodeDelete: Scalars['Int']['output'];
|
|
subscriptionEpisodeUpdate: Array<SubscriptionEpisodeBasic>;
|
|
subscriptionsCreateBatch: Array<SubscriptionsBasic>;
|
|
subscriptionsCreateOne: SubscriptionsBasic;
|
|
subscriptionsDelete: Scalars['Int']['output'];
|
|
subscriptionsUpdate: Array<SubscriptionsBasic>;
|
|
};
|
|
|
|
export type MutationBangumiCreateBatchArgs = {
|
|
data: Array<BangumiInsertInput>;
|
|
};
|
|
|
|
export type MutationBangumiCreateOneArgs = {
|
|
data: BangumiInsertInput;
|
|
};
|
|
|
|
export type MutationBangumiDeleteArgs = {
|
|
filter?: InputMaybe<BangumiFilterInput>;
|
|
};
|
|
|
|
export type MutationBangumiUpdateArgs = {
|
|
data: BangumiUpdateInput;
|
|
filter?: InputMaybe<BangumiFilterInput>;
|
|
};
|
|
|
|
export type MutationDownloadersCreateBatchArgs = {
|
|
data: Array<DownloadersInsertInput>;
|
|
};
|
|
|
|
export type MutationDownloadersCreateOneArgs = {
|
|
data: DownloadersInsertInput;
|
|
};
|
|
|
|
export type MutationDownloadersDeleteArgs = {
|
|
filter?: InputMaybe<DownloadersFilterInput>;
|
|
};
|
|
|
|
export type MutationDownloadersUpdateArgs = {
|
|
data: DownloadersUpdateInput;
|
|
filter?: InputMaybe<DownloadersFilterInput>;
|
|
};
|
|
|
|
export type MutationDownloadsCreateBatchArgs = {
|
|
data: Array<DownloadsInsertInput>;
|
|
};
|
|
|
|
export type MutationDownloadsCreateOneArgs = {
|
|
data: DownloadsInsertInput;
|
|
};
|
|
|
|
export type MutationDownloadsDeleteArgs = {
|
|
filter?: InputMaybe<DownloadsFilterInput>;
|
|
};
|
|
|
|
export type MutationDownloadsUpdateArgs = {
|
|
data: DownloadsUpdateInput;
|
|
filter?: InputMaybe<DownloadsFilterInput>;
|
|
};
|
|
|
|
export type MutationEpisodesCreateBatchArgs = {
|
|
data: Array<EpisodesInsertInput>;
|
|
};
|
|
|
|
export type MutationEpisodesCreateOneArgs = {
|
|
data: EpisodesInsertInput;
|
|
};
|
|
|
|
export type MutationEpisodesDeleteArgs = {
|
|
filter?: InputMaybe<EpisodesFilterInput>;
|
|
};
|
|
|
|
export type MutationEpisodesUpdateArgs = {
|
|
data: EpisodesUpdateInput;
|
|
filter?: InputMaybe<EpisodesFilterInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionBangumiCreateBatchArgs = {
|
|
data: Array<SubscriptionBangumiInsertInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionBangumiCreateOneArgs = {
|
|
data: SubscriptionBangumiInsertInput;
|
|
};
|
|
|
|
export type MutationSubscriptionBangumiDeleteArgs = {
|
|
filter?: InputMaybe<SubscriptionBangumiFilterInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionBangumiUpdateArgs = {
|
|
data: SubscriptionBangumiUpdateInput;
|
|
filter?: InputMaybe<SubscriptionBangumiFilterInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionEpisodeCreateBatchArgs = {
|
|
data: Array<SubscriptionEpisodeInsertInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionEpisodeCreateOneArgs = {
|
|
data: SubscriptionEpisodeInsertInput;
|
|
};
|
|
|
|
export type MutationSubscriptionEpisodeDeleteArgs = {
|
|
filter?: InputMaybe<SubscriptionEpisodeFilterInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionEpisodeUpdateArgs = {
|
|
data: SubscriptionEpisodeUpdateInput;
|
|
filter?: InputMaybe<SubscriptionEpisodeFilterInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionsCreateBatchArgs = {
|
|
data: Array<SubscriptionsInsertInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionsCreateOneArgs = {
|
|
data: SubscriptionsInsertInput;
|
|
};
|
|
|
|
export type MutationSubscriptionsDeleteArgs = {
|
|
filter?: InputMaybe<SubscriptionsFilterInput>;
|
|
};
|
|
|
|
export type MutationSubscriptionsUpdateArgs = {
|
|
data: SubscriptionsUpdateInput;
|
|
filter?: InputMaybe<SubscriptionsFilterInput>;
|
|
};
|
|
|
|
export type OffsetInput = {
|
|
limit: Scalars['Int']['input'];
|
|
offset: Scalars['Int']['input'];
|
|
};
|
|
|
|
export enum OrderByEnum {
|
|
Asc = 'ASC',
|
|
Desc = 'DESC',
|
|
}
|
|
|
|
export type PageInfo = {
|
|
__typename?: 'PageInfo';
|
|
endCursor?: Maybe<Scalars['String']['output']>;
|
|
hasNextPage: Scalars['Boolean']['output'];
|
|
hasPreviousPage: Scalars['Boolean']['output'];
|
|
startCursor?: Maybe<Scalars['String']['output']>;
|
|
};
|
|
|
|
export type PageInput = {
|
|
limit: Scalars['Int']['input'];
|
|
page: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type PaginationInfo = {
|
|
__typename?: 'PaginationInfo';
|
|
current: Scalars['Int']['output'];
|
|
offset: Scalars['Int']['output'];
|
|
pages: Scalars['Int']['output'];
|
|
total: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type PaginationInput = {
|
|
cursor?: InputMaybe<CursorInput>;
|
|
offset?: InputMaybe<OffsetInput>;
|
|
page?: InputMaybe<PageInput>;
|
|
};
|
|
|
|
export type Query = {
|
|
__typename?: 'Query';
|
|
_sea_orm_entity_metadata?: Maybe<Scalars['String']['output']>;
|
|
bangumi: BangumiConnection;
|
|
downloaders: DownloadersConnection;
|
|
downloads: DownloadsConnection;
|
|
episodes: EpisodesConnection;
|
|
subscribers: SubscribersConnection;
|
|
subscriptionBangumi: SubscriptionBangumiConnection;
|
|
subscriptionEpisode: SubscriptionEpisodeConnection;
|
|
subscriptions: SubscriptionsConnection;
|
|
};
|
|
|
|
export type Query_Sea_Orm_Entity_MetadataArgs = {
|
|
table_name: Scalars['String']['input'];
|
|
};
|
|
|
|
export type QueryBangumiArgs = {
|
|
filters?: InputMaybe<BangumiFilterInput>;
|
|
orderBy?: InputMaybe<BangumiOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type QueryDownloadersArgs = {
|
|
filters?: InputMaybe<DownloadersFilterInput>;
|
|
orderBy?: InputMaybe<DownloadersOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type QueryDownloadsArgs = {
|
|
filters?: InputMaybe<DownloadsFilterInput>;
|
|
orderBy?: InputMaybe<DownloadsOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type QueryEpisodesArgs = {
|
|
filters?: InputMaybe<EpisodesFilterInput>;
|
|
orderBy?: InputMaybe<EpisodesOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type QuerySubscribersArgs = {
|
|
filters?: InputMaybe<SubscribersFilterInput>;
|
|
orderBy?: InputMaybe<SubscribersOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type QuerySubscriptionBangumiArgs = {
|
|
filters?: InputMaybe<SubscriptionBangumiFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionBangumiOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type QuerySubscriptionEpisodeArgs = {
|
|
filters?: InputMaybe<SubscriptionEpisodeFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionEpisodeOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type QuerySubscriptionsArgs = {
|
|
filters?: InputMaybe<SubscriptionsFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionsOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type StringFilterInput = {
|
|
between?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
contains?: InputMaybe<Scalars['String']['input']>;
|
|
ends_with?: InputMaybe<Scalars['String']['input']>;
|
|
eq?: InputMaybe<Scalars['String']['input']>;
|
|
gt?: InputMaybe<Scalars['String']['input']>;
|
|
gte?: InputMaybe<Scalars['String']['input']>;
|
|
is_in?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
is_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
is_not_null?: InputMaybe<Scalars['String']['input']>;
|
|
is_null?: InputMaybe<Scalars['String']['input']>;
|
|
like?: InputMaybe<Scalars['String']['input']>;
|
|
lt?: InputMaybe<Scalars['String']['input']>;
|
|
lte?: InputMaybe<Scalars['String']['input']>;
|
|
ne?: InputMaybe<Scalars['String']['input']>;
|
|
not_between?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
not_like?: InputMaybe<Scalars['String']['input']>;
|
|
starts_with?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type SubscriberIdFilterInput = {
|
|
eq?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type Subscribers = {
|
|
__typename?: 'Subscribers';
|
|
bangumi: BangumiConnection;
|
|
createdAt: Scalars['String']['output'];
|
|
displayName: Scalars['String']['output'];
|
|
downloader: DownloadersConnection;
|
|
episode: EpisodesConnection;
|
|
id: Scalars['Int']['output'];
|
|
subscription: SubscriptionsConnection;
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type SubscribersBangumiArgs = {
|
|
filters?: InputMaybe<BangumiFilterInput>;
|
|
orderBy?: InputMaybe<BangumiOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscribersDownloaderArgs = {
|
|
filters?: InputMaybe<DownloadersFilterInput>;
|
|
orderBy?: InputMaybe<DownloadersOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscribersEpisodeArgs = {
|
|
filters?: InputMaybe<EpisodesFilterInput>;
|
|
orderBy?: InputMaybe<EpisodesOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscribersSubscriptionArgs = {
|
|
filters?: InputMaybe<SubscriptionsFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionsOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscribersConnection = {
|
|
__typename?: 'SubscribersConnection';
|
|
edges: Array<SubscribersEdge>;
|
|
nodes: Array<Subscribers>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type SubscribersEdge = {
|
|
__typename?: 'SubscribersEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: Subscribers;
|
|
};
|
|
|
|
export type SubscribersFilterInput = {
|
|
and?: InputMaybe<Array<SubscribersFilterInput>>;
|
|
id?: InputMaybe<SubscriberIdFilterInput>;
|
|
or?: InputMaybe<Array<SubscribersFilterInput>>;
|
|
};
|
|
|
|
export type SubscribersOrderInput = {
|
|
bangumiConf?: InputMaybe<OrderByEnum>;
|
|
createdAt?: InputMaybe<OrderByEnum>;
|
|
displayName?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
updatedAt?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type SubscriptionBangumi = {
|
|
__typename?: 'SubscriptionBangumi';
|
|
bangumi?: Maybe<Bangumi>;
|
|
bangumiId: Scalars['Int']['output'];
|
|
id: Scalars['Int']['output'];
|
|
subscriberId: Scalars['Int']['output'];
|
|
subscription?: Maybe<Subscriptions>;
|
|
subscriptionId: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type SubscriptionBangumiBasic = {
|
|
__typename?: 'SubscriptionBangumiBasic';
|
|
bangumiId: Scalars['Int']['output'];
|
|
id: Scalars['Int']['output'];
|
|
subscriberId: Scalars['Int']['output'];
|
|
subscriptionId: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type SubscriptionBangumiConnection = {
|
|
__typename?: 'SubscriptionBangumiConnection';
|
|
edges: Array<SubscriptionBangumiEdge>;
|
|
nodes: Array<SubscriptionBangumi>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type SubscriptionBangumiEdge = {
|
|
__typename?: 'SubscriptionBangumiEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: SubscriptionBangumi;
|
|
};
|
|
|
|
export type SubscriptionBangumiFilterInput = {
|
|
and?: InputMaybe<Array<SubscriptionBangumiFilterInput>>;
|
|
bangumiId?: InputMaybe<IntegerFilterInput>;
|
|
id?: InputMaybe<IntegerFilterInput>;
|
|
or?: InputMaybe<Array<SubscriptionBangumiFilterInput>>;
|
|
subscriberId?: InputMaybe<SubscriberIdFilterInput>;
|
|
subscriptionId?: InputMaybe<IntegerFilterInput>;
|
|
};
|
|
|
|
export type SubscriptionBangumiInsertInput = {
|
|
bangumiId: Scalars['Int']['input'];
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
subscriptionId: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type SubscriptionBangumiOrderInput = {
|
|
bangumiId?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
subscriberId?: InputMaybe<OrderByEnum>;
|
|
subscriptionId?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type SubscriptionBangumiUpdateInput = {
|
|
bangumiId?: InputMaybe<Scalars['Int']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
subscriptionId?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export enum SubscriptionCategoryEnum {
|
|
Manual = 'manual',
|
|
Mikan = 'mikan',
|
|
}
|
|
|
|
export type SubscriptionCategoryEnumFilterInput = {
|
|
eq?: InputMaybe<SubscriptionCategoryEnum>;
|
|
gt?: InputMaybe<SubscriptionCategoryEnum>;
|
|
gte?: InputMaybe<SubscriptionCategoryEnum>;
|
|
is_in?: InputMaybe<Array<SubscriptionCategoryEnum>>;
|
|
is_not_in?: InputMaybe<Array<SubscriptionCategoryEnum>>;
|
|
is_not_null?: InputMaybe<SubscriptionCategoryEnum>;
|
|
is_null?: InputMaybe<SubscriptionCategoryEnum>;
|
|
lt?: InputMaybe<SubscriptionCategoryEnum>;
|
|
lte?: InputMaybe<SubscriptionCategoryEnum>;
|
|
ne?: InputMaybe<SubscriptionCategoryEnum>;
|
|
};
|
|
|
|
export type SubscriptionEpisode = {
|
|
__typename?: 'SubscriptionEpisode';
|
|
episode?: Maybe<Episodes>;
|
|
episodeId: Scalars['Int']['output'];
|
|
id: Scalars['Int']['output'];
|
|
subscriberId: Scalars['Int']['output'];
|
|
subscription?: Maybe<Subscriptions>;
|
|
subscriptionId: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type SubscriptionEpisodeBasic = {
|
|
__typename?: 'SubscriptionEpisodeBasic';
|
|
episodeId: Scalars['Int']['output'];
|
|
id: Scalars['Int']['output'];
|
|
subscriberId: Scalars['Int']['output'];
|
|
subscriptionId: Scalars['Int']['output'];
|
|
};
|
|
|
|
export type SubscriptionEpisodeConnection = {
|
|
__typename?: 'SubscriptionEpisodeConnection';
|
|
edges: Array<SubscriptionEpisodeEdge>;
|
|
nodes: Array<SubscriptionEpisode>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type SubscriptionEpisodeEdge = {
|
|
__typename?: 'SubscriptionEpisodeEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: SubscriptionEpisode;
|
|
};
|
|
|
|
export type SubscriptionEpisodeFilterInput = {
|
|
and?: InputMaybe<Array<SubscriptionEpisodeFilterInput>>;
|
|
episodeId?: InputMaybe<IntegerFilterInput>;
|
|
id?: InputMaybe<IntegerFilterInput>;
|
|
or?: InputMaybe<Array<SubscriptionEpisodeFilterInput>>;
|
|
subscriberId?: InputMaybe<SubscriberIdFilterInput>;
|
|
subscriptionId?: InputMaybe<IntegerFilterInput>;
|
|
};
|
|
|
|
export type SubscriptionEpisodeInsertInput = {
|
|
episodeId: Scalars['Int']['input'];
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
subscriptionId: Scalars['Int']['input'];
|
|
};
|
|
|
|
export type SubscriptionEpisodeOrderInput = {
|
|
episodeId?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
subscriberId?: InputMaybe<OrderByEnum>;
|
|
subscriptionId?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type SubscriptionEpisodeUpdateInput = {
|
|
episodeId?: InputMaybe<Scalars['Int']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
subscriptionId?: InputMaybe<Scalars['Int']['input']>;
|
|
};
|
|
|
|
export type Subscriptions = {
|
|
__typename?: 'Subscriptions';
|
|
bangumi: BangumiConnection;
|
|
category: SubscriptionCategoryEnum;
|
|
createdAt: Scalars['String']['output'];
|
|
displayName: Scalars['String']['output'];
|
|
enabled: Scalars['Boolean']['output'];
|
|
episode: EpisodesConnection;
|
|
id: Scalars['Int']['output'];
|
|
sourceUrl: Scalars['String']['output'];
|
|
subscriber?: Maybe<Subscribers>;
|
|
subscriberId: Scalars['Int']['output'];
|
|
subscriptionBangumi: SubscriptionBangumiConnection;
|
|
subscriptionEpisode: SubscriptionEpisodeConnection;
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type SubscriptionsBangumiArgs = {
|
|
filters?: InputMaybe<BangumiFilterInput>;
|
|
orderBy?: InputMaybe<BangumiOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscriptionsEpisodeArgs = {
|
|
filters?: InputMaybe<EpisodesFilterInput>;
|
|
orderBy?: InputMaybe<EpisodesOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscriptionsSubscriptionBangumiArgs = {
|
|
filters?: InputMaybe<SubscriptionBangumiFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionBangumiOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscriptionsSubscriptionEpisodeArgs = {
|
|
filters?: InputMaybe<SubscriptionEpisodeFilterInput>;
|
|
orderBy?: InputMaybe<SubscriptionEpisodeOrderInput>;
|
|
pagination?: InputMaybe<PaginationInput>;
|
|
};
|
|
|
|
export type SubscriptionsBasic = {
|
|
__typename?: 'SubscriptionsBasic';
|
|
category: SubscriptionCategoryEnum;
|
|
createdAt: Scalars['String']['output'];
|
|
displayName: Scalars['String']['output'];
|
|
enabled: Scalars['Boolean']['output'];
|
|
id: Scalars['Int']['output'];
|
|
sourceUrl: Scalars['String']['output'];
|
|
subscriberId: Scalars['Int']['output'];
|
|
updatedAt: Scalars['String']['output'];
|
|
};
|
|
|
|
export type SubscriptionsConnection = {
|
|
__typename?: 'SubscriptionsConnection';
|
|
edges: Array<SubscriptionsEdge>;
|
|
nodes: Array<Subscriptions>;
|
|
pageInfo: PageInfo;
|
|
paginationInfo?: Maybe<PaginationInfo>;
|
|
};
|
|
|
|
export type SubscriptionsEdge = {
|
|
__typename?: 'SubscriptionsEdge';
|
|
cursor: Scalars['String']['output'];
|
|
node: Subscriptions;
|
|
};
|
|
|
|
export type SubscriptionsFilterInput = {
|
|
and?: InputMaybe<Array<SubscriptionsFilterInput>>;
|
|
category?: InputMaybe<SubscriptionCategoryEnumFilterInput>;
|
|
createdAt?: InputMaybe<TextFilterInput>;
|
|
displayName?: InputMaybe<StringFilterInput>;
|
|
enabled?: InputMaybe<BooleanFilterInput>;
|
|
id?: InputMaybe<IntegerFilterInput>;
|
|
or?: InputMaybe<Array<SubscriptionsFilterInput>>;
|
|
sourceUrl?: InputMaybe<StringFilterInput>;
|
|
subscriberId?: InputMaybe<SubscriberIdFilterInput>;
|
|
updatedAt?: InputMaybe<TextFilterInput>;
|
|
};
|
|
|
|
export type SubscriptionsInsertInput = {
|
|
category: SubscriptionCategoryEnum;
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
displayName: Scalars['String']['input'];
|
|
enabled: Scalars['Boolean']['input'];
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
sourceUrl: Scalars['String']['input'];
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type SubscriptionsOrderInput = {
|
|
category?: InputMaybe<OrderByEnum>;
|
|
createdAt?: InputMaybe<OrderByEnum>;
|
|
displayName?: InputMaybe<OrderByEnum>;
|
|
enabled?: InputMaybe<OrderByEnum>;
|
|
id?: InputMaybe<OrderByEnum>;
|
|
sourceUrl?: InputMaybe<OrderByEnum>;
|
|
subscriberId?: InputMaybe<OrderByEnum>;
|
|
updatedAt?: InputMaybe<OrderByEnum>;
|
|
};
|
|
|
|
export type SubscriptionsUpdateInput = {
|
|
category?: InputMaybe<SubscriptionCategoryEnum>;
|
|
createdAt?: InputMaybe<Scalars['String']['input']>;
|
|
displayName?: InputMaybe<Scalars['String']['input']>;
|
|
enabled?: InputMaybe<Scalars['Boolean']['input']>;
|
|
id?: InputMaybe<Scalars['Int']['input']>;
|
|
sourceUrl?: InputMaybe<Scalars['String']['input']>;
|
|
updatedAt?: InputMaybe<Scalars['String']['input']>;
|
|
};
|
|
|
|
export type TextFilterInput = {
|
|
between?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
eq?: InputMaybe<Scalars['String']['input']>;
|
|
gt?: InputMaybe<Scalars['String']['input']>;
|
|
gte?: InputMaybe<Scalars['String']['input']>;
|
|
is_in?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
is_not_in?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
is_not_null?: InputMaybe<Scalars['String']['input']>;
|
|
is_null?: InputMaybe<Scalars['String']['input']>;
|
|
lt?: InputMaybe<Scalars['String']['input']>;
|
|
lte?: InputMaybe<Scalars['String']['input']>;
|
|
ne?: InputMaybe<Scalars['String']['input']>;
|
|
not_between?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
};
|
|
|
|
export type CreateSubscriptionMutationVariables = Exact<{
|
|
input: SubscriptionsInsertInput;
|
|
}>;
|
|
|
|
export type CreateSubscriptionMutation = {
|
|
__typename?: 'Mutation';
|
|
subscriptionsCreateOne: {
|
|
__typename?: 'SubscriptionsBasic';
|
|
id: number;
|
|
displayName: string;
|
|
sourceUrl: string;
|
|
enabled: boolean;
|
|
category: SubscriptionCategoryEnum;
|
|
subscriberId: number;
|
|
};
|
|
};
|
|
|
|
export type GetSubscriptionsQueryVariables = Exact<{
|
|
page: Scalars['Int']['input'];
|
|
pageSize: Scalars['Int']['input'];
|
|
}>;
|
|
|
|
export type GetSubscriptionsQuery = {
|
|
__typename?: 'Query';
|
|
subscriptions: {
|
|
__typename?: 'SubscriptionsConnection';
|
|
nodes: Array<{
|
|
__typename?: 'Subscriptions';
|
|
id: number;
|
|
displayName: string;
|
|
category: SubscriptionCategoryEnum;
|
|
enabled: boolean;
|
|
bangumi: {
|
|
__typename?: 'BangumiConnection';
|
|
nodes: Array<{
|
|
__typename?: 'Bangumi';
|
|
id: number;
|
|
displayName: string;
|
|
posterLink?: string | null;
|
|
season: number;
|
|
fansub?: string | null;
|
|
homepage?: string | null;
|
|
}>;
|
|
};
|
|
}>;
|
|
};
|
|
};
|
|
|
|
export const CreateSubscriptionDocument = {
|
|
kind: 'Document',
|
|
definitions: [
|
|
{
|
|
kind: 'OperationDefinition',
|
|
operation: 'mutation',
|
|
name: { kind: 'Name', value: 'CreateSubscription' },
|
|
variableDefinitions: [
|
|
{
|
|
kind: 'VariableDefinition',
|
|
variable: {
|
|
kind: 'Variable',
|
|
name: { kind: 'Name', value: 'input' },
|
|
},
|
|
type: {
|
|
kind: 'NonNullType',
|
|
type: {
|
|
kind: 'NamedType',
|
|
name: { kind: 'Name', value: 'SubscriptionsInsertInput' },
|
|
},
|
|
},
|
|
},
|
|
],
|
|
selectionSet: {
|
|
kind: 'SelectionSet',
|
|
selections: [
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'subscriptionsCreateOne' },
|
|
arguments: [
|
|
{
|
|
kind: 'Argument',
|
|
name: { kind: 'Name', value: 'data' },
|
|
value: {
|
|
kind: 'Variable',
|
|
name: { kind: 'Name', value: 'input' },
|
|
},
|
|
},
|
|
],
|
|
selectionSet: {
|
|
kind: 'SelectionSet',
|
|
selections: [
|
|
{ kind: 'Field', name: { kind: 'Name', value: 'id' } },
|
|
{ kind: 'Field', name: { kind: 'Name', value: 'displayName' } },
|
|
{ kind: 'Field', name: { kind: 'Name', value: 'sourceUrl' } },
|
|
{ kind: 'Field', name: { kind: 'Name', value: 'enabled' } },
|
|
{ kind: 'Field', name: { kind: 'Name', value: 'category' } },
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'subscriberId' },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
} as unknown as DocumentNode<
|
|
CreateSubscriptionMutation,
|
|
CreateSubscriptionMutationVariables
|
|
>;
|
|
export const GetSubscriptionsDocument = {
|
|
kind: 'Document',
|
|
definitions: [
|
|
{
|
|
kind: 'OperationDefinition',
|
|
operation: 'query',
|
|
name: { kind: 'Name', value: 'GetSubscriptions' },
|
|
variableDefinitions: [
|
|
{
|
|
kind: 'VariableDefinition',
|
|
variable: { kind: 'Variable', name: { kind: 'Name', value: 'page' } },
|
|
type: {
|
|
kind: 'NonNullType',
|
|
type: { kind: 'NamedType', name: { kind: 'Name', value: 'Int' } },
|
|
},
|
|
},
|
|
{
|
|
kind: 'VariableDefinition',
|
|
variable: {
|
|
kind: 'Variable',
|
|
name: { kind: 'Name', value: 'pageSize' },
|
|
},
|
|
type: {
|
|
kind: 'NonNullType',
|
|
type: { kind: 'NamedType', name: { kind: 'Name', value: 'Int' } },
|
|
},
|
|
},
|
|
],
|
|
selectionSet: {
|
|
kind: 'SelectionSet',
|
|
selections: [
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'subscriptions' },
|
|
arguments: [
|
|
{
|
|
kind: 'Argument',
|
|
name: { kind: 'Name', value: 'pagination' },
|
|
value: {
|
|
kind: 'ObjectValue',
|
|
fields: [
|
|
{
|
|
kind: 'ObjectField',
|
|
name: { kind: 'Name', value: 'page' },
|
|
value: {
|
|
kind: 'ObjectValue',
|
|
fields: [
|
|
{
|
|
kind: 'ObjectField',
|
|
name: { kind: 'Name', value: 'page' },
|
|
value: {
|
|
kind: 'Variable',
|
|
name: { kind: 'Name', value: 'page' },
|
|
},
|
|
},
|
|
{
|
|
kind: 'ObjectField',
|
|
name: { kind: 'Name', value: 'limit' },
|
|
value: {
|
|
kind: 'Variable',
|
|
name: { kind: 'Name', value: 'pageSize' },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
selectionSet: {
|
|
kind: 'SelectionSet',
|
|
selections: [
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'nodes' },
|
|
selectionSet: {
|
|
kind: 'SelectionSet',
|
|
selections: [
|
|
{ kind: 'Field', name: { kind: 'Name', value: 'id' } },
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'displayName' },
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'category' },
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'enabled' },
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'bangumi' },
|
|
selectionSet: {
|
|
kind: 'SelectionSet',
|
|
selections: [
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'nodes' },
|
|
selectionSet: {
|
|
kind: 'SelectionSet',
|
|
selections: [
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'id' },
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: {
|
|
kind: 'Name',
|
|
value: 'displayName',
|
|
},
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'posterLink' },
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'season' },
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'fansub' },
|
|
},
|
|
{
|
|
kind: 'Field',
|
|
name: { kind: 'Name', value: 'homepage' },
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
},
|
|
},
|
|
],
|
|
} as unknown as DocumentNode<
|
|
GetSubscriptionsQuery,
|
|
GetSubscriptionsQueryVariables
|
|
>;
|