import { gql } from '@apollo/client';
import * as Apollo from '@apollo/client';
import * as ApolloReactHooks from '@apollo/client/react';
export type Maybe<T> = T | null;
export type InputMaybe<T> = T | null;
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 };
const defaultOptions = {} as const;
/** 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; }
  Instant: { input: any; output: any; }
  UUID: { input: any; output: any; }
  UnsignedInt: { input: any; output: any; }
};

export type Chapter = {
  body: LocalizationKey;
  createdTime: Scalars['Instant']['output'];
  id: Scalars['UnsignedInt']['output'];
  images: Array<Image>;
  lastUpdatedTime: Scalars['Instant']['output'];
  name: LocalizationKey;
  order: Scalars['UnsignedInt']['output'];
  revision: Scalars['UnsignedInt']['output'];
  url: Maybe<Scalars['String']['output']>;
};

export type ChapterFilterInput = {
  and: InputMaybe<Array<ChapterFilterInput>>;
  body: InputMaybe<LocalizationKeyFilterInput>;
  createdTime: InputMaybe<InstantFilterInput>;
  id: InputMaybe<UnsignedIntOperationFilterInputType>;
  images: InputMaybe<ListFilterInputTypeOfImageFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  name: InputMaybe<LocalizationKeyFilterInput>;
  or: InputMaybe<Array<ChapterFilterInput>>;
  order: InputMaybe<UnsignedIntOperationFilterInputType>;
  revision: InputMaybe<UnsignedIntOperationFilterInputType>;
  url: InputMaybe<StringOperationFilterInput>;
};

export type ChapterPullRequestedEvent = {
  chapterNumber: Scalars['UnsignedInt']['output'];
  novelId: Scalars['UnsignedInt']['output'];
};

export type ChapterSortInput = {
  body: InputMaybe<LocalizationKeySortInput>;
  createdTime: InputMaybe<SortEnumType>;
  id: InputMaybe<SortEnumType>;
  lastUpdatedTime: InputMaybe<SortEnumType>;
  name: InputMaybe<LocalizationKeySortInput>;
  order: InputMaybe<SortEnumType>;
  revision: InputMaybe<SortEnumType>;
  url: InputMaybe<SortEnumType>;
};

export type DeleteJobError = KeyNotFoundError;

export type DeleteJobInput = {
  jobKey: Scalars['String']['input'];
};

export type DeleteJobPayload = {
  boolean: Maybe<Scalars['Boolean']['output']>;
  errors: Maybe<Array<DeleteJobError>>;
};

export type DuplicateNameError = Error & {
  message: Scalars['String']['output'];
};

export type Error = {
  message: Scalars['String']['output'];
};

export type FetchChapterContentsInput = {
  chapterNumber: Scalars['UnsignedInt']['input'];
  novelId: Scalars['UnsignedInt']['input'];
};

export type FetchChapterContentsPayload = {
  chapterPullRequestedEvent: Maybe<ChapterPullRequestedEvent>;
};

export type FormatError = Error & {
  message: Scalars['String']['output'];
};

export type Image = {
  chapter: Maybe<Chapter>;
  createdTime: Scalars['Instant']['output'];
  id: Scalars['UUID']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
  newPath: Maybe<Scalars['String']['output']>;
  originalPath: Scalars['String']['output'];
};

export type ImageFilterInput = {
  and: InputMaybe<Array<ImageFilterInput>>;
  chapter: InputMaybe<ChapterFilterInput>;
  createdTime: InputMaybe<InstantFilterInput>;
  id: InputMaybe<UuidOperationFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  newPath: InputMaybe<StringOperationFilterInput>;
  or: InputMaybe<Array<ImageFilterInput>>;
  originalPath: InputMaybe<StringOperationFilterInput>;
};

export type ImageSortInput = {
  chapter: InputMaybe<ChapterSortInput>;
  createdTime: InputMaybe<SortEnumType>;
  id: InputMaybe<SortEnumType>;
  lastUpdatedTime: InputMaybe<SortEnumType>;
  newPath: InputMaybe<SortEnumType>;
  originalPath: InputMaybe<SortEnumType>;
};

export type ImportNovelInput = {
  novelUrl: Scalars['String']['input'];
};

export type ImportNovelPayload = {
  novelUpdateRequestedEvent: Maybe<NovelUpdateRequestedEvent>;
};

export type InstantFilterInput = {
  and: InputMaybe<Array<InstantFilterInput>>;
  or: InputMaybe<Array<InstantFilterInput>>;
};

export type JobKey = {
  group: Scalars['String']['output'];
  name: Scalars['String']['output'];
};

export type JobPersistenceError = Error & {
  message: Scalars['String']['output'];
};

export type KeyNotFoundError = Error & {
  message: Scalars['String']['output'];
};

export type KeyValuePairOfStringAndString = {
  key: Scalars['String']['output'];
  value: Scalars['String']['output'];
};

export enum Language {
  Ch = 'CH',
  En = 'EN',
  Ja = 'JA',
  Kr = 'KR'
}

export type LanguageOperationFilterInput = {
  eq: InputMaybe<Language>;
  in: InputMaybe<Array<Language>>;
  neq: InputMaybe<Language>;
  nin: InputMaybe<Array<Language>>;
};

export type ListFilterInputTypeOfChapterFilterInput = {
  all: InputMaybe<ChapterFilterInput>;
  any: InputMaybe<Scalars['Boolean']['input']>;
  none: InputMaybe<ChapterFilterInput>;
  some: InputMaybe<ChapterFilterInput>;
};

export type ListFilterInputTypeOfImageFilterInput = {
  all: InputMaybe<ImageFilterInput>;
  any: InputMaybe<Scalars['Boolean']['input']>;
  none: InputMaybe<ImageFilterInput>;
  some: InputMaybe<ImageFilterInput>;
};

export type ListFilterInputTypeOfLocalizationTextFilterInput = {
  all: InputMaybe<LocalizationTextFilterInput>;
  any: InputMaybe<Scalars['Boolean']['input']>;
  none: InputMaybe<LocalizationTextFilterInput>;
  some: InputMaybe<LocalizationTextFilterInput>;
};

export type ListFilterInputTypeOfNovelFilterInput = {
  all: InputMaybe<NovelFilterInput>;
  any: InputMaybe<Scalars['Boolean']['input']>;
  none: InputMaybe<NovelFilterInput>;
  some: InputMaybe<NovelFilterInput>;
};

export type ListFilterInputTypeOfNovelTagFilterInput = {
  all: InputMaybe<NovelTagFilterInput>;
  any: InputMaybe<Scalars['Boolean']['input']>;
  none: InputMaybe<NovelTagFilterInput>;
  some: InputMaybe<NovelTagFilterInput>;
};

export type LocalizationKey = {
  createdTime: Scalars['Instant']['output'];
  id: Scalars['UUID']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
  texts: Array<LocalizationText>;
};

export type LocalizationKeyFilterInput = {
  and: InputMaybe<Array<LocalizationKeyFilterInput>>;
  createdTime: InputMaybe<InstantFilterInput>;
  id: InputMaybe<UuidOperationFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  or: InputMaybe<Array<LocalizationKeyFilterInput>>;
  texts: InputMaybe<ListFilterInputTypeOfLocalizationTextFilterInput>;
};

export type LocalizationKeySortInput = {
  createdTime: InputMaybe<SortEnumType>;
  id: InputMaybe<SortEnumType>;
  lastUpdatedTime: InputMaybe<SortEnumType>;
};

export type LocalizationText = {
  createdTime: Scalars['Instant']['output'];
  id: Scalars['UUID']['output'];
  language: Language;
  lastUpdatedTime: Scalars['Instant']['output'];
  text: Scalars['String']['output'];
  translationEngine: Maybe<TranslationEngine>;
};

export type LocalizationTextFilterInput = {
  and: InputMaybe<Array<LocalizationTextFilterInput>>;
  createdTime: InputMaybe<InstantFilterInput>;
  id: InputMaybe<UuidOperationFilterInput>;
  language: InputMaybe<LanguageOperationFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  or: InputMaybe<Array<LocalizationTextFilterInput>>;
  text: InputMaybe<StringOperationFilterInput>;
  translationEngine: InputMaybe<TranslationEngineFilterInput>;
};

export type Mutation = {
  deleteJob: DeleteJobPayload;
  fetchChapterContents: FetchChapterContentsPayload;
  importNovel: ImportNovelPayload;
  registerUser: RegisterUserPayload;
  runJob: RunJobPayload;
  scheduleEventJob: ScheduleEventJobPayload;
  translateText: TranslateTextPayload;
};


export type MutationDeleteJobArgs = {
  input: DeleteJobInput;
};


export type MutationFetchChapterContentsArgs = {
  input: FetchChapterContentsInput;
};


export type MutationImportNovelArgs = {
  input: ImportNovelInput;
};


export type MutationRegisterUserArgs = {
  input: RegisterUserInput;
};


export type MutationRunJobArgs = {
  input: RunJobInput;
};


export type MutationScheduleEventJobArgs = {
  input: ScheduleEventJobInput;
};


export type MutationTranslateTextArgs = {
  input: TranslateTextInput;
};

export type Novel = {
  author: Person;
  chapters: Array<Chapter>;
  coverImage: Maybe<Image>;
  createdTime: Scalars['Instant']['output'];
  description: LocalizationKey;
  externalId: Scalars['String']['output'];
  id: Scalars['UnsignedInt']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
  name: LocalizationKey;
  rawLanguage: Language;
  rawStatus: NovelStatus;
  source: Source;
  statusOverride: Maybe<NovelStatus>;
  tags: Array<NovelTag>;
  url: Scalars['String']['output'];
};

export type NovelFilterInput = {
  and: InputMaybe<Array<NovelFilterInput>>;
  author: InputMaybe<PersonFilterInput>;
  chapters: InputMaybe<ListFilterInputTypeOfChapterFilterInput>;
  coverImage: InputMaybe<ImageFilterInput>;
  createdTime: InputMaybe<InstantFilterInput>;
  description: InputMaybe<LocalizationKeyFilterInput>;
  externalId: InputMaybe<StringOperationFilterInput>;
  id: InputMaybe<UnsignedIntOperationFilterInputType>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  name: InputMaybe<LocalizationKeyFilterInput>;
  or: InputMaybe<Array<NovelFilterInput>>;
  rawLanguage: InputMaybe<LanguageOperationFilterInput>;
  rawStatus: InputMaybe<NovelStatusOperationFilterInput>;
  source: InputMaybe<SourceFilterInput>;
  statusOverride: InputMaybe<NullableOfNovelStatusOperationFilterInput>;
  tags: InputMaybe<ListFilterInputTypeOfNovelTagFilterInput>;
  url: InputMaybe<StringOperationFilterInput>;
};

export type NovelSortInput = {
  author: InputMaybe<PersonSortInput>;
  coverImage: InputMaybe<ImageSortInput>;
  createdTime: InputMaybe<SortEnumType>;
  description: InputMaybe<LocalizationKeySortInput>;
  externalId: InputMaybe<SortEnumType>;
  id: InputMaybe<SortEnumType>;
  lastUpdatedTime: InputMaybe<SortEnumType>;
  name: InputMaybe<LocalizationKeySortInput>;
  rawLanguage: InputMaybe<SortEnumType>;
  rawStatus: InputMaybe<SortEnumType>;
  source: InputMaybe<SourceSortInput>;
  statusOverride: InputMaybe<SortEnumType>;
  url: InputMaybe<SortEnumType>;
};

export enum NovelStatus {
  Abandoned = 'ABANDONED',
  Completed = 'COMPLETED',
  Hiatus = 'HIATUS',
  InProgress = 'IN_PROGRESS',
  Unknown = 'UNKNOWN'
}

export type NovelStatusOperationFilterInput = {
  eq: InputMaybe<NovelStatus>;
  in: InputMaybe<Array<NovelStatus>>;
  neq: InputMaybe<NovelStatus>;
  nin: InputMaybe<Array<NovelStatus>>;
};

export type NovelTag = {
  createdTime: Scalars['Instant']['output'];
  displayName: LocalizationKey;
  id: Scalars['UnsignedInt']['output'];
  key: Scalars['String']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
  novels: Array<Novel>;
  source: Maybe<Source>;
  tagType: TagType;
};

export type NovelTagFilterInput = {
  and: InputMaybe<Array<NovelTagFilterInput>>;
  createdTime: InputMaybe<InstantFilterInput>;
  displayName: InputMaybe<LocalizationKeyFilterInput>;
  id: InputMaybe<UnsignedIntOperationFilterInputType>;
  key: InputMaybe<StringOperationFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  novels: InputMaybe<ListFilterInputTypeOfNovelFilterInput>;
  or: InputMaybe<Array<NovelTagFilterInput>>;
  source: InputMaybe<SourceFilterInput>;
  tagType: InputMaybe<TagTypeOperationFilterInput>;
};

export type NovelUpdateRequestedEvent = {
  novelUrl: Scalars['String']['output'];
};

/** A connection to a list of items. */
export type NovelsConnection = {
  /** A list of edges. */
  edges: Maybe<Array<NovelsEdge>>;
  /** A flattened list of the nodes. */
  nodes: Maybe<Array<Novel>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type NovelsEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge. */
  node: Novel;
};

