import type { GraphQLClient, RequestOptions } from 'graphql-request';
import gql from 'graphql-tag';
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 };
type GraphQLClientRequestHeaders = RequestOptions['requestHeaders'];
/** 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; }
  JSON: { input: any; output: any; }
};

export type Address = {
  __typename?: 'Address';
  authors?: Maybe<Array<Author>>;
  city?: Maybe<City>;
  country?: Maybe<Country>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  street: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  users?: Maybe<Array<User>>;
};

export type AuthPayload = {
  __typename?: 'AuthPayload';
  token: Scalars['String']['output'];
  user: User;
};

export type Author = {
  __typename?: 'Author';
  address?: Maybe<Address>;
  biography?: Maybe<Scalars['String']['output']>;
  birthDate?: Maybe<Scalars['String']['output']>;
  books?: Maybe<Array<Book>>;
  city?: Maybe<City>;
  copyright?: Maybe<Copyright>;
  copyrightClaims?: Maybe<Array<CopyrightClaim>>;
  country?: Maybe<Country>;
  createdAt: Scalars['String']['output'];
  deathDate?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  place?: Maybe<Place>;
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type AuthorInput = {
  addressId?: InputMaybe<Scalars['ID']['input']>;
  biography?: InputMaybe<Scalars['String']['input']>;
  birthDate?: InputMaybe<Scalars['String']['input']>;
  cityId?: InputMaybe<Scalars['ID']['input']>;
  countryId?: InputMaybe<Scalars['ID']['input']>;
  deathDate?: InputMaybe<Scalars['String']['input']>;
  language: Scalars['String']['input'];
  name: Scalars['String']['input'];
  placeId?: InputMaybe<Scalars['ID']['input']>;
};

export type BlogPost = {
  __typename?: 'BlogPost';
  author: Author;
  content: Scalars['String']['output'];
  createdAt: Scalars['String']['output'];
  excerpt?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  publishedAt?: Maybe<Scalars['String']['output']>;
  slug: Scalars['String']['output'];
  title: Scalars['String']['output'];
};

export type Book = {
  __typename?: 'Book';
  copyright?: Maybe<Copyright>;
  copyrightClaims?: Maybe<Array<CopyrightClaim>>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  stats?: Maybe<BookStats>;
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type BookStats = {
  __typename?: 'BookStats';
  book: Book;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  sales: Scalars['Int']['output'];
  updatedAt: Scalars['String']['output'];
};

export type Bookmark = {
  __typename?: 'Bookmark';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name?: Maybe<Scalars['String']['output']>;
  updatedAt: Scalars['String']['output'];
  user: User;
  work: Work;
};

export type BookmarkInput = {
  name?: InputMaybe<Scalars['String']['input']>;
  workId: Scalars['ID']['input'];
};

export type Category = {
  __typename?: 'Category';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type City = {
  __typename?: 'City';
  authors?: Maybe<Array<Author>>;
  country?: Maybe<Country>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  users?: Maybe<Array<User>>;
};

export type Collection = {
  __typename?: 'Collection';
  createdAt: Scalars['String']['output'];
  description?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  stats?: Maybe<CollectionStats>;
  updatedAt: Scalars['String']['output'];
  user?: Maybe<User>;
  works?: Maybe<Array<Work>>;
};

export type CollectionInput = {
  description?: InputMaybe<Scalars['String']['input']>;
  name: Scalars['String']['input'];
  workIds?: InputMaybe<Array<Scalars['ID']['input']>>;
};

export type CollectionStats = {
  __typename?: 'CollectionStats';
  collection: Collection;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  items: Scalars['Int']['output'];
  updatedAt: Scalars['String']['output'];
};

export type Comment = {
  __typename?: 'Comment';
  childComments?: Maybe<Array<Comment>>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  likes?: Maybe<Array<Like>>;
  lineNumber?: Maybe<Scalars['Int']['output']>;
  parentComment?: Maybe<Comment>;
  text: Scalars['String']['output'];
  translation?: Maybe<Translation>;
  updatedAt: Scalars['String']['output'];
  user: User;
  work?: Maybe<Work>;
};

export type CommentInput = {
  lineNumber?: InputMaybe<Scalars['Int']['input']>;
  parentCommentId?: InputMaybe<Scalars['ID']['input']>;
  text: Scalars['String']['input'];
  translationId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
};

export type Concept = {
  __typename?: 'Concept';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  words?: Maybe<Array<Word>>;
  works?: Maybe<Array<Work>>;
};

export type Contribution = {
  __typename?: 'Contribution';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  status: ContributionStatus;
  translation?: Maybe<Translation>;
  updatedAt: Scalars['String']['output'];
  user: User;
  work?: Maybe<Work>;
};

export type ContributionInput = {
  name: Scalars['String']['input'];
  status?: InputMaybe<ContributionStatus>;
  translationId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
};

export enum ContributionStatus {
  APPROVED = 'APPROVED',
  DRAFT = 'DRAFT',
  REJECTED = 'REJECTED',
  SUBMITTED = 'SUBMITTED',
  UNDER_REVIEW = 'UNDER_REVIEW'
}

export type Copyright = {
  __typename?: 'Copyright';
  books?: Maybe<Array<Book>>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  sources?: Maybe<Array<Source>>;
  translations?: Maybe<Array<Translation>>;
  updatedAt: Scalars['String']['output'];
  workOwner?: Maybe<Author>;
  works?: Maybe<Array<Work>>;
};

export type CopyrightClaim = {
  __typename?: 'CopyrightClaim';
  author?: Maybe<Author>;
  book?: Maybe<Book>;
  createdAt: Scalars['String']['output'];
  details: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  source?: Maybe<Source>;
  translation?: Maybe<Translation>;
  updatedAt: Scalars['String']['output'];
  user?: Maybe<User>;
  work?: Maybe<Work>;
};

export type Country = {
  __typename?: 'Country';
  authors?: Maybe<Array<Author>>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  users?: Maybe<Array<User>>;
};

export type Edge = {
  __typename?: 'Edge';
  createdAt: Scalars['String']['output'];
  extra?: Maybe<Scalars['JSON']['output']>;
  id: Scalars['ID']['output'];
  language?: Maybe<Scalars['String']['output']>;
  relation: Scalars['String']['output'];
  sourceId: Scalars['ID']['output'];
  sourceTable: Scalars['String']['output'];
  targetId: Scalars['ID']['output'];
  targetTable: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
};

export type Emotion = {
  __typename?: 'Emotion';
  collection?: Maybe<Collection>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  user?: Maybe<User>;
  work?: Maybe<Work>;
};

export type Like = {
  __typename?: 'Like';
  comment?: Maybe<Comment>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  translation?: Maybe<Translation>;
  updatedAt: Scalars['String']['output'];
  user: User;
  work?: Maybe<Work>;
};

export type LikeInput = {
  commentId?: InputMaybe<Scalars['ID']['input']>;
  translationId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
};

export type LinguisticLayer = {
  __typename?: 'LinguisticLayer';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type Mood = {
  __typename?: 'Mood';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type Mutation = {
  __typename?: 'Mutation';
  addWorkToCollection: Collection;
  changePassword: Scalars['Boolean']['output'];
  createAuthor: Author;
  createBookmark: Bookmark;
  createCollection: Collection;
  createComment: Comment;
  createContribution: Contribution;
  createLike: Like;
  createTranslation: Translation;
  createWork: Work;
  deleteAuthor: Scalars['Boolean']['output'];
  deleteBookmark: Scalars['Boolean']['output'];
  deleteCollection: Scalars['Boolean']['output'];
  deleteComment: Scalars['Boolean']['output'];
  deleteContribution: Scalars['Boolean']['output'];
  deleteLike: Scalars['Boolean']['output'];
  deleteTranslation: Scalars['Boolean']['output'];
  deleteUser: Scalars['Boolean']['output'];
  deleteWork: Scalars['Boolean']['output'];
  forgotPassword: Scalars['Boolean']['output'];
  login: AuthPayload;
  logout: Scalars['Boolean']['output'];
  refreshToken: AuthPayload;
  register: AuthPayload;
  removeWorkFromCollection: Collection;
  resendVerificationEmail: Scalars['Boolean']['output'];
  resetPassword: Scalars['Boolean']['output'];
  reviewContribution: Contribution;
  updateAuthor: Author;
  updateCollection: Collection;
  updateComment: Comment;
  updateContribution: Contribution;
  updateProfile: User;
  updateTranslation: Translation;
  updateUser: User;
  updateWork: Work;
  verifyEmail: Scalars['Boolean']['output'];
};


export type MutationAddWorkToCollectionArgs = {
  collectionId: Scalars['ID']['input'];
  workId: Scalars['ID']['input'];
};


export type MutationChangePasswordArgs = {
  currentPassword: Scalars['String']['input'];
  newPassword: Scalars['String']['input'];
};


export type MutationCreateAuthorArgs = {
  input: AuthorInput;
};


export type MutationCreateBookmarkArgs = {
  input: BookmarkInput;
};


export type MutationCreateCollectionArgs = {
  input: CollectionInput;
};


export type MutationCreateCommentArgs = {
  input: CommentInput;
};


export type MutationCreateContributionArgs = {
  input: ContributionInput;
};


export type MutationCreateLikeArgs = {
  input: LikeInput;
};


export type MutationCreateTranslationArgs = {
  input: TranslationInput;
};


export type MutationCreateWorkArgs = {
  input: WorkInput;
};


export type MutationDeleteAuthorArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteBookmarkArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteCollectionArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteCommentArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteContributionArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteLikeArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteTranslationArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteUserArgs = {
  id: Scalars['ID']['input'];
};


export type MutationDeleteWorkArgs = {
  id: Scalars['ID']['input'];
};


export type MutationForgotPasswordArgs = {
  email: Scalars['String']['input'];
};


export type MutationLoginArgs = {
  email: Scalars['String']['input'];
  password: Scalars['String']['input'];
};


export type MutationRegisterArgs = {
  input: RegisterInput;
};


export type MutationRemoveWorkFromCollectionArgs = {
  collectionId: Scalars['ID']['input'];
  workId: Scalars['ID']['input'];
};


export type MutationResendVerificationEmailArgs = {
  email: Scalars['String']['input'];
};


export type MutationResetPasswordArgs = {
  newPassword: Scalars['String']['input'];
  token: Scalars['String']['input'];
};


export type MutationReviewContributionArgs = {
  feedback?: InputMaybe<Scalars['String']['input']>;
  id: Scalars['ID']['input'];
  status: ContributionStatus;
};


export type MutationUpdateAuthorArgs = {
  id: Scalars['ID']['input'];
  input: AuthorInput;
};


export type MutationUpdateCollectionArgs = {
  id: Scalars['ID']['input'];
  input: CollectionInput;
};


export type MutationUpdateCommentArgs = {
  id: Scalars['ID']['input'];
  input: CommentInput;
};


export type MutationUpdateContributionArgs = {
  id: Scalars['ID']['input'];
  input: ContributionInput;
};


export type MutationUpdateProfileArgs = {
  input: UserInput;
};


export type MutationUpdateTranslationArgs = {
  id: Scalars['ID']['input'];
  input: TranslationInput;
};


export type MutationUpdateUserArgs = {
  id: Scalars['ID']['input'];
  input: UserInput;
};


export type MutationUpdateWorkArgs = {
  id: Scalars['ID']['input'];
  input: WorkInput;
};


export type MutationVerifyEmailArgs = {
  token: Scalars['String']['input'];
};

export type Place = {
  __typename?: 'Place';
  authors?: Maybe<Array<Author>>;
  city?: Maybe<City>;
  country?: Maybe<Country>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
};

export type PoeticAnalysis = {
  __typename?: 'PoeticAnalysis';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  structure: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  work: Work;
};

export type Query = {
  __typename?: 'Query';
  author?: Maybe<Author>;
  authors: Array<Author>;
  blog?: Maybe<BlogPost>;
  blogs: Array<BlogPost>;
  bookmark?: Maybe<Bookmark>;
  bookmarks: Array<Bookmark>;
  categories: Array<Category>;
  category?: Maybe<Category>;
  collection?: Maybe<Collection>;
  collections: Array<Collection>;
  comment?: Maybe<Comment>;
  comments: Array<Comment>;
  contribution?: Maybe<Contribution>;
  contributions: Array<Contribution>;
  like?: Maybe<Like>;
  likes: Array<Like>;
  me?: Maybe<User>;
  search: SearchResults;
  tag?: Maybe<Tag>;
  tags: Array<Tag>;
  translation?: Maybe<Translation>;
  translations: Array<Translation>;
  user?: Maybe<User>;
  userByEmail?: Maybe<User>;
  userByUsername?: Maybe<User>;
  userProfile?: Maybe<UserProfile>;
  users: Array<User>;
  work?: Maybe<Work>;
  works: Array<Work>;
};


export type QueryAuthorArgs = {
  id: Scalars['ID']['input'];
};


export type QueryAuthorsArgs = {
  countryId?: InputMaybe<Scalars['ID']['input']>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  search?: InputMaybe<Scalars['String']['input']>;
};


export type QueryBlogArgs = {
  id: Scalars['ID']['input'];
};


export type QueryBlogsArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  userId?: InputMaybe<Scalars['ID']['input']>;
};


export type QueryBookmarkArgs = {
  id: Scalars['ID']['input'];
};


export type QueryBookmarksArgs = {
  userId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
};


export type QueryCategoriesArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};


export type QueryCategoryArgs = {
  id: Scalars['ID']['input'];
};


export type QueryCollectionArgs = {
  id: Scalars['ID']['input'];
};


export type QueryCollectionsArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  userId?: InputMaybe<Scalars['ID']['input']>;
};


export type QueryCommentArgs = {
  id: Scalars['ID']['input'];
};


export type QueryCommentsArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  translationId?: InputMaybe<Scalars['ID']['input']>;
  userId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
};


export type QueryContributionArgs = {
  id: Scalars['ID']['input'];
};


export type QueryContributionsArgs = {
  translationId?: InputMaybe<Scalars['ID']['input']>;
  userId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
};


export type QueryLikeArgs = {
  id: Scalars['ID']['input'];
};


export type QueryLikesArgs = {
  commentId?: InputMaybe<Scalars['ID']['input']>;
  translationId?: InputMaybe<Scalars['ID']['input']>;
  userId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
};


export type QuerySearchArgs = {
  filters?: InputMaybe<SearchFilters>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  query: Scalars['String']['input'];
};


export type QueryTagArgs = {
  id: Scalars['ID']['input'];
};


export type QueryTagsArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
};


export type QueryTranslationArgs = {
  id: Scalars['ID']['input'];
};


export type QueryTranslationsArgs = {
  language?: InputMaybe<Scalars['String']['input']>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  workId: Scalars['ID']['input'];
};


export type QueryUserArgs = {
  id: Scalars['ID']['input'];
};


export type QueryUserByEmailArgs = {
  email: Scalars['String']['input'];
};


export type QueryUserByUsernameArgs = {
  username: Scalars['String']['input'];
};


export type QueryUserProfileArgs = {
  userId: Scalars['ID']['input'];
};


export type QueryUsersArgs = {
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  role?: InputMaybe<UserRole>;
};


export type QueryWorkArgs = {
  id: Scalars['ID']['input'];
};


export type QueryWorksArgs = {
  authorId?: InputMaybe<Scalars['ID']['input']>;
  categoryId?: InputMaybe<Scalars['ID']['input']>;
  language?: InputMaybe<Scalars['String']['input']>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  search?: InputMaybe<Scalars['String']['input']>;
  tagId?: InputMaybe<Scalars['ID']['input']>;
};

export type ReadabilityScore = {
  __typename?: 'ReadabilityScore';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  score: Scalars['Float']['output'];
  updatedAt: Scalars['String']['output'];
  work?: Maybe<Work>;
};

export type RegisterInput = {
  email: Scalars['String']['input'];
  firstName: Scalars['String']['input'];
  lastName: Scalars['String']['input'];
  password: Scalars['String']['input'];
  username: Scalars['String']['input'];
};

export type SearchFilters = {
  authors?: InputMaybe<Array<Scalars['ID']['input']>>;
  categories?: InputMaybe<Array<Scalars['ID']['input']>>;
  dateFrom?: InputMaybe<Scalars['String']['input']>;
  dateTo?: InputMaybe<Scalars['String']['input']>;
  languages?: InputMaybe<Array<Scalars['String']['input']>>;
  tags?: InputMaybe<Array<Scalars['ID']['input']>>;
};

export type SearchResults = {
  __typename?: 'SearchResults';
  authors: Array<Author>;
  total: Scalars['Int']['output'];
  translations: Array<Translation>;
  works: Array<Work>;
};

export type Source = {
  __typename?: 'Source';
  copyright?: Maybe<Copyright>;
  copyrightClaims?: Maybe<Array<CopyrightClaim>>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type Tag = {
  __typename?: 'Tag';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type TextMetadata = {
  __typename?: 'TextMetadata';
  analysis: Scalars['String']['output'];
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  work: Work;
};

export type TopicCluster = {
  __typename?: 'TopicCluster';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type Translation = {
  __typename?: 'Translation';
  comments?: Maybe<Array<Comment>>;
  content?: Maybe<Scalars['String']['output']>;
  copyright?: Maybe<Copyright>;
  copyrightClaims?: Maybe<Array<CopyrightClaim>>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  likes?: Maybe<Array<Like>>;
  name: Scalars['String']['output'];
  stats?: Maybe<TranslationStats>;
  translator?: Maybe<User>;
  updatedAt: Scalars['String']['output'];
  work: Work;
  workId: Scalars['ID']['output'];
};

export type TranslationInput = {
  content?: InputMaybe<Scalars['String']['input']>;
  language: Scalars['String']['input'];
  name: Scalars['String']['input'];
  workId: Scalars['ID']['input'];
};

export type TranslationStats = {
  __typename?: 'TranslationStats';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  translation: Translation;
  updatedAt: Scalars['String']['output'];
  views: Scalars['Int']['output'];
};

export type User = {
  __typename?: 'User';
  active: Scalars['Boolean']['output'];
  address?: Maybe<Address>;
  avatarUrl?: Maybe<Scalars['String']['output']>;
  bio?: Maybe<Scalars['String']['output']>;
  bookmarks?: Maybe<Array<Bookmark>>;
  city?: Maybe<City>;
  collections?: Maybe<Array<Collection>>;
  comments?: Maybe<Array<Comment>>;
  contributions?: Maybe<Array<Contribution>>;
  country?: Maybe<Country>;
  createdAt: Scalars['String']['output'];
  displayName?: Maybe<Scalars['String']['output']>;
  email: Scalars['String']['output'];
  firstName?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  lastLoginAt?: Maybe<Scalars['String']['output']>;
  lastName?: Maybe<Scalars['String']['output']>;
  likes?: Maybe<Array<Like>>;
  role: UserRole;
  stats?: Maybe<UserStats>;
  translations?: Maybe<Array<Translation>>;
  updatedAt: Scalars['String']['output'];
  username: Scalars['String']['output'];
  verified: Scalars['Boolean']['output'];
};

export type UserInput = {
  active?: InputMaybe<Scalars['Boolean']['input']>;
  addressId?: InputMaybe<Scalars['ID']['input']>;
  avatarUrl?: InputMaybe<Scalars['String']['input']>;
  bio?: InputMaybe<Scalars['String']['input']>;
  cityId?: InputMaybe<Scalars['ID']['input']>;
  countryId?: InputMaybe<Scalars['ID']['input']>;
  displayName?: InputMaybe<Scalars['String']['input']>;
  email?: InputMaybe<Scalars['String']['input']>;
  firstName?: InputMaybe<Scalars['String']['input']>;
  lastName?: InputMaybe<Scalars['String']['input']>;
  password?: InputMaybe<Scalars['String']['input']>;
  role?: InputMaybe<UserRole>;
  username?: InputMaybe<Scalars['String']['input']>;
  verified?: InputMaybe<Scalars['Boolean']['input']>;
};

export type UserProfile = {
  __typename?: 'UserProfile';
  createdAt: Scalars['String']['output'];
  facebook?: Maybe<Scalars['String']['output']>;
  github?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  linkedIn?: Maybe<Scalars['String']['output']>;
  phoneNumber?: Maybe<Scalars['String']['output']>;
  preferences?: Maybe<Scalars['JSON']['output']>;
  settings?: Maybe<Scalars['JSON']['output']>;
  twitter?: Maybe<Scalars['String']['output']>;
  updatedAt: Scalars['String']['output'];
  user: User;
  userId: Scalars['ID']['output'];
  website?: Maybe<Scalars['String']['output']>;
};

export enum UserRole {
  ADMIN = 'ADMIN',
  CONTRIBUTOR = 'CONTRIBUTOR',
  EDITOR = 'EDITOR',
  READER = 'READER',
  REVIEWER = 'REVIEWER'
}

export type UserStats = {
  __typename?: 'UserStats';
  activity: Scalars['Int']['output'];
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  updatedAt: Scalars['String']['output'];
  user: User;
};

export type Word = {
  __typename?: 'Word';
  concept?: Maybe<Concept>;
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  works?: Maybe<Array<Work>>;
};

export type Work = {
  __typename?: 'Work';
  authors?: Maybe<Array<Author>>;
  bookmarks?: Maybe<Array<Bookmark>>;
  categories?: Maybe<Array<Category>>;
  collections?: Maybe<Array<Collection>>;
  comments?: Maybe<Array<Comment>>;
  concepts?: Maybe<Array<Concept>>;
  content?: Maybe<Scalars['String']['output']>;
  copyright?: Maybe<Copyright>;
  copyrightClaims?: Maybe<Array<CopyrightClaim>>;
  createdAt: Scalars['String']['output'];
  emotions?: Maybe<Array<Emotion>>;
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  likes?: Maybe<Array<Like>>;
  linguisticLayers?: Maybe<Array<LinguisticLayer>>;
  moods?: Maybe<Array<Mood>>;
  name: Scalars['String']['output'];
  poeticAnalysis?: Maybe<PoeticAnalysis>;
  readabilityScore?: Maybe<ReadabilityScore>;
  stats?: Maybe<WorkStats>;
  tags?: Maybe<Array<Tag>>;
  textMetadata?: Maybe<TextMetadata>;
  topicClusters?: Maybe<Array<TopicCluster>>;
  translations?: Maybe<Array<Translation>>;
  updatedAt: Scalars['String']['output'];
  writingStyle?: Maybe<WritingStyle>;
};

export type WorkInput = {
  authorIds?: InputMaybe<Array<Scalars['ID']['input']>>;
  categoryIds?: InputMaybe<Array<Scalars['ID']['input']>>;
  content?: InputMaybe<Scalars['String']['input']>;
  language: Scalars['String']['input'];
  name: Scalars['String']['input'];
  tagIds?: InputMaybe<Array<Scalars['ID']['input']>>;
};

export type WorkStats = {
  __typename?: 'WorkStats';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  updatedAt: Scalars['String']['output'];
  views: Scalars['Int']['output'];
  work: Work;
};

export type WritingStyle = {
  __typename?: 'WritingStyle';
  createdAt: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  language: Scalars['String']['output'];
  name: Scalars['String']['output'];
  updatedAt: Scalars['String']['output'];
  work?: Maybe<Work>;
};

export type RegisterMutationVariables = Exact<{
  input: RegisterInput;
}>;


export type RegisterMutation = { __typename?: 'Mutation', register: { __typename?: 'AuthPayload', token: string, user: { __typename?: 'User', id: string, username: string, email: string } } };

export type LoginMutationVariables = Exact<{
  email: Scalars['String']['input'];
  password: Scalars['String']['input'];
}>;


export type LoginMutation = { __typename?: 'Mutation', login: { __typename?: 'AuthPayload', token: string, user: { __typename?: 'User', id: string, username: string, email: string } } };

export type LogoutMutationVariables = Exact<{ [key: string]: never; }>;


export type LogoutMutation = { __typename?: 'Mutation', logout: boolean };

export type RefreshTokenMutationVariables = Exact<{ [key: string]: never; }>;


export type RefreshTokenMutation = { __typename?: 'Mutation', refreshToken: { __typename?: 'AuthPayload', token: string, user: { __typename?: 'User', id: string, username: string, email: string } } };

export type GetAuthorQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetAuthorQuery = { __typename?: 'Query', author?: { __typename?: 'Author', id: string, name: string, biography?: string | null, createdAt: string, updatedAt: string } | null };

export type AuthorsQueryVariables = Exact<{
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  search?: InputMaybe<Scalars['String']['input']>;
  countryId?: InputMaybe<Scalars['ID']['input']>;
}>;


export type AuthorsQuery = { __typename?: 'Query', authors: Array<{ __typename?: 'Author', id: string, name: string, createdAt: string }> };

export type CreateAuthorMutationVariables = Exact<{
  input: AuthorInput;
}>;


export type CreateAuthorMutation = { __typename?: 'Mutation', createAuthor: { __typename?: 'Author', id: string, name: string, createdAt: string } };

export type GetBookmarkQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetBookmarkQuery = { __typename?: 'Query', bookmark?: { __typename?: 'Bookmark', id: string, name?: string | null, createdAt: string, user: { __typename?: 'User', id: string, username: string }, work: { __typename?: 'Work', id: string, name: string } } | null };

export type BookmarksQueryVariables = Exact<{
  userId?: InputMaybe<Scalars['ID']['input']>;
}>;


export type BookmarksQuery = { __typename?: 'Query', bookmarks: Array<{ __typename?: 'Bookmark', id: string, name?: string | null, createdAt: string, work: { __typename?: 'Work', id: string, name: string } }> };

export type CreateBookmarkMutationVariables = Exact<{
  input: BookmarkInput;
}>;


export type CreateBookmarkMutation = { __typename?: 'Mutation', createBookmark: { __typename?: 'Bookmark', id: string, name?: string | null, createdAt: string, work: { __typename?: 'Work', id: string, name: string } } };

export type DeleteBookmarkMutationVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type DeleteBookmarkMutation = { __typename?: 'Mutation', deleteBookmark: boolean };

export type GetCategoryQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetCategoryQuery = { __typename?: 'Query', category?: { __typename?: 'Category', id: string, name: string, createdAt: string, updatedAt: string, works?: Array<{ __typename?: 'Work', id: string, name: string }> | null } | null };

export type CategoriesQueryVariables = Exact<{
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
}>;


export type CategoriesQuery = { __typename?: 'Query', categories: Array<{ __typename?: 'Category', id: string, name: string, createdAt: string, updatedAt: string }> };

export type GetCollectionQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetCollectionQuery = { __typename?: 'Query', collection?: { __typename?: 'Collection', id: string, name: string, description?: string | null, createdAt: string, updatedAt: string, works?: Array<{ __typename?: 'Work', id: string, name: string }> | null, user?: { __typename?: 'User', id: string, username: string } | null } | null };

export type CollectionsQueryVariables = Exact<{
  userId?: InputMaybe<Scalars['ID']['input']>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
}>;


export type CollectionsQuery = { __typename?: 'Query', collections: Array<{ __typename?: 'Collection', id: string, name: string, description?: string | null, createdAt: string, updatedAt: string }> };

export type CreateCollectionMutationVariables = Exact<{
  input: CollectionInput;
}>;


export type CreateCollectionMutation = { __typename?: 'Mutation', createCollection: { __typename?: 'Collection', id: string, name: string, description?: string | null, createdAt: string, updatedAt: string } };

export type UpdateCollectionMutationVariables = Exact<{
  id: Scalars['ID']['input'];
  input: CollectionInput;
}>;


export type UpdateCollectionMutation = { __typename?: 'Mutation', updateCollection: { __typename?: 'Collection', id: string, name: string, description?: string | null, updatedAt: string } };

export type DeleteCollectionMutationVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type DeleteCollectionMutation = { __typename?: 'Mutation', deleteCollection: boolean };

export type AddWorkToCollectionMutationVariables = Exact<{
  collectionId: Scalars['ID']['input'];
  workId: Scalars['ID']['input'];
}>;


export type AddWorkToCollectionMutation = { __typename?: 'Mutation', addWorkToCollection: { __typename?: 'Collection', id: string, name: string, works?: Array<{ __typename?: 'Work', id: string, name: string }> | null } };

export type RemoveWorkFromCollectionMutationVariables = Exact<{
  collectionId: Scalars['ID']['input'];
  workId: Scalars['ID']['input'];
}>;


export type RemoveWorkFromCollectionMutation = { __typename?: 'Mutation', removeWorkFromCollection: { __typename?: 'Collection', id: string, name: string, works?: Array<{ __typename?: 'Work', id: string, name: string }> | null } };

export type GetCommentQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetCommentQuery = { __typename?: 'Query', comment?: { __typename?: 'Comment', id: string, text: string, createdAt: string, updatedAt: string, user: { __typename?: 'User', id: string, username: string, displayName?: string | null }, work?: { __typename?: 'Work', id: string, name: string } | null, translation?: { __typename?: 'Translation', id: string, name: string } | null, parentComment?: { __typename?: 'Comment', id: string } | null } | null };

export type CommentsQueryVariables = Exact<{
  workId?: InputMaybe<Scalars['ID']['input']>;
  translationId?: InputMaybe<Scalars['ID']['input']>;
  userId?: InputMaybe<Scalars['ID']['input']>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
}>;


export type CommentsQuery = { __typename?: 'Query', comments: Array<{ __typename?: 'Comment', id: string, text: string, createdAt: string, user: { __typename?: 'User', id: string, username: string, displayName?: string | null } }> };

export type CreateCommentMutationVariables = Exact<{
  input: CommentInput;
}>;


export type CreateCommentMutation = { __typename?: 'Mutation', createComment: { __typename?: 'Comment', id: string, text: string, createdAt: string, user: { __typename?: 'User', id: string, username: string } } };

export type UpdateCommentMutationVariables = Exact<{
  id: Scalars['ID']['input'];
  input: CommentInput;
}>;


export type UpdateCommentMutation = { __typename?: 'Mutation', updateComment: { __typename?: 'Comment', id: string, text: string, updatedAt: string } };

export type DeleteCommentMutationVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type DeleteCommentMutation = { __typename?: 'Mutation', deleteComment: boolean };

export type GetContributionQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetContributionQuery = { __typename?: 'Query', contribution?: { __typename?: 'Contribution', id: string, name: string, status: ContributionStatus, createdAt: string, updatedAt: string, user: { __typename?: 'User', id: string, username: string }, work?: { __typename?: 'Work', id: string, name: string } | null, translation?: { __typename?: 'Translation', id: string, name: string } | null } | null };

export type ContributionsQueryVariables = Exact<{
  userId?: InputMaybe<Scalars['ID']['input']>;
  workId?: InputMaybe<Scalars['ID']['input']>;
  translationId?: InputMaybe<Scalars['ID']['input']>;
}>;


export type ContributionsQuery = { __typename?: 'Query', contributions: Array<{ __typename?: 'Contribution', id: string, name: string, status: ContributionStatus, createdAt: string, updatedAt: string }> };

export type CreateContributionMutationVariables = Exact<{
  input: ContributionInput;
}>;


export type CreateContributionMutation = { __typename?: 'Mutation', createContribution: { __typename?: 'Contribution', id: string, name: string, status: ContributionStatus, createdAt: string } };

export type UpdateContributionMutationVariables = Exact<{
  id: Scalars['ID']['input'];
  input: ContributionInput;
}>;


export type UpdateContributionMutation = { __typename?: 'Mutation', updateContribution: { __typename?: 'Contribution', id: string, name: string, status: ContributionStatus, updatedAt: string } };

export type DeleteContributionMutationVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type DeleteContributionMutation = { __typename?: 'Mutation', deleteContribution: boolean };

export type ReviewContributionMutationVariables = Exact<{
  id: Scalars['ID']['input'];
  status: ContributionStatus;
  feedback?: InputMaybe<Scalars['String']['input']>;
}>;


export type ReviewContributionMutation = { __typename?: 'Mutation', reviewContribution: { __typename?: 'Contribution', id: string, status: ContributionStatus, updatedAt: string } };

export type GetLikeQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetLikeQuery = { __typename?: 'Query', like?: { __typename?: 'Like', id: string, createdAt: string, user: { __typename?: 'User', id: string, username: string }, work?: { __typename?: 'Work', id: string, name: string } | null, translation?: { __typename?: 'Translation', id: string, name: string } | null, comment?: { __typename?: 'Comment', id: string } | null } | null };

export type LikesQueryVariables = Exact<{
  workId?: InputMaybe<Scalars['ID']['input']>;
  translationId?: InputMaybe<Scalars['ID']['input']>;
  commentId?: InputMaybe<Scalars['ID']['input']>;
}>;


export type LikesQuery = { __typename?: 'Query', likes: Array<{ __typename?: 'Like', id: string, createdAt: string, user: { __typename?: 'User', id: string, username: string } }> };

export type CreateLikeMutationVariables = Exact<{
  input: LikeInput;
}>;


export type CreateLikeMutation = { __typename?: 'Mutation', createLike: { __typename?: 'Like', id: string, createdAt: string, user: { __typename?: 'User', id: string, username: string } } };

export type DeleteLikeMutationVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type DeleteLikeMutation = { __typename?: 'Mutation', deleteLike: boolean };

export type SearchQueryVariables = Exact<{
  query: Scalars['String']['input'];
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  filters?: InputMaybe<SearchFilters>;
}>;


export type SearchQuery = { __typename?: 'Query', search: { __typename?: 'SearchResults', total: number, works: Array<{ __typename?: 'Work', id: string, name: string }>, authors: Array<{ __typename?: 'Author', id: string, name: string }>, translations: Array<{ __typename?: 'Translation', id: string, name: string }> } };

export type WorkStatsQueryVariables = Exact<{ [key: string]: never; }>;


export type WorkStatsQuery = { __typename?: 'Query', works: Array<{ __typename?: 'Work', id: string, name: string }> };

export type UserStatsQueryVariables = Exact<{ [key: string]: never; }>;


export type UserStatsQuery = { __typename?: 'Query', users: Array<{ __typename?: 'User', id: string, username: string }> };

export type BlogStatsQueryVariables = Exact<{ [key: string]: never; }>;


export type BlogStatsQuery = { __typename?: 'Query', blog?: { __typename?: 'BlogPost', id: string, title: string } | null };

export type CommentStatsQueryVariables = Exact<{ [key: string]: never; }>;


export type CommentStatsQuery = { __typename?: 'Query', comments: Array<{ __typename?: 'Comment', id: string, text: string }> };

export type GetTagQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetTagQuery = { __typename?: 'Query', tag?: { __typename?: 'Tag', id: string, name: string, createdAt: string } | null };

export type TagsQueryVariables = Exact<{
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
}>;


export type TagsQuery = { __typename?: 'Query', tags: Array<{ __typename?: 'Tag', id: string, name: string, createdAt: string }> };

export type GetTranslationQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetTranslationQuery = { __typename?: 'Query', translation?: { __typename?: 'Translation', id: string, name: string, language: string, content?: string | null, createdAt: string, updatedAt: string, work: { __typename?: 'Work', id: string, name: string } } | null };

export type TranslationsQueryVariables = Exact<{
  workId: Scalars['ID']['input'];
  language?: InputMaybe<Scalars['String']['input']>;
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
}>;


export type TranslationsQuery = { __typename?: 'Query', translations: Array<{ __typename?: 'Translation', id: string, name: string, language: string, createdAt: string }> };

export type CreateTranslationMutationVariables = Exact<{
  input: TranslationInput;
}>;


export type CreateTranslationMutation = { __typename?: 'Mutation', createTranslation: { __typename?: 'Translation', id: string, name: string, language: string, createdAt: string } };

export type UpdateTranslationMutationVariables = Exact<{
  id: Scalars['ID']['input'];
  input: TranslationInput;
}>;


export type UpdateTranslationMutation = { __typename?: 'Mutation', updateTranslation: { __typename?: 'Translation', id: string, name: string, language: string, updatedAt: string } };

export type DeleteTranslationMutationVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type DeleteTranslationMutation = { __typename?: 'Mutation', deleteTranslation: boolean };

export type GetUserQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetUserQuery = { __typename?: 'Query', user?: { __typename?: 'User', id: string, username: string, email: string, displayName?: string | null, role: UserRole, createdAt: string, updatedAt: string } | null };

export type UsersQueryVariables = Exact<{
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  role?: InputMaybe<UserRole>;
}>;


export type UsersQuery = { __typename?: 'Query', users: Array<{ __typename?: 'User', id: string, username: string, email: string, displayName?: string | null, role: UserRole, createdAt: string, updatedAt: string }> };

export type UpdateUserMutationVariables = Exact<{
  id: Scalars['ID']['input'];
  input: UserInput;
}>;


export type UpdateUserMutation = { __typename?: 'Mutation', updateUser: { __typename?: 'User', id: string, username: string, email: string, displayName?: string | null, role: UserRole, createdAt: string, updatedAt: string } };

export type DeleteUserMutationVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type DeleteUserMutation = { __typename?: 'Mutation', deleteUser: boolean };

export type GetUserProfileQueryVariables = Exact<{
  userId: Scalars['ID']['input'];
}>;


export type GetUserProfileQuery = { __typename?: 'Query', userProfile?: { __typename?: 'UserProfile', id: string, userId: string, phoneNumber?: string | null, website?: string | null, twitter?: string | null, facebook?: string | null, linkedIn?: string | null, github?: string | null, preferences?: any | null, settings?: any | null, createdAt: string, updatedAt: string } | null };

export type GetWorkQueryVariables = Exact<{
  id: Scalars['ID']['input'];
}>;


export type GetWorkQuery = { __typename?: 'Query', work?: { __typename?: 'Work', id: string, name: string, language: string, createdAt: string, updatedAt: string } | null };

export type WorksQueryVariables = Exact<{
  limit?: InputMaybe<Scalars['Int']['input']>;
  offset?: InputMaybe<Scalars['Int']['input']>;
  language?: InputMaybe<Scalars['String']['input']>;
  authorId?: InputMaybe<Scalars['ID']['input']>;
  tagId?: InputMaybe<Scalars['ID']['input']>;
  search?: InputMaybe<Scalars['String']['input']>;
}>;


export type WorksQuery = { __typename?: 'Query', works: Array<{ __typename?: 'Work', id: string, name: string, language: string, createdAt: string }> };

export type CreateWorkMutationVariables = Exact<{
  input: WorkInput;
}>;


export type CreateWorkMutation = { __typename?: 'Mutation', createWork: { __typename?: 'Work', id: string, name: string, language: string, createdAt: string } };


export const RegisterDocument = gql`
    mutation Register($input: RegisterInput!) {
  register(input: $input) {
    token
    user {
      id
      username
      email
    }
  }
}
    `;
export const LoginDocument = gql`
    mutation Login($email: String!, $password: String!) {
  login(email: $email, password: $password) {
    token
    user {
      id
      username
      email
    }
  }
}
    `;
export const LogoutDocument = gql`
    mutation Logout {
  logout
}
    `;
export const RefreshTokenDocument = gql`
    mutation RefreshToken {
  refreshToken {
    token
    user {
      id
      username
      email
    }
  }
}
    `;
export const GetAuthorDocument = gql`
    query GetAuthor($id: ID!) {
  author(id: $id) {
    id
    name
    biography
    createdAt
    updatedAt
  }
}
    `;
export const AuthorsDocument = gql`
    query Authors($limit: Int, $offset: Int, $search: String, $countryId: ID) {
  authors(limit: $limit, offset: $offset, search: $search, countryId: $countryId) {
    id
    name
    createdAt
  }
}
    `;
export const CreateAuthorDocument = gql`
    mutation CreateAuthor($input: AuthorInput!) {
  createAuthor(input: $input) {
    id
    name
    createdAt
  }
}
    `;
export const GetBookmarkDocument = gql`
    query GetBookmark($id: ID!) {
  bookmark(id: $id) {
    id
    name
    createdAt
    user {
      id
      username
    }
    work {
      id
      name
    }
  }
}
    `;
export const BookmarksDocument = gql`
    query Bookmarks($userId: ID) {
  bookmarks(userId: $userId) {
    id
    name
    createdAt
    work {
      id
      name
    }
  }
}
    `;
export const CreateBookmarkDocument = gql`
    mutation CreateBookmark($input: BookmarkInput!) {
  createBookmark(input: $input) {
    id
    name
    createdAt
    work {
      id
      name
    }
  }
}
    `;
export const DeleteBookmarkDocument = gql`
    mutation DeleteBookmark($id: ID!) {
  deleteBookmark(id: $id)
}
    `;
export const GetCategoryDocument = gql`
    query GetCategory($id: ID!) {
  category(id: $id) {
    id
    name
    createdAt
    updatedAt
    works {
      id
      name
    }
  }
}
    `;
export const CategoriesDocument = gql`
    query Categories($limit: Int, $offset: Int) {
  categories(limit: $limit, offset: $offset) {
    id
    name
    createdAt
    updatedAt
  }
}
    `;
export const GetCollectionDocument = gql`
    query GetCollection($id: ID!) {
  collection(id: $id) {
    id
    name
    description
    createdAt
    updatedAt
    works {
      id
      name
    }
    user {
      id
      username
    }
  }
}
    `;
export const CollectionsDocument = gql`
    query Collections($userId: ID, $limit: Int, $offset: Int) {
  collections(userId: $userId, limit: $limit, offset: $offset) {
    id
    name
    description
    createdAt
    updatedAt
  }
}
    `;
export const CreateCollectionDocument = gql`
    mutation CreateCollection($input: CollectionInput!) {
  createCollection(input: $input) {
    id
    name
    description
    createdAt
    updatedAt
  }
}
    `;
export const UpdateCollectionDocument = gql`
    mutation UpdateCollection($id: ID!, $input: CollectionInput!) {
  updateCollection(id: $id, input: $input) {
    id
    name
    description
    updatedAt
  }
}
    `;
export const DeleteCollectionDocument = gql`
    mutation DeleteCollection($id: ID!) {
  deleteCollection(id: $id)
}
    `;
export const AddWorkToCollectionDocument = gql`
    mutation AddWorkToCollection($collectionId: ID!, $workId: ID!) {
  addWorkToCollection(collectionId: $collectionId, workId: $workId) {
    id
    name
    works {
      id
      name
    }
  }
}
    `;
export const RemoveWorkFromCollectionDocument = gql`
    mutation RemoveWorkFromCollection($collectionId: ID!, $workId: ID!) {
  removeWorkFromCollection(collectionId: $collectionId, workId: $workId) {
    id
    name
    works {
      id
      name
    }
  }
}
    `;
export const GetCommentDocument = gql`
    query GetComment($id: ID!) {
  comment(id: $id) {
    id
    text
    createdAt
    updatedAt
    user {
      id
      username
      displayName
    }
    work {
      id
      name
    }
    translation {
      id
      name
    }
    parentComment {
      id
    }
  }
}
    `;
export const CommentsDocument = gql`
    query Comments($workId: ID, $translationId: ID, $userId: ID, $limit: Int, $offset: Int) {
  comments(
    workId: $workId
    translationId: $translationId
    userId: $userId
    limit: $limit
    offset: $offset
  ) {
    id
    text
    createdAt
    user {
      id
      username
      displayName
    }
  }
}
    `;
export const CreateCommentDocument = gql`
    mutation CreateComment($input: CommentInput!) {
  createComment(input: $input) {
    id
    text
    createdAt
    user {
      id
      username
    }
  }
}
    `;
export const UpdateCommentDocument = gql`
    mutation UpdateComment($id: ID!, $input: CommentInput!) {
  updateComment(id: $id, input: $input) {
    id
    text
    updatedAt
  }
}
    `;
export const DeleteCommentDocument = gql`
    mutation DeleteComment($id: ID!) {
  deleteComment(id: $id)
}
    `;
export const GetContributionDocument = gql`
    query GetContribution($id: ID!) {
  contribution(id: $id) {
    id
    name
    status
    createdAt
    updatedAt
    user {
      id
      username
    }
    work {
      id
      name
    }
    translation {
      id
      name
    }
  }
}
    `;
export const ContributionsDocument = gql`
    query Contributions($userId: ID, $workId: ID, $translationId: ID) {
  contributions(userId: $userId, workId: $workId, translationId: $translationId) {
    id
    name
    status
    createdAt
    updatedAt
  }
}
    `;
export const CreateContributionDocument = gql`
    mutation CreateContribution($input: ContributionInput!) {
  createContribution(input: $input) {
    id
    name
    status
    createdAt
  }
}
    `;
export const UpdateContributionDocument = gql`
    mutation UpdateContribution($id: ID!, $input: ContributionInput!) {
  updateContribution(id: $id, input: $input) {
    id
    name
    status
    updatedAt
  }
}
    `;
export const DeleteContributionDocument = gql`
    mutation DeleteContribution($id: ID!) {
  deleteContribution(id: $id)
}
    `;
export const ReviewContributionDocument = gql`
    mutation ReviewContribution($id: ID!, $status: ContributionStatus!, $feedback: String) {
  reviewContribution(id: $id, status: $status, feedback: $feedback) {
    id
    status
    updatedAt
  }
}
    `;
export const GetLikeDocument = gql`
    query GetLike($id: ID!) {
  like(id: $id) {
    id
    createdAt
    user {
      id
      username
    }
    work {
      id
      name
    }
    translation {
      id
      name
    }
    comment {
      id
    }
  }
}
    `;
export const LikesDocument = gql`
    query Likes($workId: ID, $translationId: ID, $commentId: ID) {
  likes(workId: $workId, translationId: $translationId, commentId: $commentId) {
    id
    user {
      id
      username
    }
    createdAt
  }
}
    `;
export const CreateLikeDocument = gql`
    mutation CreateLike($input: LikeInput!) {
  createLike(input: $input) {
    id
    createdAt
    user {
      id
      username
    }
  }
}
    `;
export const DeleteLikeDocument = gql`
    mutation DeleteLike($id: ID!) {
  deleteLike(id: $id)
}
    `;
export const SearchDocument = gql`
    query Search($query: String!, $limit: Int, $offset: Int, $filters: SearchFilters) {
  search(query: $query, limit: $limit, offset: $offset, filters: $filters) {
    works {
      id
      name
    }
    authors {
      id
      name
    }
    translations {
      id
      name
    }
    total
  }
}
    `;
export const WorkStatsDocument = gql`
    query WorkStats {
  works: works {
    id
    name
  }
}
    `;
export const UserStatsDocument = gql`
    query UserStats {
  users: users {
    id
    username
  }
}
    `;
export const BlogStatsDocument = gql`
    query BlogStats {
  blog: blog(id: "sample-id") {
    id
    title
  }
}
    `;
export const CommentStatsDocument = gql`
    query CommentStats {
  comments: comments {
    id
    text
  }
}
    `;
export const GetTagDocument = gql`
    query GetTag($id: ID!) {
  tag(id: $id) {
    id
    name
    createdAt
  }
}
    `;
export const TagsDocument = gql`
    query Tags($limit: Int, $offset: Int) {
  tags(limit: $limit, offset: $offset) {
    id
    name
    createdAt
  }
}
    `;
export const GetTranslationDocument = gql`
    query GetTranslation($id: ID!) {
  translation(id: $id) {
    id
    name
    language
    content
    work {
      id
      name
    }
    createdAt
    updatedAt
  }
}
    `;
export const TranslationsDocument = gql`
    query Translations($workId: ID!, $language: String, $limit: Int, $offset: Int) {
  translations(
    workId: $workId
    language: $language
    limit: $limit
    offset: $offset
  ) {
    id
    name
    language
    createdAt
  }
}
    `;
export const CreateTranslationDocument = gql`
    mutation CreateTranslation($input: TranslationInput!) {
  createTranslation(input: $input) {
    id
    name
    language
    createdAt
  }
}
    `;
export const UpdateTranslationDocument = gql`
    mutation UpdateTranslation($id: ID!, $input: TranslationInput!) {
  updateTranslation(id: $id, input: $input) {
    id
    name
    language
    updatedAt
  }
}
    `;
export const DeleteTranslationDocument = gql`
    mutation DeleteTranslation($id: ID!) {
  deleteTranslation(id: $id)
}
    `;
export const GetUserDocument = gql`
    query GetUser($id: ID!) {
  user(id: $id) {
    id
    username
    email
    displayName
    role
    createdAt
    updatedAt
  }
}
    `;
export const UsersDocument = gql`
    query Users($limit: Int, $offset: Int, $role: UserRole) {
  users(limit: $limit, offset: $offset, role: $role) {
    id
    username
    email
    displayName
    role
    createdAt
    updatedAt
  }
}
    `;
export const UpdateUserDocument = gql`
    mutation UpdateUser($id: ID!, $input: UserInput!) {
  updateUser(id: $id, input: $input) {
    id
    username
    email
    displayName
    role
    createdAt
    updatedAt
  }
}
    `;
export const DeleteUserDocument = gql`
    mutation DeleteUser($id: ID!) {
  deleteUser(id: $id)
}
    `;
export const GetUserProfileDocument = gql`
    query GetUserProfile($userId: ID!) {
  userProfile(userId: $userId) {
    id
    userId
    phoneNumber
    website
    twitter
    facebook
    linkedIn
    github
    preferences
    settings
    createdAt
    updatedAt
  }
}
    `;
export const GetWorkDocument = gql`
    query GetWork($id: ID!) {
  work(id: $id) {
    id
    name
    language
    createdAt
    updatedAt
  }
}
    `;
export const WorksDocument = gql`
    query Works($limit: Int, $offset: Int, $language: String, $authorId: ID, $tagId: ID, $search: String) {
  works(
    limit: $limit
    offset: $offset
    language: $language
    authorId: $authorId
    tagId: $tagId
    search: $search
  ) {
    id
    name
    language
    createdAt
  }
}
    `;
export const CreateWorkDocument = gql`
    mutation CreateWork($input: WorkInput!) {
  createWork(input: $input) {
    id
    name
    language
    createdAt
  }
}
    `;

export type SdkFunctionWrapper = <T>(action: (requestHeaders?:Record<string, string>) => Promise<T>, operationName: string, operationType?: string, variables?: any) => Promise<T>;


const defaultWrapper: SdkFunctionWrapper = (action, _operationName, _operationType, _variables) => action();

export function getSdk(client: GraphQLClient, withWrapper: SdkFunctionWrapper = defaultWrapper) {
  return {
    Register(variables: RegisterMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<RegisterMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<RegisterMutation>({ document: RegisterDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Register', 'mutation', variables);
    },
    Login(variables: LoginMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<LoginMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<LoginMutation>({ document: LoginDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Login', 'mutation', variables);
    },
    Logout(variables?: LogoutMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<LogoutMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<LogoutMutation>({ document: LogoutDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Logout', 'mutation', variables);
    },
    RefreshToken(variables?: RefreshTokenMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<RefreshTokenMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<RefreshTokenMutation>({ document: RefreshTokenDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'RefreshToken', 'mutation', variables);
    },
    GetAuthor(variables: GetAuthorQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetAuthorQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetAuthorQuery>({ document: GetAuthorDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetAuthor', 'query', variables);
    },
    Authors(variables?: AuthorsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<AuthorsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<AuthorsQuery>({ document: AuthorsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Authors', 'query', variables);
    },
    CreateAuthor(variables: CreateAuthorMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateAuthorMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateAuthorMutation>({ document: CreateAuthorDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateAuthor', 'mutation', variables);
    },
    GetBookmark(variables: GetBookmarkQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetBookmarkQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetBookmarkQuery>({ document: GetBookmarkDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetBookmark', 'query', variables);
    },
    Bookmarks(variables?: BookmarksQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<BookmarksQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<BookmarksQuery>({ document: BookmarksDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Bookmarks', 'query', variables);
    },
    CreateBookmark(variables: CreateBookmarkMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateBookmarkMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateBookmarkMutation>({ document: CreateBookmarkDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateBookmark', 'mutation', variables);
    },
    DeleteBookmark(variables: DeleteBookmarkMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<DeleteBookmarkMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<DeleteBookmarkMutation>({ document: DeleteBookmarkDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'DeleteBookmark', 'mutation', variables);
    },
    GetCategory(variables: GetCategoryQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetCategoryQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetCategoryQuery>({ document: GetCategoryDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetCategory', 'query', variables);
    },
    Categories(variables?: CategoriesQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CategoriesQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<CategoriesQuery>({ document: CategoriesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Categories', 'query', variables);
    },
    GetCollection(variables: GetCollectionQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetCollectionQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetCollectionQuery>({ document: GetCollectionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetCollection', 'query', variables);
    },
    Collections(variables?: CollectionsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CollectionsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<CollectionsQuery>({ document: CollectionsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Collections', 'query', variables);
    },
    CreateCollection(variables: CreateCollectionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateCollectionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateCollectionMutation>({ document: CreateCollectionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateCollection', 'mutation', variables);
    },
    UpdateCollection(variables: UpdateCollectionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<UpdateCollectionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<UpdateCollectionMutation>({ document: UpdateCollectionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'UpdateCollection', 'mutation', variables);
    },
    DeleteCollection(variables: DeleteCollectionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<DeleteCollectionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<DeleteCollectionMutation>({ document: DeleteCollectionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'DeleteCollection', 'mutation', variables);
    },
    AddWorkToCollection(variables: AddWorkToCollectionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<AddWorkToCollectionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<AddWorkToCollectionMutation>({ document: AddWorkToCollectionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'AddWorkToCollection', 'mutation', variables);
    },
    RemoveWorkFromCollection(variables: RemoveWorkFromCollectionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<RemoveWorkFromCollectionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<RemoveWorkFromCollectionMutation>({ document: RemoveWorkFromCollectionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'RemoveWorkFromCollection', 'mutation', variables);
    },
    GetComment(variables: GetCommentQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetCommentQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetCommentQuery>({ document: GetCommentDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetComment', 'query', variables);
    },
    Comments(variables?: CommentsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CommentsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<CommentsQuery>({ document: CommentsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Comments', 'query', variables);
    },
    CreateComment(variables: CreateCommentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateCommentMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateCommentMutation>({ document: CreateCommentDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateComment', 'mutation', variables);
    },
    UpdateComment(variables: UpdateCommentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<UpdateCommentMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<UpdateCommentMutation>({ document: UpdateCommentDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'UpdateComment', 'mutation', variables);
    },
    DeleteComment(variables: DeleteCommentMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<DeleteCommentMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<DeleteCommentMutation>({ document: DeleteCommentDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'DeleteComment', 'mutation', variables);
    },
    GetContribution(variables: GetContributionQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetContributionQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetContributionQuery>({ document: GetContributionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetContribution', 'query', variables);
    },
    Contributions(variables?: ContributionsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<ContributionsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<ContributionsQuery>({ document: ContributionsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Contributions', 'query', variables);
    },
    CreateContribution(variables: CreateContributionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateContributionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateContributionMutation>({ document: CreateContributionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateContribution', 'mutation', variables);
    },
    UpdateContribution(variables: UpdateContributionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<UpdateContributionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<UpdateContributionMutation>({ document: UpdateContributionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'UpdateContribution', 'mutation', variables);
    },
    DeleteContribution(variables: DeleteContributionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<DeleteContributionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<DeleteContributionMutation>({ document: DeleteContributionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'DeleteContribution', 'mutation', variables);
    },
    ReviewContribution(variables: ReviewContributionMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<ReviewContributionMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<ReviewContributionMutation>({ document: ReviewContributionDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'ReviewContribution', 'mutation', variables);
    },
    GetLike(variables: GetLikeQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetLikeQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetLikeQuery>({ document: GetLikeDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetLike', 'query', variables);
    },
    Likes(variables?: LikesQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<LikesQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<LikesQuery>({ document: LikesDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Likes', 'query', variables);
    },
    CreateLike(variables: CreateLikeMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateLikeMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateLikeMutation>({ document: CreateLikeDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateLike', 'mutation', variables);
    },
    DeleteLike(variables: DeleteLikeMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<DeleteLikeMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<DeleteLikeMutation>({ document: DeleteLikeDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'DeleteLike', 'mutation', variables);
    },
    Search(variables: SearchQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<SearchQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<SearchQuery>({ document: SearchDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Search', 'query', variables);
    },
    WorkStats(variables?: WorkStatsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<WorkStatsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<WorkStatsQuery>({ document: WorkStatsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'WorkStats', 'query', variables);
    },
    UserStats(variables?: UserStatsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<UserStatsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<UserStatsQuery>({ document: UserStatsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'UserStats', 'query', variables);
    },
    BlogStats(variables?: BlogStatsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<BlogStatsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<BlogStatsQuery>({ document: BlogStatsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'BlogStats', 'query', variables);
    },
    CommentStats(variables?: CommentStatsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CommentStatsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<CommentStatsQuery>({ document: CommentStatsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CommentStats', 'query', variables);
    },
    GetTag(variables: GetTagQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetTagQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetTagQuery>({ document: GetTagDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetTag', 'query', variables);
    },
    Tags(variables?: TagsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<TagsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<TagsQuery>({ document: TagsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Tags', 'query', variables);
    },
    GetTranslation(variables: GetTranslationQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetTranslationQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetTranslationQuery>({ document: GetTranslationDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetTranslation', 'query', variables);
    },
    Translations(variables: TranslationsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<TranslationsQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<TranslationsQuery>({ document: TranslationsDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Translations', 'query', variables);
    },
    CreateTranslation(variables: CreateTranslationMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateTranslationMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateTranslationMutation>({ document: CreateTranslationDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateTranslation', 'mutation', variables);
    },
    UpdateTranslation(variables: UpdateTranslationMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<UpdateTranslationMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<UpdateTranslationMutation>({ document: UpdateTranslationDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'UpdateTranslation', 'mutation', variables);
    },
    DeleteTranslation(variables: DeleteTranslationMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<DeleteTranslationMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<DeleteTranslationMutation>({ document: DeleteTranslationDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'DeleteTranslation', 'mutation', variables);
    },
    GetUser(variables: GetUserQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetUserQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetUserQuery>({ document: GetUserDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetUser', 'query', variables);
    },
    Users(variables?: UsersQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<UsersQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<UsersQuery>({ document: UsersDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Users', 'query', variables);
    },
    UpdateUser(variables: UpdateUserMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<UpdateUserMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<UpdateUserMutation>({ document: UpdateUserDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'UpdateUser', 'mutation', variables);
    },
    DeleteUser(variables: DeleteUserMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<DeleteUserMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<DeleteUserMutation>({ document: DeleteUserDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'DeleteUser', 'mutation', variables);
    },
    GetUserProfile(variables: GetUserProfileQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetUserProfileQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetUserProfileQuery>({ document: GetUserProfileDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetUserProfile', 'query', variables);
    },
    GetWork(variables: GetWorkQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<GetWorkQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<GetWorkQuery>({ document: GetWorkDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'GetWork', 'query', variables);
    },
    Works(variables?: WorksQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<WorksQuery> {
      return withWrapper((wrappedRequestHeaders) => client.request<WorksQuery>({ document: WorksDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'Works', 'query', variables);
    },
    CreateWork(variables: CreateWorkMutationVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit['signal']): Promise<CreateWorkMutation> {
      return withWrapper((wrappedRequestHeaders) => client.request<CreateWorkMutation>({ document: CreateWorkDocument, variables, requestHeaders: { ...requestHeaders, ...wrappedRequestHeaders }, signal }), 'CreateWork', 'mutation', variables);
    }
  };
}
export type Sdk = ReturnType<typeof getSdk>;