@eightyfourthousand/client-graphql 2026.4.0 → 2026.4.1

package/lib/generated/graphql.d.ts

@@ -0,0 +1,1062 @@
+import type { GraphQLClient, RequestOptions } from 'graphql-request';
+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 scalar for arbitrary JSON data */
+    JSON: {
+        input: any;
+        output: any;
+    };
+};
+/** An alignment linking a passage to Tibetan source text */
+export type Alignment = {
+    __typename?: 'Alignment';
+    /** Folio number within the volume */
+    folioNumber: Scalars['Int']['output'];
+    /** UUID of the folio containing the Tibetan source */
+    folioUuid: Scalars['ID']['output'];
+    /** Tibetan source text content */
+    tibetan: Scalars['String']['output'];
+    /** Tohoku catalog reference (e.g., "toh123") */
+    toh: Scalars['String']['output'];
+    /** Volume number */
+    volumeNumber: Scalars['Int']['output'];
+};
+/** An annotation marking up a range within a passage */
+export type Annotation = {
+    __typename?: 'Annotation';
+    /** End offset within the passage content */
+    end: Scalars['Int']['output'];
+    /**
+     * Type-specific metadata. Contents vary by annotation type:
+     * - heading: { level, class }
+     * - link: { href, text }
+     * - internalLink: { linkType, href, label, entity, isPending }
+     * - span/mantra/inlineTitle: { textStyle, lang }
+     * - audio: { src, mediaType }
+     * - image: { src }
+     * - list: { spacing, nesting, itemStyle }
+     * - glossaryInstance: { glossary }
+     * - endNoteLink: { endNote, label }
+     * - abbreviation/hasAbbreviation: { abbreviation }
+     * - quote/quoted: { quote }
+     */
+    metadata?: Maybe<Scalars['JSON']['output']>;
+    /** Start offset within the passage content */
+    start: Scalars['Int']['output'];
+    /** Tohoku number associated with this annotation, if applicable */
+    toh?: Maybe<Scalars['String']['output']>;
+    /** Type of annotation (e.g., heading, span, link, internalLink, glossaryInstance) */
+    type: Scalars['String']['output'];
+    /** Unique identifier for the annotation */
+    uuid: Scalars['ID']['output'];
+};
+/** A bibliography section with heading and entries */
+export type BibliographyEntry = {
+    __typename?: 'BibliographyEntry';
+    /** Bibliography entries in this section */
+    entries: Array<BibliographyEntryItem>;
+    /** Section heading */
+    heading?: Maybe<Scalars['String']['output']>;
+};
+/** A single bibliography entry item */
+export type BibliographyEntryItem = {
+    __typename?: 'BibliographyEntryItem';
+    /** HTML content of the bibliography entry */
+    html: Scalars['String']['output'];
+    /** Unique identifier */
+    uuid: Scalars['ID']['output'];
+    /** UUID of the work this entry belongs to */
+    workUuid?: Maybe<Scalars['ID']['output']>;
+};
+/** Currently authenticated user */
+export type CurrentUser = {
+    __typename?: 'CurrentUser';
+    /** User's email address */
+    email: Scalars['String']['output'];
+    /** User's unique identifier */
+    id: Scalars['ID']['output'];
+    /** User's role */
+    role: UserRole;
+};
+/** A folio page from a Tibetan work */
+export type Folio = {
+    __typename?: 'Folio';
+    /** Content of the folio */
+    content: Scalars['String']['output'];
+    /** Folio number within the volume */
+    folio: Scalars['Int']['output'];
+    /** Side of the folio (a or b) */
+    side: FolioSide;
+    /** Unique identifier */
+    uuid: Scalars['ID']['output'];
+    /** Volume number */
+    volume: Scalars['Int']['output'];
+};
+/** Folio side (recto/verso) */
+export type FolioSide = 'a' | 'b';
+/** Paginated passage references for a glossary term */
+export type GlossaryPassagesPage = {
+    __typename?: 'GlossaryPassagesPage';
+    /** Whether more passages exist beyond this page */
+    hasMore: Scalars['Boolean']['output'];
+    /** Passages in this page */
+    items: Array<Passage>;
+    /** Cursor for fetching the next page (offset encoded as string), null if no more */
+    nextCursor?: Maybe<Scalars['String']['output']>;
+};
+/** Paginated connection of glossary term instances for a work */
+export type GlossaryTermConnection = {
+    __typename?: 'GlossaryTermConnection';
+    /** List of glossary term instances in this page */
+    nodes: Array<GlossaryTermInstance>;
+    /** Pagination information */
+    pageInfo: PageInfo;
+    /** Total number of glossary terms in this work */
+    totalCount: Scalars['Int']['output'];
+};
+/** A glossary term instance within a specific work */
+export type GlossaryTermInstance = {
+    __typename?: 'GlossaryTermInstance';
+    /** Authority UUID for the term */
+    authority: Scalars['String']['output'];
+    /** Definition of the term */
+    definition?: Maybe<Scalars['String']['output']>;
+    /** Names in different languages */
+    names: GlossaryTermNames;
+    /** Paginated passage references where this term appears */
+    passages: GlossaryPassagesPage;
+    /** Absolute position of this term in the work's glossary (1-based) */
+    termNumber: Scalars['Int']['output'];
+    /** Unique identifier */
+    uuid: Scalars['ID']['output'];
+};
+/** A glossary term instance within a specific work */
+export type GlossaryTermInstancePassagesArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Names for a glossary term instance in different languages */
+export type GlossaryTermNames = {
+    __typename?: 'GlossaryTermNames';
+    /** Chinese name */
+    chinese?: Maybe<Scalars['String']['output']>;
+    /** English name/translation */
+    english?: Maybe<Scalars['String']['output']>;
+    /** Pali name */
+    pali?: Maybe<Scalars['String']['output']>;
+    /** Sanskrit name */
+    sanskrit?: Maybe<Scalars['String']['output']>;
+    /** Tibetan name */
+    tibetan?: Maybe<Scalars['String']['output']>;
+    /** Wylie transliteration */
+    wylie?: Maybe<Scalars['String']['output']>;
+};
+/** Health status response */
+export type HealthStatus = {
+    __typename?: 'HealthStatus';
+    /** Current status of the API (e.g., "ok", "degraded") */
+    status: Scalars['String']['output'];
+    /** ISO 8601 timestamp of the health check */
+    timestamp: Scalars['String']['output'];
+};
+/** Publication imprint information for a work */
+export type Imprint = {
+    __typename?: 'Imprint';
+    /** Whether the authorship is contested */
+    isAuthorContested: Scalars['Boolean']['output'];
+    /** License information */
+    license: License;
+    /** Long titles by language */
+    longTitles?: Maybe<TitlesByLanguage>;
+    /** Main titles by language */
+    mainTitles?: Maybe<TitlesByLanguage>;
+    /** Year the translation was published */
+    publishYear?: Maybe<Scalars['String']['output']>;
+    /** Publisher statement */
+    publisherStatement?: Maybe<Scalars['String']['output']>;
+    /** Whether access to this work is restricted */
+    restriction?: Maybe<Scalars['Boolean']['output']>;
+    /** Section of the canon (e.g., "Sutra") */
+    section?: Maybe<Scalars['String']['output']>;
+    /** Description of the source text */
+    sourceDescription?: Maybe<Scalars['String']['output']>;
+    /** Names of Tibetan authors */
+    tibetanAuthors?: Maybe<Array<Scalars['String']['output']>>;
+    /** Names of Tibetan translators */
+    tibetanTranslators?: Maybe<Scalars['String']['output']>;
+    /** Tohoku catalog entry number (e.g., "toh1") */
+    toh: Scalars['String']['output'];
+    /** Publication version (semantic versioning) */
+    version?: Maybe<Scalars['String']['output']>;
+};
+/** License information for a published work */
+export type License = {
+    __typename?: 'License';
+    /** Human-readable description of the license terms */
+    description?: Maybe<Scalars['String']['output']>;
+    /** URL to the license text */
+    link?: Maybe<Scalars['String']['output']>;
+    /** Name of the license (e.g., "CC BY-NC-ND 4.0") */
+    name?: Maybe<Scalars['String']['output']>;
+};
+/** Root Mutation type - extend this in other schema files */
+export type Mutation = {
+    __typename?: 'Mutation';
+    /** Placeholder for schema validation - not used */
+    _empty?: Maybe<Scalars['Boolean']['output']>;
+    /**
+     * Replace text within one or more targets.
+     * Requires editor.edit permission.
+     */
+    replace: ReplaceResult;
+    /**
+     * Save one or more passages.
+     * Requires editor.edit permission.
+     */
+    savePassages: SavePassagesResult;
+};
+/** Root Mutation type - extend this in other schema files */
+export type MutationReplaceArgs = {
+    cursorPassageUuid?: InputMaybe<Scalars['ID']['input']>;
+    cursorStart?: InputMaybe<Scalars['Int']['input']>;
+    occurrenceIndex?: InputMaybe<Scalars['Int']['input']>;
+    replaceText: Scalars['String']['input'];
+    searchText: Scalars['String']['input'];
+    targetUuids: Array<Scalars['ID']['input']>;
+    type?: InputMaybe<ReplaceType>;
+};
+/** Root Mutation type - extend this in other schema files */
+export type MutationSavePassagesArgs = {
+    deletedUuids?: InputMaybe<Array<Scalars['ID']['input']>>;
+    passages: Array<PassageInput>;
+};
+/**
+ * Pagination information for connections.
+ * Used consistently across all paginated queries.
+ */
+export type PageInfo = {
+    __typename?: 'PageInfo';
+    /** Whether there are more items after the current page */
+    hasMoreAfter: Scalars['Boolean']['output'];
+    /** Whether there are more items before the current page */
+    hasMoreBefore: Scalars['Boolean']['output'];
+    /** Cursor for fetching the next page */
+    nextCursor?: Maybe<Scalars['String']['output']>;
+    /** Cursor for fetching the previous page */
+    prevCursor?: Maybe<Scalars['String']['output']>;
+};
+/** Direction for pagination */
+export type PaginationDirection = 
+/** Fetch passages around the cursor (both before and after) */
+'AROUND'
+/** Fetch passages before the cursor */
+ | 'BACKWARD'
+/** Fetch passages after the cursor (default) */
+ | 'FORWARD';
+/** A passage of text from a work */
+export type Passage = {
+    __typename?: 'Passage';
+    /** Alignments linking this passage to Tibetan source text */
+    alignments: Array<Alignment>;
+    /** Annotations marking up ranges within this passage */
+    annotations: Array<Annotation>;
+    /** Text content of the passage */
+    content: Scalars['String']['output'];
+    /**
+     * TipTap editor JSON representation of this passage.
+     * Transforms content and annotations into nested JSON structure.
+     */
+    json?: Maybe<Scalars['JSON']['output']>;
+    /** Display label for the passage (e.g., "1.1") */
+    label?: Maybe<Scalars['String']['output']>;
+    /**
+     * Passages that reference this endnote passage via end-note-link annotations.
+     * Only populated for endnotes type passages; empty for all other types.
+     */
+    references: Array<Passage>;
+    /** Sort order within the work */
+    sort: Scalars['Int']['output'];
+    /** Tohoku number associated with this passage, if applicable */
+    toh?: Maybe<Scalars['String']['output']>;
+    /** Type of passage content (e.g., translation, introduction, colophon) */
+    type: Scalars['String']['output'];
+    /** Unique identifier for the passage */
+    uuid: Scalars['ID']['output'];
+    /** UUID of the work this passage belongs to */
+    workUuid: Scalars['ID']['output'];
+    /** The Legacy XML ID from the source document */
+    xmlId?: Maybe<Scalars['String']['output']>;
+};
+/** Paginated connection of passages */
+export type PassageConnection = {
+    __typename?: 'PassageConnection';
+    /**
+     * Whether there are more passages after the current page
+     * @deprecated Use pageInfo.hasMoreAfter instead
+     */
+    hasMoreAfter: Scalars['Boolean']['output'];
+    /**
+     * Whether there are more passages before the current page
+     * @deprecated Use pageInfo.hasMoreBefore instead
+     */
+    hasMoreBefore: Scalars['Boolean']['output'];
+    /**
+     * Cursor for fetching the next page
+     * @deprecated Use pageInfo.nextCursor instead
+     */
+    nextCursor?: Maybe<Scalars['String']['output']>;
+    /** List of passages */
+    nodes: Array<Passage>;
+    /** Pagination information */
+    pageInfo: PageInfo;
+    /**
+     * Cursor for fetching the previous page
+     * @deprecated Use pageInfo.prevCursor instead
+     */
+    prevCursor?: Maybe<Scalars['String']['output']>;
+};
+/** Filter options for passages */
+export type PassageFilter = {
+    /** Filter by label pattern using ILIKE (e.g., "n.5%") */
+    label?: InputMaybe<Scalars['String']['input']>;
+    /**
+     * Filter by passage type (e.g., translation, introduction, colophon).
+     * Can be a single type or use LIKE pattern with %.
+     */
+    type?: InputMaybe<Scalars['String']['input']>;
+    /**
+     * Filter by multiple passage types (OR logic).
+     * Use this instead of type when filtering by multiple types.
+     */
+    types?: InputMaybe<Array<Scalars['String']['input']>>;
+};
+/** Input type for saving a passage */
+export type PassageInput = {
+    /** Annotations as JSON array */
+    annotations: Scalars['JSON']['input'];
+    /** Text content of the passage */
+    content: Scalars['String']['input'];
+    /** Display label for the passage */
+    label: Scalars['String']['input'];
+    /** Sort order within the work */
+    sort: Scalars['Int']['input'];
+    /** Type of passage content */
+    type: Scalars['String']['input'];
+    /** Unique identifier for the passage */
+    uuid: Scalars['ID']['input'];
+    /** UUID of the work this passage belongs to */
+    workUuid: Scalars['ID']['input'];
+    /** The Legacy XML ID from the source document */
+    xmlId?: InputMaybe<Scalars['String']['input']>;
+};
+/** Permission types that can be checked */
+export type Permission = 'EDITOR_ADMIN' | 'EDITOR_EDIT' | 'EDITOR_READ' | 'PROJECTS_ADMIN' | 'PROJECTS_EDIT' | 'PROJECTS_READ';
+/** Root Query type - extend this in other schema files */
+export type Query = {
+    __typename?: 'Query';
+    /** Get a single bibliography entry by UUID */
+    bibliographyEntry?: Maybe<BibliographyEntryItem>;
+    /** Get a single glossary instance by UUID */
+    glossaryInstance?: Maybe<GlossaryTermInstance>;
+    /** Get paginated passage references for a glossary term (per-term, on-demand) */
+    glossaryTermPassages: GlossaryPassagesPage;
+    /**
+     * Check if the current user has a specific permission.
+     * Returns false if not authenticated.
+     */
+    hasPermission: Scalars['Boolean']['output'];
+    /** Health check query */
+    health: HealthStatus;
+    /** Get the currently authenticated user (null if not authenticated) */
+    me?: Maybe<CurrentUser>;
+    /**
+     * Fetch a single passage by UUID or XML ID.
+     * At least one of uuid or legacy xmlId must be provided. Prefers uuid if both are present.
+     */
+    passage?: Maybe<Passage>;
+    /** Get the current API version */
+    version: Scalars['String']['output'];
+    /**
+     * Get a single work by UUID or Tohoku catalog number.
+     * When both uuid and toh are provided, toh acts as a composite key
+     * and will be used as the default for nested resolvers (like imprint).
+     */
+    work?: Maybe<Work>;
+    /** Get paginated published translation works */
+    works: WorkConnection;
+};
+/** Root Query type - extend this in other schema files */
+export type QueryBibliographyEntryArgs = {
+    uuid: Scalars['ID']['input'];
+};
+/** Root Query type - extend this in other schema files */
+export type QueryGlossaryInstanceArgs = {
+    uuid: Scalars['ID']['input'];
+};
+/** Root Query type - extend this in other schema files */
+export type QueryGlossaryTermPassagesArgs = {
+    after?: InputMaybe<Scalars['String']['input']>;
+    first?: InputMaybe<Scalars['Int']['input']>;
+    uuid: Scalars['ID']['input'];
+};
+/** Root Query type - extend this in other schema files */
+export type QueryHasPermissionArgs = {
+    permission: Permission;
+};
+/** Root Query type - extend this in other schema files */
+export type QueryPassageArgs = {
+    uuid?: InputMaybe<Scalars['ID']['input']>;
+    xmlId?: InputMaybe<Scalars['String']['input']>;
+};
+/** Root Query type - extend this in other schema files */
+export type QueryWorkArgs = {
+    toh?: InputMaybe<Scalars['String']['input']>;
+    uuid?: InputMaybe<Scalars['ID']['input']>;
+};
+/** Root Query type - extend this in other schema files */
+export type QueryWorksArgs = {
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    filter?: InputMaybe<WorkFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Result of a replace mutation */
+export type ReplaceResult = {
+    __typename?: 'ReplaceResult';
+    /** Number of annotations deleted because the replacement removed them */
+    deletedAnnotationCount: Scalars['Int']['output'];
+    /** Error message if the replace failed */
+    error?: Maybe<Scalars['String']['output']>;
+    /** Character offset within nextPassageUuid where the next single replace should continue */
+    nextOccurrenceStart?: Maybe<Scalars['Int']['output']>;
+    /** Passage UUID after which the next single replace should continue */
+    nextPassageUuid?: Maybe<Scalars['ID']['output']>;
+    /** Updated target passages for client-side refresh */
+    passages: Array<Passage>;
+    /** Number of occurrences replaced */
+    replacedOccurrenceCount: Scalars['Int']['output'];
+    /** Whether the replace was successful */
+    success: Scalars['Boolean']['output'];
+    /** Number of annotations whose ranges changed */
+    updatedAnnotationCount: Scalars['Int']['output'];
+    /** Number of target records updated */
+    updatedCount: Scalars['Int']['output'];
+};
+/** Supported target types for search-and-replace operations */
+export type ReplaceType = 'PASSAGE';
+/** Result of saving passages */
+export type SavePassagesResult = {
+    __typename?: 'SavePassagesResult';
+    /** Number of passages deleted */
+    deletedCount?: Maybe<Scalars['Int']['output']>;
+    /** Error message if the save failed */
+    error?: Maybe<Scalars['String']['output']>;
+    /** Number of passages saved */
+    savedCount: Scalars['Int']['output'];
+    /** Whether the save was successful */
+    success: Scalars['Boolean']['output'];
+};
+/** A title of a work in a specific language */
+export type Title = {
+    __typename?: 'Title';
+    /** The title text content */
+    content: Scalars['String']['output'];
+    /** Language code (e.g., "en", "bo", "Sa-Ltn", "Bo-Ltn") */
+    language: Scalars['String']['output'];
+    /** Type of title (e.g., "mainTitle", "longTitle", "otherTitle", "toh", "shortcode") */
+    type: Scalars['String']['output'];
+    /** Unique identifier for the title */
+    uuid: Scalars['ID']['output'];
+};
+/** Titles grouped by language */
+export type TitlesByLanguage = {
+    __typename?: 'TitlesByLanguage';
+    /** English title */
+    english?: Maybe<Scalars['String']['output']>;
+    /** Sanskrit title */
+    sanskrit?: Maybe<Scalars['String']['output']>;
+    /** Tibetan title */
+    tibetan?: Maybe<Scalars['String']['output']>;
+    /** Wylie transliteration of Tibetan title */
+    wylie?: Maybe<Scalars['String']['output']>;
+};
+/** Table of contents for a work, organized by major sections */
+export type Toc = {
+    __typename?: 'Toc';
+    /** Back matter entries (endnotes, abbreviations) */
+    backMatter: Array<TocEntry>;
+    /** Body entries (homage, translation, colophon, etc.) */
+    body: Array<TocEntry>;
+    /** Front matter entries (acknowledgment, introduction, summary) */
+    frontMatter: Array<TocEntry>;
+};
+/**
+ * A hierarchical entry in a work's table of contents.
+ *
+ * This is a recursive type - each entry can contain nested children entries.
+ * Due to GraphQL's explicit nesting requirement, queries must specify the
+ * desired depth using fragments.
+ *
+ * Example query for 3 levels deep:
+ *   fragment TocFields on TocEntry {
+ *     uuid
+ *     content
+ *     label
+ *     level
+ *   }
+ *
+ *   query {
+ *     work(uuid: "...") {
+ *       toc {
+ *         frontMatter {
+ *           ...TocFields
+ *           children {
+ *             ...TocFields
+ *             children {
+ *               ...TocFields
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ *
+ * Maximum query depth is limited to 12 levels.
+ */
+export type TocEntry = {
+    __typename?: 'TocEntry';
+    /**
+     * Child entries nested under this entry.
+     * Must be explicitly queried to desired depth using fragments.
+     */
+    children: Array<TocEntry>;
+    /** Content of the TOC entry (title/heading) */
+    content: Scalars['String']['output'];
+    /** Optional label for the entry */
+    label?: Maybe<Scalars['String']['output']>;
+    /** Nesting level (1 for top level, 2+ for nested) */
+    level: Scalars['Int']['output'];
+    /** Section type (e.g., "introduction", "translation", "colophon") */
+    section: Scalars['String']['output'];
+    /** Sort order within the section */
+    sort: Scalars['Int']['output'];
+    /** Unique identifier for the passage */
+    uuid: Scalars['ID']['output'];
+};
+/** User role levels */
+export type UserRole = 'ADMIN' | 'EDITOR' | 'READER' | 'SCHOLAR' | 'TRANSLATOR';
+/** A published translation work from the 84000 canon */
+export type Work = {
+    __typename?: 'Work';
+    /** Bibliography entries for this work, grouped by section */
+    bibliography: Array<BibliographyEntry>;
+    /** Folios for this work, filtered by toh and paginated */
+    folios: Array<Folio>;
+    /**
+     * Glossary term instances for this work
+     * @deprecated Use glossaryTerms for paginated access
+     */
+    glossary: Array<GlossaryTermInstance>;
+    /** Paginated glossary term instances for this work */
+    glossaryTerms: GlossaryTermConnection;
+    /**
+     * Publication imprint information.
+     * If the work query specified a toh argument, that value will be used.
+     * Otherwise, imprint for the first toh in the work is returned.
+     */
+    imprint?: Maybe<Imprint>;
+    /** Number of source pages */
+    pages: Scalars['Int']['output'];
+    /** Paginated passages from this work */
+    passages: PassageConnection;
+    /** Date the work was published */
+    publicationDate?: Maybe<Scalars['String']['output']>;
+    /** Semantic version of the publication (e.g., "1.0.0") */
+    publicationVersion: Scalars['String']['output'];
+    /** Whether access to this work is restricted */
+    restriction: Scalars['Boolean']['output'];
+    /** Section of the canon this work belongs to */
+    section: Scalars['String']['output'];
+    /** Title of the work */
+    title: Scalars['String']['output'];
+    /** All titles associated with this work, in various languages and types */
+    titles: Array<Title>;
+    /**
+     * Table of contents for the work, organized by major sections.
+     * Returns a recursive tree structure up to 12 levels deep.
+     * See the TocEntry type documentation for query examples.
+     */
+    toc?: Maybe<Toc>;
+    /** Tohoku catalog entry numbers (e.g., ["toh1", "toh2"]) */
+    toh: Array<Scalars['String']['output']>;
+    /** Unique identifier for the work */
+    uuid: Scalars['ID']['output'];
+};
+/** A published translation work from the 84000 canon */
+export type WorkFoliosArgs = {
+    page?: InputMaybe<Scalars['Int']['input']>;
+    size?: InputMaybe<Scalars['Int']['input']>;
+    toh: Scalars['String']['input'];
+};
+/** A published translation work from the 84000 canon */
+export type WorkGlossaryArgs = {
+    withAttestations?: InputMaybe<Scalars['Boolean']['input']>;
+};
+/** A published translation work from the 84000 canon */
+export type WorkGlossaryTermsArgs = {
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    direction?: InputMaybe<PaginationDirection>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    withAttestations?: InputMaybe<Scalars['Boolean']['input']>;
+};
+/** A published translation work from the 84000 canon */
+export type WorkPassagesArgs = {
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    direction?: InputMaybe<PaginationDirection>;
+    filter?: InputMaybe<PassageFilter>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+};
+/** Connection type for paginated works */
+export type WorkConnection = {
+    __typename?: 'WorkConnection';
+    /** List of works in this page */
+    items: Array<Work>;
+    /** Pagination information */
+    pageInfo: PageInfo;
+    /** Total count of works matching the query */
+    totalCount: Scalars['Int']['output'];
+};
+/** Filter criteria for works query */
+export type WorkFilter = {
+    /** Maximum number of source pages (exclusive). Only return works with fewer pages than this value. */
+    maxPages?: InputMaybe<Scalars['Int']['input']>;
+};
+export type AlignmentFieldsFragment = {
+    __typename?: 'Alignment';
+    folioUuid: string;
+    toh: string;
+    tibetan: string;
+    folioNumber: number;
+    volumeNumber: number;
+};
+export type AnnotationFieldsFragment = {
+    __typename?: 'Annotation';
+    uuid: string;
+    type: string;
+    start: number;
+    end: number;
+    metadata?: any | null;
+};
+export type LicenseFieldsFragment = {
+    __typename?: 'License';
+    name?: string | null;
+    link?: string | null;
+    description?: string | null;
+};
+export type TitlesByLanguageFieldsFragment = {
+    __typename?: 'TitlesByLanguage';
+    tibetan?: string | null;
+    english?: string | null;
+    wylie?: string | null;
+    sanskrit?: string | null;
+};
+export type ImprintFieldsFragment = {
+    __typename?: 'Imprint';
+    toh: string;
+    section?: string | null;
+    version?: string | null;
+    restriction?: boolean | null;
+    publishYear?: string | null;
+    tibetanAuthors?: Array<string> | null;
+    isAuthorContested: boolean;
+    sourceDescription?: string | null;
+    publisherStatement?: string | null;
+    tibetanTranslators?: string | null;
+    license: ({
+        __typename?: 'License';
+    } & LicenseFieldsFragment);
+    mainTitles?: ({
+        __typename?: 'TitlesByLanguage';
+    } & TitlesByLanguageFieldsFragment) | null;
+    longTitles?: ({
+        __typename?: 'TitlesByLanguage';
+    } & TitlesByLanguageFieldsFragment) | null;
+};
+export type PassageFieldsFragment = {
+    __typename?: 'Passage';
+    uuid: string;
+    workUuid: string;
+    content: string;
+    label?: string | null;
+    sort: number;
+    type: string;
+    xmlId?: string | null;
+};
+export type PassageWithAnnotationsFragment = ({
+    __typename?: 'Passage';
+    annotations: Array<({
+        __typename?: 'Annotation';
+    } & AnnotationFieldsFragment)>;
+    alignments: Array<({
+        __typename?: 'Alignment';
+    } & AlignmentFieldsFragment)>;
+} & PassageFieldsFragment);
+export type PassageWithJsonFragment = {
+    __typename?: 'Passage';
+    uuid: string;
+    workUuid: string;
+    label?: string | null;
+    sort: number;
+    type: string;
+    xmlId?: string | null;
+    json?: any | null;
+};
+export type TitleFieldsFragment = {
+    __typename?: 'Title';
+    uuid: string;
+    content: string;
+    language: string;
+    type: string;
+};
+export type TocEntryFieldsFragment = {
+    __typename?: 'TocEntry';
+    uuid: string;
+    content: string;
+    label?: string | null;
+    sort: number;
+    level: number;
+    section: string;
+};
+export type TocEntryNestedFragment = ({
+    __typename?: 'TocEntry';
+    children: Array<({
+        __typename?: 'TocEntry';
+        children: Array<({
+            __typename?: 'TocEntry';
+            children: Array<({
+                __typename?: 'TocEntry';
+                children: Array<({
+                    __typename?: 'TocEntry';
+                    children: Array<({
+                        __typename?: 'TocEntry';
+                    } & TocEntryFieldsFragment)>;
+                } & TocEntryFieldsFragment)>;
+            } & TocEntryFieldsFragment)>;
+        } & TocEntryFieldsFragment)>;
+    } & TocEntryFieldsFragment)>;
+} & TocEntryFieldsFragment);
+export type TocFieldsFragment = {
+    __typename?: 'Toc';
+    frontMatter: Array<({
+        __typename?: 'TocEntry';
+    } & TocEntryNestedFragment)>;
+    body: Array<({
+        __typename?: 'TocEntry';
+    } & TocEntryNestedFragment)>;
+    backMatter: Array<({
+        __typename?: 'TocEntry';
+    } & TocEntryNestedFragment)>;
+};
+export type WorkFieldsFragment = {
+    __typename?: 'Work';
+    uuid: string;
+    title: string;
+    toh: Array<string>;
+    publicationDate?: string | null;
+    publicationVersion: string;
+    pages: number;
+    restriction: boolean;
+    section: string;
+};
+export type GetPassagesQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    direction?: InputMaybe<PaginationDirection>;
+    filter?: InputMaybe<PassageFilter>;
+}>;
+export type GetPassagesQuery = {
+    __typename?: 'Query';
+    work?: {
+        __typename?: 'Work';
+        uuid: string;
+        passages: {
+            __typename?: 'PassageConnection';
+            nodes: Array<({
+                __typename?: 'Passage';
+            } & PassageWithAnnotationsFragment)>;
+            pageInfo: {
+                __typename?: 'PageInfo';
+                nextCursor?: string | null;
+                prevCursor?: string | null;
+                hasMoreAfter: boolean;
+                hasMoreBefore: boolean;
+            };
+        };
+    } | null;
+};
+export type GetPassagesBasicQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    direction?: InputMaybe<PaginationDirection>;
+    filter?: InputMaybe<PassageFilter>;
+}>;
+export type GetPassagesBasicQuery = {
+    __typename?: 'Query';
+    work?: {
+        __typename?: 'Work';
+        uuid: string;
+        passages: {
+            __typename?: 'PassageConnection';
+            nodes: Array<({
+                __typename?: 'Passage';
+            } & PassageFieldsFragment)>;
+            pageInfo: {
+                __typename?: 'PageInfo';
+                nextCursor?: string | null;
+                prevCursor?: string | null;
+                hasMoreAfter: boolean;
+                hasMoreBefore: boolean;
+            };
+        };
+    } | null;
+};
+export type GetPassagesWithJsonQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    direction?: InputMaybe<PaginationDirection>;
+    filter?: InputMaybe<PassageFilter>;
+}>;
+export type GetPassagesWithJsonQuery = {
+    __typename?: 'Query';
+    work?: {
+        __typename?: 'Work';
+        uuid: string;
+        passages: {
+            __typename?: 'PassageConnection';
+            nodes: Array<({
+                __typename?: 'Passage';
+            } & PassageWithJsonFragment)>;
+            pageInfo: {
+                __typename?: 'PageInfo';
+                nextCursor?: string | null;
+                prevCursor?: string | null;
+                hasMoreAfter: boolean;
+                hasMoreBefore: boolean;
+            };
+        };
+    } | null;
+};
+export type GetPassagesAroundWithJsonQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+    cursor: Scalars['String']['input'];
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    filter?: InputMaybe<PassageFilter>;
+}>;
+export type GetPassagesAroundWithJsonQuery = {
+    __typename?: 'Query';
+    work?: {
+        __typename?: 'Work';
+        uuid: string;
+        passages: {
+            __typename?: 'PassageConnection';
+            nodes: Array<({
+                __typename?: 'Passage';
+            } & PassageWithJsonFragment)>;
+            pageInfo: {
+                __typename?: 'PageInfo';
+                nextCursor?: string | null;
+                prevCursor?: string | null;
+                hasMoreAfter: boolean;
+                hasMoreBefore: boolean;
+            };
+        };
+    } | null;
+};
+export type GetPassageQueryVariables = Exact<{
+    uuid?: InputMaybe<Scalars['ID']['input']>;
+    xmlId?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type GetPassageQuery = {
+    __typename?: 'Query';
+    passage?: ({
+        __typename?: 'Passage';
+    } & PassageWithAnnotationsFragment) | null;
+};
+export type GetWorkByUuidQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+}>;
+export type GetWorkByUuidQuery = {
+    __typename?: 'Query';
+    work?: ({
+        __typename?: 'Work';
+    } & WorkFieldsFragment) | null;
+};
+export type GetWorkByTohQueryVariables = Exact<{
+    toh: Scalars['String']['input'];
+}>;
+export type GetWorkByTohQuery = {
+    __typename?: 'Query';
+    work?: ({
+        __typename?: 'Work';
+    } & WorkFieldsFragment) | null;
+};
+export type GetWorkWithTitlesQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+}>;
+export type GetWorkWithTitlesQuery = {
+    __typename?: 'Query';
+    work?: ({
+        __typename?: 'Work';
+        titles: Array<({
+            __typename?: 'Title';
+        } & TitleFieldsFragment)>;
+    } & WorkFieldsFragment) | null;
+};
+export type GetWorkWithImprintQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+    toh?: InputMaybe<Scalars['String']['input']>;
+}>;
+export type GetWorkWithImprintQuery = {
+    __typename?: 'Query';
+    work?: ({
+        __typename?: 'Work';
+        imprint?: ({
+            __typename?: 'Imprint';
+        } & ImprintFieldsFragment) | null;
+    } & WorkFieldsFragment) | null;
+};
+export type GetWorkWithTocQueryVariables = Exact<{
+    uuid: Scalars['ID']['input'];
+}>;
+export type GetWorkWithTocQuery = {
+    __typename?: 'Query';
+    work?: ({
+        __typename?: 'Work';
+        toc?: ({
+            __typename?: 'Toc';
+        } & TocFieldsFragment) | null;
+    } & WorkFieldsFragment) | null;
+};
+export type GetAllWorksQueryVariables = Exact<{
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type GetAllWorksQuery = {
+    __typename?: 'Query';
+    works: {
+        __typename?: 'WorkConnection';
+        items: Array<({
+            __typename?: 'Work';
+        } & WorkFieldsFragment)>;
+        pageInfo: {
+            __typename?: 'PageInfo';
+            nextCursor?: string | null;
+            hasMoreAfter: boolean;
+        };
+    };
+};
+export type GetWorkUuidsQueryVariables = Exact<{
+    cursor?: InputMaybe<Scalars['String']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type GetWorkUuidsQuery = {
+    __typename?: 'Query';
+    works: {
+        __typename?: 'WorkConnection';
+        items: Array<{
+            __typename?: 'Work';
+            uuid: string;
+        }>;
+        pageInfo: {
+            __typename?: 'PageInfo';
+            nextCursor?: string | null;
+            hasMoreAfter: boolean;
+        };
+    };
+};
+export declare const LicenseFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const TitlesByLanguageFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const ImprintFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const PassageFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const AnnotationFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const AlignmentFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const PassageWithAnnotationsFragmentDoc: import("graphql").DocumentNode;
+export declare const PassageWithJsonFragmentDoc: import("graphql").DocumentNode;
+export declare const TitleFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const TocEntryFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const TocEntryNestedFragmentDoc: import("graphql").DocumentNode;
+export declare const TocFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const WorkFieldsFragmentDoc: import("graphql").DocumentNode;
+export declare const GetPassagesDocument: import("graphql").DocumentNode;
+export declare const GetPassagesBasicDocument: import("graphql").DocumentNode;
+export declare const GetPassagesWithJsonDocument: import("graphql").DocumentNode;
+export declare const GetPassagesAroundWithJsonDocument: import("graphql").DocumentNode;
+export declare const GetPassageDocument: import("graphql").DocumentNode;
+export declare const GetWorkByUuidDocument: import("graphql").DocumentNode;
+export declare const GetWorkByTohDocument: import("graphql").DocumentNode;
+export declare const GetWorkWithTitlesDocument: import("graphql").DocumentNode;
+export declare const GetWorkWithImprintDocument: import("graphql").DocumentNode;
+export declare const GetWorkWithTocDocument: import("graphql").DocumentNode;
+export declare const GetAllWorksDocument: import("graphql").DocumentNode;
+export declare const GetWorkUuidsDocument: import("graphql").DocumentNode;
+export type SdkFunctionWrapper = <T>(action: (requestHeaders?: Record<string, string>) => Promise<T>, operationName: string, operationType?: string, variables?: any) => Promise<T>;
+export declare function getSdk(client: GraphQLClient, withWrapper?: SdkFunctionWrapper): {
+    GetPassages(variables: GetPassagesQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetPassagesQuery>;
+    GetPassagesBasic(variables: GetPassagesBasicQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetPassagesBasicQuery>;
+    GetPassagesWithJson(variables: GetPassagesWithJsonQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetPassagesWithJsonQuery>;
+    GetPassagesAroundWithJson(variables: GetPassagesAroundWithJsonQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetPassagesAroundWithJsonQuery>;
+    GetPassage(variables?: GetPassageQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetPassageQuery>;
+    GetWorkByUuid(variables: GetWorkByUuidQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetWorkByUuidQuery>;
+    GetWorkByToh(variables: GetWorkByTohQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetWorkByTohQuery>;
+    GetWorkWithTitles(variables: GetWorkWithTitlesQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetWorkWithTitlesQuery>;
+    GetWorkWithImprint(variables: GetWorkWithImprintQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetWorkWithImprintQuery>;
+    GetWorkWithToc(variables: GetWorkWithTocQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetWorkWithTocQuery>;
+    GetAllWorks(variables?: GetAllWorksQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetAllWorksQuery>;
+    GetWorkUuids(variables?: GetWorkUuidsQueryVariables, requestHeaders?: GraphQLClientRequestHeaders, signal?: RequestInit["signal"]): Promise<GetWorkUuidsQuery>;
+};
+export type Sdk = ReturnType<typeof getSdk>;
+export {};