export type NullableOfNovelStatusOperationFilterInput = {
  eq: InputMaybe<NovelStatus>;
  in: InputMaybe<Array<InputMaybe<NovelStatus>>>;
  neq: InputMaybe<NovelStatus>;
  nin: InputMaybe<Array<InputMaybe<NovelStatus>>>;
};

/** Information about pagination in a connection. */
export type PageInfo = {
  /** When paginating forwards, the cursor to continue. */
  endCursor: Maybe<Scalars['String']['output']>;
  /** Indicates whether more edges exist following the set defined by the clients arguments. */
  hasNextPage: Scalars['Boolean']['output'];
  /** Indicates whether more edges exist prior the set defined by the clients arguments. */
  hasPreviousPage: Scalars['Boolean']['output'];
  /** When paginating backwards, the cursor to continue. */
  startCursor: Maybe<Scalars['String']['output']>;
};

export type Person = {
  createdTime: Scalars['Instant']['output'];
  externalUrl: Maybe<Scalars['String']['output']>;
  id: Scalars['UnsignedInt']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
  name: LocalizationKey;
};

export type PersonFilterInput = {
  and: InputMaybe<Array<PersonFilterInput>>;
  createdTime: InputMaybe<InstantFilterInput>;
  externalUrl: InputMaybe<StringOperationFilterInput>;
  id: InputMaybe<UnsignedIntOperationFilterInputType>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  name: InputMaybe<LocalizationKeyFilterInput>;
  or: InputMaybe<Array<PersonFilterInput>>;
};

export type PersonSortInput = {
  createdTime: InputMaybe<SortEnumType>;
  externalUrl: InputMaybe<SortEnumType>;
  id: InputMaybe<SortEnumType>;
  lastUpdatedTime: InputMaybe<SortEnumType>;
  name: InputMaybe<LocalizationKeySortInput>;
};

export type Query = {
  jobs: Array<SchedulerJob>;
  novels: Maybe<NovelsConnection>;
  translationEngines: Array<TranslationEngineDescriptor>;
  translationRequests: Maybe<TranslationRequestsConnection>;
  users: Array<User>;
};


export type QueryNovelsArgs = {
  after: InputMaybe<Scalars['String']['input']>;
  before: InputMaybe<Scalars['String']['input']>;
  first: InputMaybe<Scalars['Int']['input']>;
  last: InputMaybe<Scalars['Int']['input']>;
  order: InputMaybe<Array<NovelSortInput>>;
  where: InputMaybe<NovelFilterInput>;
};


export type QueryTranslationEnginesArgs = {
  order: InputMaybe<Array<TranslationEngineDescriptorSortInput>>;
  where: InputMaybe<TranslationEngineDescriptorFilterInput>;
};


export type QueryTranslationRequestsArgs = {
  after: InputMaybe<Scalars['String']['input']>;
  before: InputMaybe<Scalars['String']['input']>;
  first: InputMaybe<Scalars['Int']['input']>;
  last: InputMaybe<Scalars['Int']['input']>;
  order: InputMaybe<Array<TranslationRequestSortInput>>;
  where: InputMaybe<TranslationRequestFilterInput>;
};

export type RegisterUserInput = {
  email: Scalars['String']['input'];
  inviterOAuthProviderId: InputMaybe<Scalars['String']['input']>;
  oAuthProviderId: Scalars['String']['input'];
  username: Scalars['String']['input'];
};

export type RegisterUserPayload = {
  user: Maybe<User>;
};

export type RunJobError = JobPersistenceError;

export type RunJobInput = {
  jobKey: Scalars['String']['input'];
};

export type RunJobPayload = {
  boolean: Maybe<Scalars['Boolean']['output']>;
  errors: Maybe<Array<RunJobError>>;
};

export type ScheduleEventJobError = DuplicateNameError | FormatError;

export type ScheduleEventJobInput = {
  cronSchedule: Scalars['String']['input'];
  description: Scalars['String']['input'];
  eventData: Scalars['String']['input'];
  eventType: Scalars['String']['input'];
  key: Scalars['String']['input'];
};

export type ScheduleEventJobPayload = {
  errors: Maybe<Array<ScheduleEventJobError>>;
  schedulerJob: Maybe<SchedulerJob>;
};

export type SchedulerJob = {
  cronSchedule: Array<Scalars['String']['output']>;
  description: Scalars['String']['output'];
  jobData: Array<KeyValuePairOfStringAndString>;
  jobKey: JobKey;
  jobTypeName: Scalars['String']['output'];
};

export enum SortEnumType {
  Asc = 'ASC',
  Desc = 'DESC'
}

export type Source = {
  createdTime: Scalars['Instant']['output'];
  id: Scalars['UnsignedInt']['output'];
  key: Scalars['String']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
  name: Scalars['String']['output'];
  url: Scalars['String']['output'];
};

export type SourceFilterInput = {
  and: InputMaybe<Array<SourceFilterInput>>;
  createdTime: InputMaybe<InstantFilterInput>;
  id: InputMaybe<UnsignedIntOperationFilterInputType>;
  key: InputMaybe<StringOperationFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  name: InputMaybe<StringOperationFilterInput>;
  or: InputMaybe<Array<SourceFilterInput>>;
  url: InputMaybe<StringOperationFilterInput>;
};

export type SourceSortInput = {
  createdTime: InputMaybe<SortEnumType>;
  id: InputMaybe<SortEnumType>;
  key: InputMaybe<SortEnumType>;
  lastUpdatedTime: InputMaybe<SortEnumType>;
  name: InputMaybe<SortEnumType>;
  url: InputMaybe<SortEnumType>;
};

export type StringOperationFilterInput = {
  and: InputMaybe<Array<StringOperationFilterInput>>;
  contains: InputMaybe<Scalars['String']['input']>;
  endsWith: InputMaybe<Scalars['String']['input']>;
  eq: InputMaybe<Scalars['String']['input']>;
  in: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  ncontains: InputMaybe<Scalars['String']['input']>;
  nendsWith: InputMaybe<Scalars['String']['input']>;
  neq: InputMaybe<Scalars['String']['input']>;
  nin: InputMaybe<Array<InputMaybe<Scalars['String']['input']>>>;
  nstartsWith: InputMaybe<Scalars['String']['input']>;
  or: InputMaybe<Array<StringOperationFilterInput>>;
  startsWith: InputMaybe<Scalars['String']['input']>;
};

export enum TagType {
  External = 'EXTERNAL',
  Genre = 'GENRE',
  System = 'SYSTEM',
  UserDefined = 'USER_DEFINED'
}

export type TagTypeOperationFilterInput = {
  eq: InputMaybe<TagType>;
  in: InputMaybe<Array<TagType>>;
  neq: InputMaybe<TagType>;
  nin: InputMaybe<Array<TagType>>;
};

export type TranslateTextInput = {
  from: Language;
  text: Scalars['String']['input'];
  to: Language;
  translationEngineKey: Scalars['String']['input'];
};

export type TranslateTextPayload = {
  translationResult: Maybe<TranslationResult>;
};

export type TranslationEngine = {
  createdTime: Scalars['Instant']['output'];
  id: Scalars['UnsignedInt']['output'];
  key: Scalars['String']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
};

export type TranslationEngineDescriptor = {
  displayName: Scalars['String']['output'];
  key: Scalars['String']['output'];
};

export type TranslationEngineDescriptorFilterInput = {
  and: InputMaybe<Array<TranslationEngineDescriptorFilterInput>>;
  displayName: InputMaybe<StringOperationFilterInput>;
  key: InputMaybe<StringOperationFilterInput>;
  or: InputMaybe<Array<TranslationEngineDescriptorFilterInput>>;
};

export type TranslationEngineDescriptorSortInput = {
  displayName: InputMaybe<SortEnumType>;
  key: InputMaybe<SortEnumType>;
};

export type TranslationEngineFilterInput = {
  and: InputMaybe<Array<TranslationEngineFilterInput>>;
  createdTime: InputMaybe<InstantFilterInput>;
  id: InputMaybe<UnsignedIntOperationFilterInputType>;
  key: InputMaybe<StringOperationFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  or: InputMaybe<Array<TranslationEngineFilterInput>>;
};

export type TranslationRequest = {
  billedCharacterCount: Scalars['UnsignedInt']['output'];
  createdTime: Scalars['Instant']['output'];
  from: Language;
  id: Scalars['UUID']['output'];
  lastUpdatedTime: Scalars['Instant']['output'];
  originalText: Scalars['String']['output'];
  status: TranslationRequestStatus;
  to: Language;
  translatedText: Maybe<Scalars['String']['output']>;
  translationEngineKey: Scalars['String']['output'];
};

export type TranslationRequestFilterInput = {
  and: InputMaybe<Array<TranslationRequestFilterInput>>;
  billedCharacterCount: InputMaybe<UnsignedIntOperationFilterInputType>;
  createdTime: InputMaybe<InstantFilterInput>;
  from: InputMaybe<LanguageOperationFilterInput>;
  id: InputMaybe<UuidOperationFilterInput>;
  lastUpdatedTime: InputMaybe<InstantFilterInput>;
  or: InputMaybe<Array<TranslationRequestFilterInput>>;
  originalText: InputMaybe<StringOperationFilterInput>;
  status: InputMaybe<TranslationRequestStatusOperationFilterInput>;
  to: InputMaybe<LanguageOperationFilterInput>;
  translatedText: InputMaybe<StringOperationFilterInput>;
  translationEngineKey: InputMaybe<StringOperationFilterInput>;
};

export type TranslationRequestSortInput = {
  billedCharacterCount: InputMaybe<SortEnumType>;
  createdTime: InputMaybe<SortEnumType>;
  from: InputMaybe<SortEnumType>;
  id: InputMaybe<SortEnumType>;
  lastUpdatedTime: InputMaybe<SortEnumType>;
  originalText: InputMaybe<SortEnumType>;
  status: InputMaybe<SortEnumType>;
  to: InputMaybe<SortEnumType>;
  translatedText: InputMaybe<SortEnumType>;
  translationEngineKey: InputMaybe<SortEnumType>;
};

export enum TranslationRequestStatus {
  Failed = 'FAILED',
  Pending = 'PENDING',
  Success = 'SUCCESS'
}

export type TranslationRequestStatusOperationFilterInput = {
  eq: InputMaybe<TranslationRequestStatus>;
  in: InputMaybe<Array<TranslationRequestStatus>>;
  neq: InputMaybe<TranslationRequestStatus>;
  nin: InputMaybe<Array<TranslationRequestStatus>>;
};

/** A connection to a list of items. */
export type TranslationRequestsConnection = {
  /** A list of edges. */
  edges: Maybe<Array<TranslationRequestsEdge>>;
  /** A flattened list of the nodes. */
  nodes: Maybe<Array<TranslationRequest>>;
  /** Information to aid in pagination. */
  pageInfo: PageInfo;
};

/** An edge in a connection. */
export type TranslationRequestsEdge = {
  /** A cursor for use in pagination. */
  cursor: Scalars['String']['output'];
  /** The item at the end of the edge. */
  node: TranslationRequest;
};

export type TranslationResult = {
  billedCharacterCount: Scalars['UnsignedInt']['output'];
  from: Language;
  originalText: Scalars['String']['output'];
  status: TranslationRequestStatus;
  to: Language;
  translatedText: Maybe<Scalars['String']['output']>;
  translationEngineKey: Scalars['String']['output'];
};

export type UnsignedIntOperationFilterInputType = {
  eq: InputMaybe<Scalars['UnsignedInt']['input']>;
  gt: InputMaybe<Scalars['UnsignedInt']['input']>;
  gte: InputMaybe<Scalars['UnsignedInt']['input']>;
  in: InputMaybe<Array<InputMaybe<Scalars['UnsignedInt']['input']>>>;
  lt: InputMaybe<Scalars['UnsignedInt']['input']>;
  lte: InputMaybe<Scalars['UnsignedInt']['input']>;
  neq: InputMaybe<Scalars['UnsignedInt']['input']>;
  ngt: InputMaybe<Scalars['UnsignedInt']['input']>;
  ngte: InputMaybe<Scalars['UnsignedInt']['input']>;
  nin: InputMaybe<Array<InputMaybe<Scalars['UnsignedInt']['input']>>>;
  nlt: InputMaybe<Scalars['UnsignedInt']['input']>;
  nlte: InputMaybe<Scalars['UnsignedInt']['input']>;
};

export type User = {
  createdTime: Scalars['Instant']['output'];
  disabled: Scalars['Boolean']['output'];
  email: Scalars['String']['output'];
  id: Scalars['UUID']['output'];
  inviter: Maybe<User>;
  lastUpdatedTime: Scalars['Instant']['output'];
  oAuthProviderId: Scalars['String']['output'];
  username: Scalars['String']['output'];
};

export type UuidOperationFilterInput = {
  eq: InputMaybe<Scalars['UUID']['input']>;
  gt: InputMaybe<Scalars['UUID']['input']>;
  gte: InputMaybe<Scalars['UUID']['input']>;
  in: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
  lt: InputMaybe<Scalars['UUID']['input']>;
  lte: InputMaybe<Scalars['UUID']['input']>;
  neq: InputMaybe<Scalars['UUID']['input']>;
  ngt: InputMaybe<Scalars['UUID']['input']>;
  ngte: InputMaybe<Scalars['UUID']['input']>;
  nin: InputMaybe<Array<InputMaybe<Scalars['UUID']['input']>>>;
  nlt: InputMaybe<Scalars['UUID']['input']>;
  nlte: InputMaybe<Scalars['UUID']['input']>;
};

export type NovelsQueryVariables = Exact<{
  first: InputMaybe<Scalars['Int']['input']>;
  after: InputMaybe<Scalars['String']['input']>;
}>;


export type NovelsQuery = { novels: { edges: Array<{ cursor: string, node: { id: any, url: string, name: { texts: Array<{ language: Language, text: string }> }, description: { texts: Array<{ language: Language, text: string }> }, coverImage: { originalPath: string, newPath: string | null } | null } }> | null, pageInfo: { hasNextPage: boolean, endCursor: string | null } } | null };


export const NovelsDocument = gql`
    query Novels($first: Int, $after: String) {
  novels(first: $first, after: $after) {
    edges {
      cursor
      node {
        id
        url
        name {
          texts {
            language
            text
          }
        }
        description {
          texts {
            language
            text
          }
        }
        coverImage {
          originalPath
          newPath
        }
      }
    }
    pageInfo {
      hasNextPage
      endCursor
    }
  }
}
    `;

/**
 * __useNovelsQuery__
 *
 * To run a query within a React component, call `useNovelsQuery` and pass it any options that fit your needs.
 * When your component renders, `useNovelsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useNovelsQuery({
 *   variables: {
 *      first: // value for 'first'
 *      after: // value for 'after'
 *   },
 * });
 */
export function useNovelsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<NovelsQuery, NovelsQueryVariables>) {
        const options = {...defaultOptions, ...baseOptions}
        return ApolloReactHooks.useQuery<NovelsQuery, NovelsQueryVariables>(NovelsDocument, options);
      }
export function useNovelsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<NovelsQuery, NovelsQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return ApolloReactHooks.useLazyQuery<NovelsQuery, NovelsQueryVariables>(NovelsDocument, options);
        }
export function useNovelsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<NovelsQuery, NovelsQueryVariables>) {
          const options = baseOptions === ApolloReactHooks.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
          return ApolloReactHooks.useSuspenseQuery<NovelsQuery, NovelsQueryVariables>(NovelsDocument, options);
        }
export type NovelsQueryHookResult = ReturnType<typeof useNovelsQuery>;
export type NovelsLazyQueryHookResult = ReturnType<typeof useNovelsLazyQuery>;
export type NovelsSuspenseQueryHookResult = ReturnType<typeof useNovelsSuspenseQuery>;
export type NovelsQueryResult = Apollo.QueryResult<NovelsQuery, NovelsQueryVariables>;