@sanity/client 8.3.0 → 8.5.0

package/dist/index.node.d.ts

@@ -1043,7 +1043,10 @@ type TranslateDocumentSync<T extends Record<string, Any> = Record<string, Any>>
 type TranslateDocumentAsync = TranslateRequestBase & AgentActionAsync;
 /** @beta */
 type TranslateDocument<T extends Record<string, Any> = Record<string, Any>> = TranslateDocumentSync<T> | TranslateDocumentAsync;
-/** @public */
+/**
+ * @public
+ * @inline
+ */
 declare class ObservableAgentsActionClient {
   #private;
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
@@ -1069,7 +1072,10 @@ declare class ObservableAgentsActionClient {
     _id: string;
   } : IdentifiedSanityDocumentStub & DocumentShape>;
 }
-/** @public */
+/**
+ * @public
+ * @inline
+ */
 declare class AgentActionsClient {
   #private;
   constructor(client: SanityClient, httpRequest: HttpRequest);
@@ -1108,7 +1114,10 @@ declare class AgentActionsClient {
     _id: string;
   } : IdentifiedSanityDocumentStub & DocumentShape>;
 }
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class ObservableAssetsClient {
   #private;
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
@@ -1143,7 +1152,10 @@ declare class ObservableAssetsClient {
     document: SanityAssetDocument | SanityImageAssetDocument;
   }>>;
 }
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class AssetsClient {
   #private;
   constructor(client: SanityClient, httpRequest: HttpRequest);
@@ -1684,50 +1696,3280 @@ declare class CollaborationCommentsClient {
    * )
    * ```
    *
-   * @param documentId - Document ID, in published, draft or version form
-   * @returns Global document reference, of the form `resourceType:resourceId:documentId`
+   * @param documentId - Document ID, in published, draft or version form
+   * @returns Global document reference, of the form `resourceType:resourceId:documentId`
+   */
+  getTargetDocumentRef(documentId: string): CollaborationCommentDocument['target']['document']['_ref'];
+  /**
+   * Fetch comments on the configured resource.
+   *
+   * Takes the same `query` and `params` as `client.fetch`, and switches from a
+   * GET to a POST for queries too large for the request URL in the same way,
+   * but queries the comments endpoint, which accepts none of the query options
+   * `client.fetch` does (`perspective`, `useCdn`, `filterResponse`,
+   * `resultSourceMap`, stega).
+   *
+   * The query runs against the organization store, which is not scoped to
+   * comments, so filter on `_type == "sanity.comment"`.
+   *
+   * @param query - GROQ-query to perform
+   * @param params - Optional query parameters
+   * @param options - Optional request options
+   */
+  fetch<R = unknown>(query: string, params?: QueryParams, options?: CollaborationCommentsRequestOptions): Promise<R>;
+  /**
+   * Listen for changes to comments on the configured resource.
+   *
+   * Mirrors `client.listen(query, params)`, and emits mutation events.
+   *
+   * @param query - GROQ-filter to listen to changes for
+   * @param params - Optional query parameters
+   */
+  listen(query: string, params?: QueryParams): Observable<MutationEvent<CollaborationCommentDocument>>;
+  /**
+   * Listen for changes to comments on the configured resource.
+   *
+   * Mirrors `client.listen(query, params, options)`.
+   *
+   * @param query - GROQ-filter to listen to changes for
+   * @param params - Optional query parameters
+   * @param options - The same listener options `client.listen` takes, forwarded
+   *   to the organization store's listener
+   */
+  listen<Opts extends CollaborationCommentsListenOptions>(query: string, params: QueryParams | undefined, options: Opts): Observable<ListenEventFromOptions<CollaborationCommentDocument, Opts>>;
+}
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+interface paths {
+  '/{apiVersion}/context/knowledge-bases': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List knowledge bases
+     * @description Returns the organization's knowledge bases visible to the caller, cursor-paginated.
+     */
+    get: operations['listKnowledgeBases'];
+    put?: never;
+    /**
+     * Create a knowledge base
+     * @description Creates a knowledge base bound to a Sanity dataset, where its content documents will be stored.
+     */
+    post: operations['createKnowledgeBase'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get a knowledge base
+     * @description Returns the knowledge base object: metadata and state. Resolves from the id alone, the public id (`kb...`) or the uuid; access is decided against the knowledge base's own organization, and an id the caller cannot read returns 404. For the built content, use the outline or entries endpoints.
+     */
+    get: operations['getKnowledgeBase'];
+    put?: never;
+    post?: never;
+    /**
+     * Delete a knowledge base
+     * @description Removes the knowledge base and everything it owns: sources, imports, and revisions. Content documents in the bound dataset are deleted best-effort, and stored source files are reclaimed by a separate cleanup.
+     */
+    delete: operations['deleteKnowledgeBase'];
+    options?: never;
+    head?: never;
+    /**
+     * Update a knowledge base
+     * @description Edits the name and description, or the recurring refresh controls (`refreshEnabled`, `refreshFrequency`). Refresh fields return 422 for knowledge bases with no web or dataset source. Disabling pauses the schedule; manual refresh still works.
+     */
+    patch: operations['updateKnowledgeBase'];
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/build': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Trigger a knowledge base build
+     * @description Queues a build over the current corpus and returns a job id right away. If a build is already running, you get that job instead of a second one.
+     */
+    post: operations['buildKnowledgeBase'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/build/cancel': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Cancel an in-progress build
+     * @description Cancels the running build and resets the knowledge base so it can be rebuilt.
+     */
+    post: operations['cancelKnowledgeBaseBuild'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/entries/{entryPath}/rebuild': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Rebuild an entry from its sources
+     * @description Queues a re-write of the entry at this path from its cited sources and the active instructions, and returns a job id right away. The response also names the other entries citing any of the same sources: a source-tied rule affects every page citing that source, so those may change too.
+     */
+    post: operations['rebuildEntry'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/imports': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List imports
+     * @description Everything added to this knowledge base, one row per import: a file upload, web crawl, dataset bind, or inline text. Cursor-paginated. The sources each import produced live under `/sources`.
+     */
+    get: operations['listImports'];
+    put?: never;
+    /**
+     * Create an import (text, crawl, or dataset)
+     * @description Adds content, discriminated on `type`: `text` for inline content, `crawl` for a website, `dataset` for a GROQ-filtered Sanity dataset. Each variant queues processing and returns a job id to poll. For files, use `POST .../imports/uploads` instead. Re-adding an existing crawl url returns 409 `webSourceRootConflict`; exceeding the crawl root limit returns 409 `webSourceRootLimitExceeded`. Supports the `Idempotency-Key` header.
+     */
+    post: operations['createImport'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/imports/uploads': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Start a file-upload import
+     * @description Creates a file-upload import and returns a single-use signed upload URL. PUT the file bytes to it, then call `POST .../imports/uploads/{importId}/complete` to start ingestion. The bytes never pass through this API. Supports the `Idempotency-Key` header.
+     */
+    post: operations['startUpload'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/imports/uploads/{importId}/complete': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Complete a file-upload import
+     * @description Call after the file bytes are uploaded to the signed URL. Starts processing and returns a job id to poll.
+     */
+    post: operations['completeUpload'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/imports/{importId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get a single import
+     * @description Returns one import with its kind and processing status.
+     */
+    get: operations['getImport'];
+    put?: never;
+    post?: never;
+    /**
+     * Delete an import
+     * @description Removes the import and every source it produced, and cancels its ingest if one is still running. Use it to discard something added by mistake.
+     */
+    delete: operations['deleteImport'];
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/imports/{importId}/download': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get a download URL for an import
+     * @description Mints a short-lived signed URL serving the import's original bytes as an attachment. Use it before `expiresAt`; the bytes never pass through this API. Only file and text imports carry original bytes; crawls and dataset binds return 409 `importInvalidState`.
+     */
+    get: operations['downloadImport'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/instructions': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Author a human instruction
+     * @description Creates a standing rule that every future build honors. Tie it to one or more sources with `scopeSourceIds`, or leave it null to apply knowledge-base-wide. Pass `rebuildPaths` to immediately rebuild those entries under the new rule; the response carries the rebuild job id, or null when the rebuild could not start (the rule is saved either way). Pass `verified` after a completed synchronous contradiction check to skip the background one; if the requested rebuild fails to start, the background check runs anyway so the contradicting pages get filed as issues.
+     */
+    post: operations['createInstruction'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/instructions/{instructionId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    post?: never;
+    /**
+     * Delete an instruction
+     * @description Deletes the rule. Builds stop honoring it from the next run.
+     */
+    delete: operations['deleteInstruction'];
+    options?: never;
+    head?: never;
+    /**
+     * Edit an instruction
+     * @description Edits the statement or scope. The change applies from the next build. Any edit re-affirms the rule: an archived rule returns to active, re-anchored to the sources' current content.
+     */
+    patch: operations['updateInstruction'];
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/issues/apply': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Apply accepted issues to a Context
+     * @description Queues a job that applies accepted issues, rewrites the affected entries, and commits a new revision. Returns a job id. Issue ids that no longer exist are skipped.
+     */
+    post: operations['applyIssues'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/issues/{issueId}/dismiss': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Dismiss an issue
+     * @description Marks the issue rejected. Idempotent: dismissing an issue that already left the queue returns it as-is. 422 `issueDocumentInvalid` when the document was hand-edited into an unverifiable shape; 409 `issueTransitionConflict` on a concurrent edit, safe to retry.
+     */
+    post: operations['dismissIssue'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/issues/{issueId}/reopen': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Reopen an accepted conflict
+     * @description Returns an accepted conflict to triage, clearing its resolution and deleting the instruction it minted. Idempotent for issues that are not accepted conflicts.
+     */
+    post: operations['reopenIssue'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/issues/{issueId}/resolve': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Resolve a conflict issue
+     * @description Settles a conflict with one of two choices: `keep_existing` or `accept_new` (rewrites the entry; the returned `jobId` tracks it). Only conflict issues are resolvable, and a dismissed issue must be reopened first. The decision becomes a standing instruction for every future build; `resolvedBy` records who decided.
+     */
+    post: operations['resolveIssue'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/jobs/{jobId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get a job by id
+     * @description Returns the status of a job, such as a build or an import. Job ids come from the endpoint that queued the work.
+     */
+    get: operations['getJob'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/refresh': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Trigger an incremental refresh
+     * @description Queues a refresh: recrawls each web source, diffs the corpus against the last build, and files change issues. Returns a job id, with `started: false` when a refresh was already in flight. Supports the `Idempotency-Key` header.
+     */
+    post: operations['refreshKnowledgeBase'];
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/sources': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * List sources
+     * @description The distilled units builds cite: the pages, files, and documents your imports expanded into. Read-only; add content via `/imports`. Cursor-paginated, filter by `status`.
+     */
+    get: operations['listSources'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/sources/{sourceId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get a single source
+     * @description Returns one source with its metadata and processing status.
+     */
+    get: operations['getSource'];
+    put?: never;
+    post?: never;
+    /**
+     * Delete a source
+     * @description Removes the source immediately. Entries are not modified here — citations to it are cleaned up by the next build or check for changes, where entries left without sources become removal proposals. Human-edited entries are never modified.
+     */
+    delete: operations['deleteSource'];
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}/sources/{sourceId}/content': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Read a source's distilled content
+     * @description The distilled markdown builds cite, the same text the pipeline itself reads. Use it to verify an issue's claims against the sources its `citedSourceIds` name. Optional `startLine` and `endLine` (1-indexed, inclusive) fetch just a span. JSON by default; `?format=markdown` returns the raw text. 409 `sourceNotDistilled` until distillation has produced content.
+     */
+    get: operations['getSourceContent'];
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/{apiVersion}/context/organizations/{organizationId}/conversations/{threadId}': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    /**
+     * Record a conversation
+     * @description Upserts the conversation telemetry for one thread. `threadId` identifies the conversation within your organization — reuse means the same conversation. Messages replace the stored transcript wholesale; `metadata` and model fields only overwrite when present. Last write per thread wins — retries are safe.
+     */
+    put: operations['saveConversation'];
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    /**
+     * Record a classification verdict
+     * @description Records the classification your own model produced for one thread: exactly one of `coreMetrics` (a verdict — the server stamps `classifiedAt` and clears any recorded failure) or `classificationError` (why classification failed; an earlier verdict stays untouched). No revision guard — like the ingest upsert the writer is an automated classifier, so last write wins and a re-classification simply overwrites.
+     */
+    patch: operations['classifyConversation'];
+    trace?: never;
+  };
+}
+interface components {
+  schemas: {
+    /** @description A `sanity.context.conversation` document, one agent conversation transcript with its classification, stored in the organization store. Not returned by any endpoint raw; published so GROQ reads can be typed. Write through the conversation ingest and classify endpoints, never with a raw client. */
+    ConversationDoc: {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      /** @enum {string} */
+      _type: 'sanity.context.conversation';
+      /** @enum {number} */
+      schemaVersion: 1;
+      organizationId: string;
+      threadId: string;
+      /** @description ConversationMetadata */
+      metadata: {
+        [key: string]: string | string[];
+      } | null;
+      /** Format: date-time */
+      startedAt: string;
+      /** Format: date-time */
+      messagesUpdatedAt: string;
+      messages: {
+        /** @enum {string} */
+        role: 'user' | 'assistant' | 'system' | 'tool';
+        /** @default null */
+        content: string | null;
+        /** @default null */
+        toolName: string | null;
+        /**
+         * @default null
+         * @enum {string|null}
+         */
+        toolType: 'call' | 'result' | null;
+      }[];
+      modelProvider: string | null;
+      modelId: string | null;
+      /** @description ConversationTokenUsage */
+      tokenUsage: {
+        inputTokens?: number;
+        outputTokens?: number;
+        totalTokens?: number;
+      } | null;
+      /** @description ConversationCoreMetrics */
+      coreMetrics: {
+        successScore?: number;
+        /** @enum {string} */
+        sentiment?: 'positive' | 'neutral' | 'negative';
+        contentGaps?: string[];
+      } | null;
+      /** Format: date-time */
+      classifiedAt: string | null;
+      classificationError: string | null;
+    };
+    /** @description A `sanity.context.entry` document, one outline node stored in the bound dataset. Not returned by any endpoint; published so GROQ reads against the dataset can be typed. The entries endpoints serve the validated wire view. */
+    EntryDoc: {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      knowledgeBaseId: string;
+      /** @enum {string} */
+      _type: 'sanity.context.entry';
+      schemaVersion: number;
+      revisionId: string;
+      path: string;
+      title: string;
+      tldr?: {
+        scope: string;
+        excludes: string;
+        neighbors?: string[];
+        /** @enum {string} */
+        centrality: 'core' | 'standard' | 'peripheral';
+      };
+      body?: string;
+      topicHeadings?: string[];
+      citations?: {
+        sourceId: string;
+        supports?: string;
+        spans?: {
+          sourceLineStart: number;
+          sourceLineEnd: number;
+          quote: string;
+        }[];
+        claim?: {
+          exact: string;
+          prefix?: string;
+          suffix?: string;
+        };
+        /** @enum {string} */
+        groundingState?: 'drifted';
+        _key: string;
+        /** @enum {string} */
+        _type: 'sanity.context.citation';
+        filename: string;
+        mime?: string;
+        excerpt?: string;
+      }[];
+      /** @enum {string} */
+      status: 'virtual' | 'outlined' | 'filled' | 'stale' | 'generation_failed';
+      generatedAt: string;
+    };
+    /** @description A `sanity.context.instruction` document, a standing decision steering every build, stored in the bound dataset. Not returned by any endpoint; published so GROQ reads against the dataset can be typed. Write through the instructions endpoints, never with a raw client. */
+    InstructionDoc: {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      knowledgeBaseId: string;
+      /** @enum {string} */
+      _type: 'sanity.context.instruction';
+      /** @enum {number} */
+      schemaVersion: 1;
+      statement: string;
+      scopeSources: {
+        _key: string;
+        sourceId: string;
+        contentHash: string;
+      }[] | null;
+      /** @enum {string} */
+      status: 'active' | 'archived';
+      archivedAt: string | null;
+      archivedReason: string | null;
+      /** @enum {string} */
+      origin: 'conflict';
+      sourceIssueId: string;
+    } | {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      knowledgeBaseId: string;
+      /** @enum {string} */
+      _type: 'sanity.context.instruction';
+      /** @enum {number} */
+      schemaVersion: 1;
+      statement: string;
+      scopeSources: {
+        _key: string;
+        sourceId: string;
+        contentHash: string;
+      }[] | null;
+      /** @enum {string} */
+      status: 'active' | 'archived';
+      archivedAt: string | null;
+      archivedReason: string | null;
+      /** @enum {string} */
+      origin: 'human';
+      /** @enum {string|null} */
+      sourceIssueId: null;
+    };
+    /** @description A `sanity.context.issue` document, a build finding awaiting triage, stored in the bound dataset. Not returned by any endpoint; published so GROQ reads and trigger filters can be typed. Status transitions flow through the issues endpoints, which own the state machine. One invariant the schema cannot express: only a `conflict` issue ever carries a non-null `resolution`. */
+    IssueDoc: {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      knowledgeBaseId: string;
+      /** @enum {string} */
+      _type: 'sanity.context.issue';
+      /** @enum {number} */
+      schemaVersion: 1;
+      /** @description IssueContent */
+      content: {
+        /** @enum {string} */
+        kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+        /** @enum {string} */
+        severity: 'critical' | 'suggestion';
+        scopePath: string;
+        issue: string;
+        suggestedFix: string;
+        citedSourceIds?: string[];
+        claimKey?: string;
+        involvedScopes?: string[];
+        currentClaim?: string;
+        alternativeClaim?: string;
+        /** @enum {string} */
+        currentAuthority?: 'primary' | 'secondary' | 'community';
+        /** @enum {string} */
+        alternativeAuthority?: 'primary' | 'secondary' | 'community';
+        /** @enum {string} */
+        suggestedResolution?: 'keep_existing' | 'accept_new';
+      };
+      fingerprint: string;
+      revisionId: string | null;
+      /** @enum {string} */
+      status: 'open';
+      /** @enum {string|null} */
+      resolution: null;
+      /** @enum {string|null} */
+      resolvedAt: null;
+      /** @enum {string|null} */
+      resolvedBy: null;
+    } | {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      knowledgeBaseId: string;
+      /** @enum {string} */
+      _type: 'sanity.context.issue';
+      /** @enum {number} */
+      schemaVersion: 1;
+      /** @description IssueContent */
+      content: {
+        /** @enum {string} */
+        kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+        /** @enum {string} */
+        severity: 'critical' | 'suggestion';
+        scopePath: string;
+        issue: string;
+        suggestedFix: string;
+        citedSourceIds?: string[];
+        claimKey?: string;
+        involvedScopes?: string[];
+        currentClaim?: string;
+        alternativeClaim?: string;
+        /** @enum {string} */
+        currentAuthority?: 'primary' | 'secondary' | 'community';
+        /** @enum {string} */
+        alternativeAuthority?: 'primary' | 'secondary' | 'community';
+        /** @enum {string} */
+        suggestedResolution?: 'keep_existing' | 'accept_new';
+      };
+      fingerprint: string;
+      revisionId: string | null;
+      /** @enum {string} */
+      status: 'accepted';
+      /** Format: date-time */
+      resolvedAt: string;
+      resolvedBy: {
+        id: string;
+        /** @enum {string} */
+        kind: 'user' | 'robot';
+      } | null;
+      /** @enum {string|null} */
+      resolution: 'keep_existing' | 'accept_new' | null;
+    } | {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      knowledgeBaseId: string;
+      /** @enum {string} */
+      _type: 'sanity.context.issue';
+      /** @enum {number} */
+      schemaVersion: 1;
+      /** @description IssueContent */
+      content: {
+        /** @enum {string} */
+        kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+        /** @enum {string} */
+        severity: 'critical' | 'suggestion';
+        scopePath: string;
+        issue: string;
+        suggestedFix: string;
+        citedSourceIds?: string[];
+        claimKey?: string;
+        involvedScopes?: string[];
+        currentClaim?: string;
+        alternativeClaim?: string;
+        /** @enum {string} */
+        currentAuthority?: 'primary' | 'secondary' | 'community';
+        /** @enum {string} */
+        alternativeAuthority?: 'primary' | 'secondary' | 'community';
+        /** @enum {string} */
+        suggestedResolution?: 'keep_existing' | 'accept_new';
+      };
+      fingerprint: string;
+      revisionId: string | null;
+      /** @enum {string} */
+      status: 'rejected';
+      /** Format: date-time */
+      resolvedAt: string;
+      resolvedBy: {
+        id: string;
+        /** @enum {string} */
+        kind: 'user' | 'robot';
+      } | null;
+      /** @enum {string|null} */
+      resolution: null;
+    };
+    /** @description A `sanity.context.mcp` document, an org-owned MCP endpoint configuration stored in the organization store. Not returned by any endpoint raw; published so GROQ reads and trigger filters can be typed. Write through the mcp endpoints, never with a raw client. The mcp endpoints serve the validated wire view. */
+    McpDoc: {
+      _id: string;
+      _rev: string;
+      /** Format: date-time */
+      _createdAt: string;
+      /** Format: date-time */
+      _updatedAt: string;
+      /** @enum {string} */
+      _type: 'sanity.context.mcp';
+      /** @enum {number} */
+      schemaVersion: 1;
+      organizationId: string;
+      publicId: string;
+      title: string;
+      name: string;
+      sources: ({
+        /** @enum {string} */
+        type: 'knowledge-base';
+        id: string;
+      } | {
+        /** @enum {string} */
+        type: 'dataset';
+        id: string;
+      })[];
+      instructions: string | null;
+      groqFilter: string | null;
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+interface operations {
+  listKnowledgeBases: {
+    parameters: {
+      query: {
+        cursor?: string;
+        limit?: number;
+        organizationId: string;
+      };
+      header?: never;
+      path: {
+        apiVersion: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            data: {
+              /** Format: uuid */
+              id: string;
+              publicId: string;
+              organizationId: string;
+              title: string;
+              description: string;
+              /** @enum {string} */
+              state: 'created' | 'building' | 'ready' | 'review' | 'stale' | 'paused';
+              activeJobId: string | null;
+              isBuilding: boolean;
+              buildStageState: {
+                jobId: string;
+                stages: {
+                  /** @enum {string} */
+                  id: 'tldr' | 'map' | 'triage' | 'plan' | 'organize' | 'arrange' | 'write' | 'review' | 'polish';
+                  /** @enum {string} */
+                  status: 'pending' | 'running' | 'done' | 'failed';
+                  units?: {
+                    /** @enum {string} */
+                    unit: 'sources' | 'groups' | 'entries' | 'rounds';
+                    done: number;
+                    total?: number;
+                  };
+                }[];
+              } | null;
+              /** Format: date-time */
+              lastCheckedAt: string | null;
+              /** Format: date-time */
+              lastChangedAt: string | null;
+              hasPendingChanges: boolean;
+              pendingChanges: {
+                added: number;
+                changed: number;
+                removed: number;
+              } | null;
+              pipelineOutdated: boolean;
+              rebuildRecommended: {
+                reason: string;
+                /** Format: date-time */
+                at: string;
+              } | null;
+              hasWebSource: boolean;
+              hasDatasetSource: boolean;
+              sourceUsage: {
+                used: number;
+                limit: number;
+              } | null;
+              refreshEnabled: boolean;
+              /** @enum {string} */
+              refreshFrequency: 'weekly' | 'monthly';
+              /** Format: date-time */
+              refreshNextRunAt: string | null;
+              refreshInFlight: boolean;
+              openIssueCount: number;
+              instructionCount: number;
+              /** Format: date-time */
+              createdAt: string;
+              /** Format: date-time */
+              updatedAt: string;
+            }[];
+            nextCursor: string | null;
+          };
+        };
+      };
+    };
+  };
+  createKnowledgeBase: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        apiVersion: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': {
+          organizationId: string;
+          title: string;
+          description: string;
+        };
+      };
+    };
+    responses: {
+      /** @description KnowledgeBase */
+      201: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            id: string;
+            publicId: string;
+            organizationId: string;
+            title: string;
+            description: string;
+            /** @enum {string} */
+            state: 'created' | 'building' | 'ready' | 'review' | 'stale' | 'paused';
+            activeJobId: string | null;
+            isBuilding: boolean;
+            buildStageState: {
+              jobId: string;
+              stages: {
+                /** @enum {string} */
+                id: 'tldr' | 'map' | 'triage' | 'plan' | 'organize' | 'arrange' | 'write' | 'review' | 'polish';
+                /** @enum {string} */
+                status: 'pending' | 'running' | 'done' | 'failed';
+                units?: {
+                  /** @enum {string} */
+                  unit: 'sources' | 'groups' | 'entries' | 'rounds';
+                  done: number;
+                  total?: number;
+                };
+              }[];
+            } | null;
+            /** Format: date-time */
+            lastCheckedAt: string | null;
+            /** Format: date-time */
+            lastChangedAt: string | null;
+            hasPendingChanges: boolean;
+            pendingChanges: {
+              added: number;
+              changed: number;
+              removed: number;
+            } | null;
+            pipelineOutdated: boolean;
+            rebuildRecommended: {
+              reason: string;
+              /** Format: date-time */
+              at: string;
+            } | null;
+            hasWebSource: boolean;
+            hasDatasetSource: boolean;
+            sourceUsage: {
+              used: number;
+              limit: number;
+            } | null;
+            refreshEnabled: boolean;
+            /** @enum {string} */
+            refreshFrequency: 'weekly' | 'monthly';
+            /** Format: date-time */
+            refreshNextRunAt: string | null;
+            refreshInFlight: boolean;
+            openIssueCount: number;
+            instructionCount: number;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+          };
+        };
+      };
+    };
+  };
+  getKnowledgeBase: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description KnowledgeBase */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            id: string;
+            publicId: string;
+            organizationId: string;
+            title: string;
+            description: string;
+            /** @enum {string} */
+            state: 'created' | 'building' | 'ready' | 'review' | 'stale' | 'paused';
+            activeJobId: string | null;
+            isBuilding: boolean;
+            buildStageState: {
+              jobId: string;
+              stages: {
+                /** @enum {string} */
+                id: 'tldr' | 'map' | 'triage' | 'plan' | 'organize' | 'arrange' | 'write' | 'review' | 'polish';
+                /** @enum {string} */
+                status: 'pending' | 'running' | 'done' | 'failed';
+                units?: {
+                  /** @enum {string} */
+                  unit: 'sources' | 'groups' | 'entries' | 'rounds';
+                  done: number;
+                  total?: number;
+                };
+              }[];
+            } | null;
+            /** Format: date-time */
+            lastCheckedAt: string | null;
+            /** Format: date-time */
+            lastChangedAt: string | null;
+            hasPendingChanges: boolean;
+            pendingChanges: {
+              added: number;
+              changed: number;
+              removed: number;
+            } | null;
+            pipelineOutdated: boolean;
+            rebuildRecommended: {
+              reason: string;
+              /** Format: date-time */
+              at: string;
+            } | null;
+            hasWebSource: boolean;
+            hasDatasetSource: boolean;
+            sourceUsage: {
+              used: number;
+              limit: number;
+            } | null;
+            refreshEnabled: boolean;
+            /** @enum {string} */
+            refreshFrequency: 'weekly' | 'monthly';
+            /** Format: date-time */
+            refreshNextRunAt: string | null;
+            refreshInFlight: boolean;
+            openIssueCount: number;
+            instructionCount: number;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+          };
+        };
+      };
+    };
+  };
+  deleteKnowledgeBase: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': null;
+        };
+      };
+    };
+  };
+  updateKnowledgeBase: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': {
+          title?: string;
+          description?: string;
+          refreshEnabled?: boolean;
+          /** @enum {string} */
+          refreshFrequency?: 'weekly' | 'monthly';
+        };
+      };
+    };
+    responses: {
+      /** @description KnowledgeBase */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            id: string;
+            publicId: string;
+            organizationId: string;
+            title: string;
+            description: string;
+            /** @enum {string} */
+            state: 'created' | 'building' | 'ready' | 'review' | 'stale' | 'paused';
+            activeJobId: string | null;
+            isBuilding: boolean;
+            buildStageState: {
+              jobId: string;
+              stages: {
+                /** @enum {string} */
+                id: 'tldr' | 'map' | 'triage' | 'plan' | 'organize' | 'arrange' | 'write' | 'review' | 'polish';
+                /** @enum {string} */
+                status: 'pending' | 'running' | 'done' | 'failed';
+                units?: {
+                  /** @enum {string} */
+                  unit: 'sources' | 'groups' | 'entries' | 'rounds';
+                  done: number;
+                  total?: number;
+                };
+              }[];
+            } | null;
+            /** Format: date-time */
+            lastCheckedAt: string | null;
+            /** Format: date-time */
+            lastChangedAt: string | null;
+            hasPendingChanges: boolean;
+            pendingChanges: {
+              added: number;
+              changed: number;
+              removed: number;
+            } | null;
+            pipelineOutdated: boolean;
+            rebuildRecommended: {
+              reason: string;
+              /** Format: date-time */
+              at: string;
+            } | null;
+            hasWebSource: boolean;
+            hasDatasetSource: boolean;
+            sourceUsage: {
+              used: number;
+              limit: number;
+            } | null;
+            refreshEnabled: boolean;
+            /** @enum {string} */
+            refreshFrequency: 'weekly' | 'monthly';
+            /** Format: date-time */
+            refreshNextRunAt: string | null;
+            refreshInFlight: boolean;
+            openIssueCount: number;
+            instructionCount: number;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+          };
+        };
+      };
+    };
+  };
+  buildKnowledgeBase: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description JobAccepted */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            jobId: string;
+          };
+        };
+      };
+    };
+  };
+  cancelKnowledgeBaseBuild: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            cancelled: boolean;
+          };
+        };
+      };
+    };
+  };
+  rebuildEntry: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        entryPath: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description RebuildEntryResponse */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            jobId: string;
+            affectedEntries: {
+              id: string;
+              path: string;
+              title: string;
+            }[];
+          };
+        };
+      };
+    };
+  };
+  listImports: {
+    parameters: {
+      query?: {
+        cursor?: string;
+        limit?: number;
+      };
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            data: {
+              /** Format: uuid */
+              id: string;
+              /** Format: uuid */
+              knowledgeBaseId: string;
+              name: string | null;
+              sizeBytes: number | null;
+              /** @enum {string} */
+              status: 'uploading' | 'processing' | 'complete' | 'failed';
+              /** @enum {string} */
+              sourceKind: 'web' | 'file' | 'dataset';
+              /** Format: date-time */
+              lastCheckedAt: string | null;
+              sourceCount: number;
+              totalDistillableCount: number;
+              distilledCount: number;
+              unsupportedCount: number;
+              statusDetail: string | null;
+              error: string | null;
+              /** @description CrawlOptions */
+              crawlOptions: {
+                includePaths?: string[];
+                excludePaths?: string[];
+                maxDepth?: number;
+                sitemapOnly?: boolean;
+                ignoreQueryParameters?: boolean;
+                pageLimit?: number;
+              } | null;
+              /** @description DatasetSourceBinding */
+              datasetSource: {
+                sanityProjectId: string;
+                sanityDatasetId: string;
+                query: string;
+              } | null;
+              /** @description Actor */
+              createdBy: {
+                id: string | null;
+                displayName: string | null;
+              } | null;
+              /** Format: date-time */
+              createdAt: string;
+              /** Format: date-time */
+              completedAt: string | null;
+            }[];
+            nextCursor: string | null;
+          };
+        };
+      };
+    };
+  };
+  createImport: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    /** @description CreateImportInput */
+    requestBody: {
+      content: {
+        'application/json': {
+          /** @enum {string} */
+          type: 'text';
+          title: string;
+          content: string;
+          /**
+           * @default text/markdown
+           * @enum {string}
+           */
+          contentType?: 'text/markdown' | 'text/plain';
+        } | {
+          /** Format: uri */
+          url: string;
+          /** @description CrawlOptions */
+          options?: {
+            includePaths?: string[];
+            excludePaths?: string[];
+            maxDepth?: number;
+            sitemapOnly?: boolean;
+            ignoreQueryParameters?: boolean;
+            pageLimit?: number;
+          };
+          /** @enum {string} */
+          type: 'crawl';
+        } | {
+          sanityProjectId: string;
+          sanityDatasetId: string;
+          query: string;
+          /** @enum {string} */
+          type: 'dataset';
+        };
+      };
+    };
+    responses: {
+      /** @description JobAccepted */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            jobId: string;
+          };
+        };
+      };
+    };
+  };
+  startUpload: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': {
+          filename: string;
+          contentType?: string;
+        };
+      };
+    };
+    responses: {
+      /** @description Default Response */
+      201: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            importId: string;
+            /** Format: uri */
+            uploadUrl: string;
+          };
+        };
+      };
+    };
+  };
+  completeUpload: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        importId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description JobAccepted */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            jobId: string;
+          };
+        };
+      };
+    };
+  };
+  getImport: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        importId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Import */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            knowledgeBaseId: string;
+            name: string | null;
+            sizeBytes: number | null;
+            /** @enum {string} */
+            status: 'uploading' | 'processing' | 'complete' | 'failed';
+            /** @enum {string} */
+            sourceKind: 'web' | 'file' | 'dataset';
+            /** Format: date-time */
+            lastCheckedAt: string | null;
+            sourceCount: number;
+            totalDistillableCount: number;
+            distilledCount: number;
+            unsupportedCount: number;
+            statusDetail: string | null;
+            error: string | null;
+            /** @description CrawlOptions */
+            crawlOptions: {
+              includePaths?: string[];
+              excludePaths?: string[];
+              maxDepth?: number;
+              sitemapOnly?: boolean;
+              ignoreQueryParameters?: boolean;
+              pageLimit?: number;
+            } | null;
+            /** @description DatasetSourceBinding */
+            datasetSource: {
+              sanityProjectId: string;
+              sanityDatasetId: string;
+              query: string;
+            } | null;
+            /** @description Actor */
+            createdBy: {
+              id: string | null;
+              displayName: string | null;
+            } | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            completedAt: string | null;
+          };
+        };
+      };
+    };
+  };
+  deleteImport: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        importId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': null;
+        };
+      };
+    };
+  };
+  downloadImport: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        importId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uri */
+            url: string;
+            /** Format: date-time */
+            expiresAt: string;
+          };
+        };
+      };
+    };
+  };
+  createInstruction: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    /** @description CreateInstructionInput */
+    requestBody: {
+      content: {
+        'application/json': {
+          statement: string;
+          scopeSourceIds?: string[] | null;
+          rebuildPaths?: string[];
+          verified?: boolean;
+        };
+      };
+    };
+    responses: {
+      /** @description CreateInstructionResponse */
+      201: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** @description Instruction */
+            instruction: {
+              id: string;
+              knowledgeBaseId: string;
+              /** @enum {string} */
+              origin: 'conflict' | 'human';
+              /** @enum {string} */
+              status: 'active' | 'archived';
+              statement: string;
+              scopeSourceIds: string[] | null;
+              /** Format: date-time */
+              archivedAt: string | null;
+              archivedReason: string | null;
+              sourceIssueId: string | null;
+              /** @description Actor */
+              createdBy: {
+                id: string | null;
+                displayName: string | null;
+              } | null;
+              /** @description Actor */
+              updatedBy: {
+                id: string | null;
+                displayName: string | null;
+              } | null;
+              /** Format: date-time */
+              createdAt: string;
+              /** Format: date-time */
+              updatedAt: string | null;
+            };
+            rebuildJobId: string | null;
+          };
+        };
+      };
+    };
+  };
+  deleteInstruction: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        instructionId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': null;
+        };
+      };
+    };
+  };
+  updateInstruction: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        instructionId: string;
+      };
+      cookie?: never;
+    };
+    /** @description UpdateInstructionInput */
+    requestBody: {
+      content: {
+        'application/json': {
+          statement?: string;
+          scopeSourceIds?: string[] | null;
+        };
+      };
+    };
+    responses: {
+      /** @description Instruction */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            id: string;
+            knowledgeBaseId: string;
+            /** @enum {string} */
+            origin: 'conflict' | 'human';
+            /** @enum {string} */
+            status: 'active' | 'archived';
+            statement: string;
+            scopeSourceIds: string[] | null;
+            /** Format: date-time */
+            archivedAt: string | null;
+            archivedReason: string | null;
+            sourceIssueId: string | null;
+            /** @description Actor */
+            createdBy: {
+              id: string | null;
+              displayName: string | null;
+            } | null;
+            /** @description Actor */
+            updatedBy: {
+              id: string | null;
+              displayName: string | null;
+            } | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string | null;
+          };
+        };
+      };
+    };
+  };
+  applyIssues: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': {
+          issueIds: string[];
+        };
+      };
+    };
+    responses: {
+      /** @description JobAccepted */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            jobId: string;
+          };
+        };
+      };
+    };
+  };
+  dismissIssue: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        issueId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Issue */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            id: string;
+            knowledgeBaseId: string;
+            /** @description IssueContent */
+            content: {
+              /** @enum {string} */
+              kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+              /** @enum {string} */
+              severity: 'critical' | 'suggestion';
+              scopePath: string;
+              issue: string;
+              suggestedFix: string;
+              citedSourceIds?: string[];
+              claimKey?: string;
+              involvedScopes?: string[];
+              currentClaim?: string;
+              alternativeClaim?: string;
+              /** @enum {string} */
+              currentAuthority?: 'primary' | 'secondary' | 'community';
+              /** @enum {string} */
+              alternativeAuthority?: 'primary' | 'secondary' | 'community';
+              /** @enum {string} */
+              suggestedResolution?: 'keep_existing' | 'accept_new';
+            };
+            /** @enum {string} */
+            status: 'open' | 'accepted' | 'rejected';
+            /** @enum {string|null} */
+            resolution: 'keep_existing' | 'accept_new' | null;
+            /** @description IssueResolvedBy */
+            resolvedBy: {
+              id: string;
+              /** @enum {string} */
+              kind: 'user' | 'robot';
+            } | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            resolvedAt: string | null;
+          };
+        };
+      };
+    };
+  };
+  reopenIssue: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        issueId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Issue */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            id: string;
+            knowledgeBaseId: string;
+            /** @description IssueContent */
+            content: {
+              /** @enum {string} */
+              kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+              /** @enum {string} */
+              severity: 'critical' | 'suggestion';
+              scopePath: string;
+              issue: string;
+              suggestedFix: string;
+              citedSourceIds?: string[];
+              claimKey?: string;
+              involvedScopes?: string[];
+              currentClaim?: string;
+              alternativeClaim?: string;
+              /** @enum {string} */
+              currentAuthority?: 'primary' | 'secondary' | 'community';
+              /** @enum {string} */
+              alternativeAuthority?: 'primary' | 'secondary' | 'community';
+              /** @enum {string} */
+              suggestedResolution?: 'keep_existing' | 'accept_new';
+            };
+            /** @enum {string} */
+            status: 'open' | 'accepted' | 'rejected';
+            /** @enum {string|null} */
+            resolution: 'keep_existing' | 'accept_new' | null;
+            /** @description IssueResolvedBy */
+            resolvedBy: {
+              id: string;
+              /** @enum {string} */
+              kind: 'user' | 'robot';
+            } | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            resolvedAt: string | null;
+          };
+        };
+      };
+    };
+  };
+  resolveIssue: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        issueId: string;
+      };
+      cookie?: never;
+    };
+    requestBody: {
+      content: {
+        'application/json': {
+          /** @enum {string} */
+          resolution: 'keep_existing' | 'accept_new';
+        };
+      };
+    };
+    responses: {
+      /** @description ResolveIssueResponse */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** @description Issue */
+            issue: {
+              id: string;
+              knowledgeBaseId: string;
+              /** @description IssueContent */
+              content: {
+                /** @enum {string} */
+                kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+                /** @enum {string} */
+                severity: 'critical' | 'suggestion';
+                scopePath: string;
+                issue: string;
+                suggestedFix: string;
+                citedSourceIds?: string[];
+                claimKey?: string;
+                involvedScopes?: string[];
+                currentClaim?: string;
+                alternativeClaim?: string;
+                /** @enum {string} */
+                currentAuthority?: 'primary' | 'secondary' | 'community';
+                /** @enum {string} */
+                alternativeAuthority?: 'primary' | 'secondary' | 'community';
+                /** @enum {string} */
+                suggestedResolution?: 'keep_existing' | 'accept_new';
+              };
+              /** @enum {string} */
+              status: 'open' | 'accepted' | 'rejected';
+              /** @enum {string|null} */
+              resolution: 'keep_existing' | 'accept_new' | null;
+              /** @description IssueResolvedBy */
+              resolvedBy: {
+                id: string;
+                /** @enum {string} */
+                kind: 'user' | 'robot';
+              } | null;
+              /** Format: date-time */
+              createdAt: string;
+              /** Format: date-time */
+              resolvedAt: string | null;
+            };
+            jobId: string | null;
+          };
+        };
+      };
+    };
+  };
+  getJob: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        jobId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Job */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            id: string;
+            /** @enum {string} */
+            status: 'pending' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+            /** Format: date-time */
+            startedAt: string | null;
+            /** Format: date-time */
+            completedAt: string | null;
+            result?: unknown;
+            error?: string | null;
+          };
+        };
+      };
+    };
+  };
+  refreshKnowledgeBase: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description RefreshAccepted */
+      202: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            jobId: string;
+            started: boolean;
+          };
+        };
+      };
+    };
+  };
+  listSources: {
+    parameters: {
+      query?: {
+        cursor?: string;
+        limit?: number;
+        status?: 'pending' | 'processing' | 'ready' | 'failed' | 'skipped';
+        importId?: string;
+        ids?: string;
+      };
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            data: {
+              /** Format: uuid */
+              id: string;
+              /** Format: uuid */
+              knowledgeBaseId: string;
+              filename: string;
+              /** @enum {string} */
+              kind: 'web' | 'file' | 'dataset';
+              sizeBytes: number;
+              /** @enum {string} */
+              status: 'pending' | 'processing' | 'ready' | 'failed' | 'skipped';
+              tldr: string | null;
+              topics: string[] | null;
+              canonicalUrl: string | null;
+              /** Format: date-time */
+              fetchedAt: string | null;
+              /** Format: date-time */
+              distilledAt: string | null;
+              /** Format: date-time */
+              createdAt: string;
+            }[];
+            nextCursor: string | null;
+          };
+        };
+      };
+    };
+  };
+  getSource: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        sourceId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Source */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            id: string;
+            /** Format: uuid */
+            knowledgeBaseId: string;
+            filename: string;
+            /** @enum {string} */
+            kind: 'web' | 'file' | 'dataset';
+            sizeBytes: number;
+            /** @enum {string} */
+            status: 'pending' | 'processing' | 'ready' | 'failed' | 'skipped';
+            tldr: string | null;
+            topics: string[] | null;
+            canonicalUrl: string | null;
+            /** Format: date-time */
+            fetchedAt: string | null;
+            /** Format: date-time */
+            distilledAt: string | null;
+            /** Format: date-time */
+            createdAt: string;
+          };
+        };
+      };
+    };
+  };
+  deleteSource: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        sourceId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description Default Response */
+      204: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': null;
+        };
+      };
+    };
+  };
+  getSourceContent: {
+    parameters: {
+      query?: {
+        /** @description Output representation. `json` (default) returns the structured resource; `markdown` / `plain` return the rendered, LLM-ready text. */
+        format?: 'json' | 'markdown' | 'plain';
+        startLine?: number;
+        endLine?: number;
+      };
+      header?: never;
+      path: {
+        knowledgeBaseId: string;
+        sourceId: string;
+      };
+      cookie?: never;
+    };
+    requestBody?: never;
+    responses: {
+      /** @description SourceContent */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            /** Format: uuid */
+            sourceId: string;
+            content: string;
+            totalLines: number;
+            slice: {
+              start: number;
+              end: number;
+            };
+          };
+          'text/markdown': string;
+          'text/plain': string;
+        };
+      };
+    };
+  };
+  saveConversation: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        threadId: string;
+      };
+      cookie?: never;
+    };
+    /** @description SaveConversationInput */
+    requestBody: {
+      content: {
+        'application/json': {
+          messages: {
+            /** @enum {string} */
+            role: 'user' | 'assistant' | 'system' | 'tool';
+            /** @default null */
+            content?: string | null;
+            /** @default null */
+            toolName?: string | null;
+            /**
+             * @default null
+             * @enum {string|null}
+             */
+            toolType?: 'call' | 'result' | null;
+          }[];
+          modelProvider?: string;
+          modelId?: string;
+          /** @description ConversationTokenUsage */
+          tokenUsage?: {
+            inputTokens?: number;
+            outputTokens?: number;
+            totalTokens?: number;
+          };
+          /** @description ConversationMetadata */
+          metadata?: {
+            [key: string]: string | string[];
+          };
+        };
+      };
+    };
+    responses: {
+      /** @description Conversation */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            id: string;
+            threadId: string;
+            /** @description ConversationMetadata */
+            metadata: {
+              [key: string]: string | string[];
+            } | null;
+            /** Format: date-time */
+            startedAt: string;
+            /** Format: date-time */
+            messagesUpdatedAt: string;
+            messages: {
+              /** @enum {string} */
+              role: 'user' | 'assistant' | 'system' | 'tool';
+              /** @default null */
+              content: string | null;
+              /** @default null */
+              toolName: string | null;
+              /**
+               * @default null
+               * @enum {string|null}
+               */
+              toolType: 'call' | 'result' | null;
+            }[];
+            modelProvider: string | null;
+            modelId: string | null;
+            /** @description ConversationTokenUsage */
+            tokenUsage: {
+              inputTokens?: number;
+              outputTokens?: number;
+              totalTokens?: number;
+            } | null;
+            /** @description ConversationCoreMetrics */
+            coreMetrics: {
+              successScore?: number;
+              /** @enum {string} */
+              sentiment?: 'positive' | 'neutral' | 'negative';
+              contentGaps?: string[];
+            } | null;
+            /** Format: date-time */
+            classifiedAt: string | null;
+            classificationError: string | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+          };
+        };
+      };
+    };
+  };
+  classifyConversation: {
+    parameters: {
+      query?: never;
+      header?: never;
+      path: {
+        threadId: string;
+      };
+      cookie?: never;
+    };
+    /** @description ClassifyConversationInput */
+    requestBody: {
+      content: {
+        'application/json': {
+          coreMetrics?: {
+            successScore: number;
+            /** @enum {string} */
+            sentiment: 'positive' | 'neutral' | 'negative';
+            contentGaps: string[];
+          };
+          classificationError?: string;
+        };
+      };
+    };
+    responses: {
+      /** @description Conversation */
+      200: {
+        headers: {
+          [name: string]: unknown;
+        };
+        content: {
+          'application/json': {
+            id: string;
+            threadId: string;
+            /** @description ConversationMetadata */
+            metadata: {
+              [key: string]: string | string[];
+            } | null;
+            /** Format: date-time */
+            startedAt: string;
+            /** Format: date-time */
+            messagesUpdatedAt: string;
+            messages: {
+              /** @enum {string} */
+              role: 'user' | 'assistant' | 'system' | 'tool';
+              /** @default null */
+              content: string | null;
+              /** @default null */
+              toolName: string | null;
+              /**
+               * @default null
+               * @enum {string|null}
+               */
+              toolType: 'call' | 'result' | null;
+            }[];
+            modelProvider: string | null;
+            modelId: string | null;
+            /** @description ConversationTokenUsage */
+            tokenUsage: {
+              inputTokens?: number;
+              outputTokens?: number;
+              totalTokens?: number;
+            } | null;
+            /** @description ConversationCoreMetrics */
+            coreMetrics: {
+              successScore?: number;
+              /** @enum {string} */
+              sentiment?: 'positive' | 'neutral' | 'negative';
+              contentGaps?: string[];
+            } | null;
+            /** Format: date-time */
+            classifiedAt: string | null;
+            classificationError: string | null;
+            /** Format: date-time */
+            createdAt: string;
+            /** Format: date-time */
+            updatedAt: string;
+          };
+        };
+      };
+    };
+  };
+}
+declare namespace types_d_exports {
+  export { ApplyIssuesParams, ApplyIssuesResponse, ClassifyConversationParams, ContextListenOptions, ContextRequestOptions, Conversation, ConversationDoc, CreateFileImportParams, CreateImportParams, CreateInstructionParams, CreateInstructionResponse, CreateKnowledgeBaseParams, DismissIssueResponse, EditInstructionParams, EditKnowledgeBaseParams, Entry, EntryDoc, Import, ImportDetail, ImportDownloadResponse, ImportsResponse, Instruction, InstructionDoc, IssueDoc, Job, JobAccepted, KnowledgeBase, KnowledgeBasesResponse, McpDoc, RebuildEntryResponse, ReopenIssueResponse, RequestOptions$2 as RequestOptions, ResolveIssueParams, ResolveIssueResponse, SaveConversationParams, Source, SourceContentResponse, SourceDetail, SourcesResponse, StagedUpload, possibleStoreRequestOptions };
+}
+/** Options accepted by every Context method. @beta */
+type RequestOptions$2 = {
+  signal?: AbortSignal;
+  tag?: string;
+};
+/** @internal */
+declare const possibleStoreRequestOptions: readonly ['headers', 'signal', 'tag', 'timeout', 'token'];
+/**
+ * Request options honored by `context.fetch`.
+ *
+ * @beta
+ */
+type ContextRequestOptions = Pick<RequestOptions, (typeof possibleStoreRequestOptions)[number]>;
+/**
+ * Listener options for `context.listen`.
+ *
+ * `includeAllVersions` is left out: Context documents are written by the
+ * Context API with no drafts or versions, so it would never make a
+ * difference.
+ *
+ * @beta
+ */
+type ContextListenOptions = Omit<ListenOptions, 'includeAllVersions'> | Omit<ResumableListenOptions, 'includeAllVersions'>;
+/**
+ * A file import. The client stages the upload, PUTs the bytes straight to
+ * storage with a signed URL, and confirms. The Context API never holds the
+ * file content.
+ * @beta
+ */
+type CreateFileImportParams = {
+  type: 'file';
+  /** Same shapes `assets.upload` accepts, minus node streams: the bytes go
+   * out through `fetch`, which has no portable stream support. */
+  file: Exclude<UploadBody, NodeJS.ReadableStream>;
+  filename: string;
+  contentType?: string;
+};
+type KnowledgeBasesPath = '/{apiVersion}/context/knowledge-bases';
+type ConversationPath = '/{apiVersion}/context/organizations/{organizationId}/conversations/{threadId}';
+type KnowledgeBasePath = '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}';
+type ImportsPath = `${KnowledgeBasePath}/imports`;
+type ImportPath = `${KnowledgeBasePath}/imports/{importId}`;
+type UploadsPath = `${KnowledgeBasePath}/imports/uploads`;
+type EntryRebuildPath = `${KnowledgeBasePath}/entries/{entryPath}/rebuild`;
+type SourcesPath = `${KnowledgeBasePath}/sources`;
+type SourcePath = `${KnowledgeBasePath}/sources/{sourceId}`;
+type SourceContentPath = `${KnowledgeBasePath}/sources/{sourceId}/content`;
+type IssuesApplyPath = `${KnowledgeBasePath}/issues/apply`;
+type InstructionPath = `${KnowledgeBasePath}/instructions/{instructionId}`;
+type JobPath = `${KnowledgeBasePath}/jobs/{jobId}`;
+type IssueResolvePath = `${KnowledgeBasePath}/issues/{issueId}/resolve`;
+type IssueDismissPath = `${KnowledgeBasePath}/issues/{issueId}/dismiss`;
+type IssueReopenPath = `${KnowledgeBasePath}/issues/{issueId}/reopen`;
+type InstructionsPath = `${KnowledgeBasePath}/instructions`;
+type JsonResponse<T> = T extends {
+  content: {
+    'application/json': infer R;
+  };
+} ? R : never;
+type JsonBody<T> = T extends {
+  requestBody: {
+    content: {
+      'application/json': infer R;
+    };
+  };
+} ? R : never;
+/**
+ * A knowledge base: one buildable body of knowledge inside Context.
+ * @beta
+ */
+type KnowledgeBase = JsonResponse<paths[KnowledgeBasePath]['get']['responses']['200']>;
+/**
+ * Parameters for creating a knowledge base.
+ * @beta
+ */
+type CreateKnowledgeBaseParams = JsonBody<paths[KnowledgeBasesPath]['post']>;
+/** @beta */
+type EditKnowledgeBaseParams = JsonBody<paths[KnowledgeBasePath]['patch']>;
+/**
+ * Parameters for importing content. Discriminated on `type`:
+ * inline text, a website crawl, or a Sanity dataset bind.
+ * @beta
+ */
+type CreateImportParams = JsonBody<paths[ImportsPath]['post']>;
+/**
+ * Accepted async work. Poll the job with `jobs.get` until it reaches a
+ * terminal state.
+ * @beta
+ */
+type JobAccepted = JsonResponse<paths[`${KnowledgeBasePath}/build`]['post']['responses']['202']>;
+/** @beta */
+type Job = JsonResponse<paths[JobPath]['get']['responses']['200']>;
+/**
+ * Accepted entry rebuild: the job to poll plus every entry the rebuild
+ * touches.
+ * @beta
+ */
+type RebuildEntryResponse = JsonResponse<paths[EntryRebuildPath]['post']['responses']['202']>;
+/** @beta */
+type ApplyIssuesParams = JsonBody<paths[IssuesApplyPath]['post']>;
+/** @beta */
+type ApplyIssuesResponse = JsonResponse<paths[IssuesApplyPath]['post']['responses']['202']>;
+/** @beta */
+type ResolveIssueParams = JsonBody<paths[IssueResolvePath]['post']>;
+/** @beta */
+type ResolveIssueResponse = JsonResponse<paths[IssueResolvePath]['post']['responses']['200']>;
+/** @beta */
+type DismissIssueResponse = JsonResponse<paths[IssueDismissPath]['post']['responses']['200']>;
+/** @beta */
+type ReopenIssueResponse = JsonResponse<paths[IssueReopenPath]['post']['responses']['200']>;
+/** @beta */
+type CreateInstructionParams = JsonBody<paths[InstructionsPath]['post']>;
+/**
+ * A standing instruction, as the instruction endpoints return it.
+ * @beta
+ */
+type Instruction = JsonResponse<paths[InstructionPath]['patch']['responses']['200']>;
+/** The created instruction, wrapped the way the create endpoint returns it. @beta */
+type CreateInstructionResponse = JsonResponse<paths[InstructionsPath]['post']['responses']['201']>;
+/** @beta */
+type EditInstructionParams = JsonBody<paths[InstructionPath]['patch']>;
+/** @beta */
+type KnowledgeBasesResponse = JsonResponse<paths[KnowledgeBasesPath]['get']['responses']['200']>;
+/** @beta */
+type ImportsResponse = JsonResponse<paths[ImportsPath]['get']['responses']['200']>;
+/** @beta */
+type Import = ImportsResponse['data'][number];
+/** @beta */
+type ImportDetail = JsonResponse<paths[ImportPath]['get']['responses']['200']>;
+/** @beta */
+type ImportDownloadResponse = JsonResponse<paths[`${ImportPath}/download`]['get']['responses']['200']>;
+/**
+ * The staged half of a file upload: PUT the bytes to `uploadUrl`, then
+ * confirm with the complete endpoint. `imports.create({type: 'file'})` does
+ * all of this in one call.
+ * @beta
+ */
+type StagedUpload = JsonResponse<paths[UploadsPath]['post']['responses']['201']>;
+/** @beta */
+type SourcesResponse = JsonResponse<paths[SourcesPath]['get']['responses']['200']>;
+/** @beta */
+type Source = SourcesResponse['data'][number];
+/** @beta */
+type SourceDetail = JsonResponse<paths[SourcePath]['get']['responses']['200']>;
+/** @beta */
+type SourceContentResponse = JsonResponse<paths[SourceContentPath]['get']['responses']['200']>;
+/**
+ * A recorded conversation: one agent thread's transcript plus the
+ * classification recorded on it. Standalone org-level telemetry — dimensions
+ * (MCP endpoints, app, the customer's own keys) live in the `metadata` bag.
+ * @beta
+ */
+type Conversation = JsonResponse<paths[ConversationPath]['put']['responses']['200']>;
+/**
+ * Body for the conversation ingest upsert. Messages replace the stored
+ * transcript wholesale; `metadata` and model fields only overwrite when
+ * present.
+ * @beta
+ */
+type SaveConversationParams = JsonBody<paths[ConversationPath]['put']>;
+/** Exactly one of a verdict (`coreMetrics`) or a failure (`classificationError`). @beta */
+type ClassifyConversationParams = JsonBody<paths[ConversationPath]['patch']>;
+/**
+ * The raw `sanity.context.entry` document shape, as stored in the
+ * organization's document store. For typing GROQ reads.
+ * @beta
+ */
+type EntryDoc = components['schemas']['EntryDoc'];
+/** @beta */
+type IssueDoc = components['schemas']['IssueDoc'];
+/** @beta */
+type InstructionDoc = components['schemas']['InstructionDoc'];
+/**
+ * The raw `sanity.context.mcp` document shape (an MCP endpoint
+ * configuration), as stored in the organization's document store. For
+ * typing GROQ reads.
+ * @beta
+ */
+type McpDoc = components['schemas']['McpDoc'];
+/**
+ * The metadata view of an entry, as `entries.list` projects it. Bodies stay
+ * behind `entries.get` (or a GROQ read through `context.fetch`).
+ * @beta
+ */
+type Entry = Pick<EntryDoc, '_id' | 'path' | 'title' | 'tldr' | 'status'>;
+/**
+ * The raw `sanity.context.conversation` document shape, as stored in the
+ * organization's document store. For typing GROQ reads.
+ * @beta
+ */
+type ConversationDoc = components['schemas']['ConversationDoc'];
+type ListOptions$1 = RequestOptions$2 & {
+  cursor?: string;
+  limit?: number;
+};
+/**
+ * `client.context` — knowledge bases and everything scoped to them.
+ *
+ * Collection-level management (create, list, get, edit, delete) addresses
+ * knowledge bases per call, like `client.projects`. Everything scoped to one
+ * knowledge base (imports, builds, issues, entries, ...) operates on the
+ * client's configured `resource`, like media libraries:
+ *
+ * @example Full lifecycle
+ * ```ts
+ * const created = await client.context.knowledgeBases.create({
+ *   organizationId: 'org123',
+ *   title: 'Support docs',
+ *   description: 'Product docs and troubleshooting guides',
+ * })
+ *
+ * const kb = createClient({
+ *   apiVersion: '2026-08-25',
+ *   token,
+ *   resource: {type: 'knowledge-base', id: created.publicId},
+ * })
+ *
+ * await kb.context.imports.create({type: 'text', title: 'Refund policy', content: refundMd})
+ * const {jobId} = await kb.context.build()
+ * ```
+ *
+ * @beta
+ */
+declare class ContextClient {
+  #private;
+  constructor(client: SanityClient, httpRequest: HttpRequest);
+  /** The knowledge base collection: management addressed per call. */
+  knowledgeBases: {
+    /** Create a knowledge base. Requires the org-level knowledge-base create grant. */
+    create: (params: CreateKnowledgeBaseParams, options?: RequestOptions$2) => Promise<KnowledgeBase>;
+    /** List the organization's knowledge bases. */
+    list: (params: {
+      organizationId: string;
+    } & ListOptions$1) => Promise<KnowledgeBasesResponse>;
+    /** Fetch a knowledge base by its id. */
+    get: (knowledgeBaseId: string, options?: RequestOptions$2) => Promise<KnowledgeBase>;
+    /** Edit a knowledge base's configuration. */
+    edit: (knowledgeBaseId: string, params: EditKnowledgeBaseParams, options?: RequestOptions$2) => Promise<KnowledgeBase>;
+    /** Delete a knowledge base and its generated content. */
+    delete: (knowledgeBaseId: string, options?: RequestOptions$2) => Promise<void>;
+  };
+  /**
+   * GROQ over the organization's Context documents (conversation telemetry
+   * today; the store holds every Context family and the caller's access
+   * decides what a query returns, so filter on `_type`).
+   *
+   * Requires `context.organizationId` in the client configuration.
+   */
+  fetch<R = unknown>(query: string, params?: QueryParams, options?: ContextRequestOptions): Promise<R>;
+  /**
+   * Listen for changes to the organization's Context documents. Mirrors
+   * `client.listen(query, params, options)` and emits mutation events by
+   * default.
+   */
+  listen<Opts extends ContextListenOptions | undefined = undefined>(query: string, params?: QueryParams, options?: Opts): Observable<ListenEventFromOptions<SanityDocument, Opts>>;
+  /**
+   * Conversation telemetry. `threadId` identifies the conversation within
+   * the organization — reuse means the same conversation. Beyond the canned
+   * `get`, reads go through {@link fetch} and {@link listen} with GROQ
+   * (`_type == "sanity.context.conversation"`).
+   *
+   * Requires `context.organizationId` in the client configuration.
+   */
+  conversations: {
+    /**
+     * Record a conversation. Messages replace the stored transcript
+     * wholesale; `metadata` and model fields only overwrite when present.
+     * Last write per thread wins — retries are safe.
+     */
+    save: (params: {
+      threadId: string;
+    } & SaveConversationParams, options?: RequestOptions$2) => Promise<Conversation>;
+    /**
+     * Record the classification your own model produced for one thread:
+     * exactly one of `coreMetrics` (a verdict) or `classificationError`
+     * (why classification failed).
+     */
+    classify: (params: {
+      threadId: string;
+    } & ClassifyConversationParams, options?: RequestOptions$2) => Promise<Conversation>;
+    /**
+     * One recorded conversation by its thread id, or `null` when the thread
+     * was never recorded. Runs:
+     *
+     * `*[_type == "sanity.context.conversation" && organizationId == $org && threadId == $threadId][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      threadId: string;
+    }, options?: ContextRequestOptions) => Promise<ConversationDoc | null>;
+  };
+  /**
+   * Build the configured knowledge base. The server waits for pending import
+   * processing before assembling, so importing and building back to back is
+   * safe. Track the returned job with {@link jobs}.
+   */
+  build(options?: RequestOptions$2): Promise<JobAccepted>;
+  /** Cancel the running build, if any. */
+  cancelBuild(options?: RequestOptions$2): Promise<{
+    cancelled: boolean;
+  }>;
+  /** Run an incremental refresh: re-check sources and apply what changed. */
+  refresh(options?: RequestOptions$2): Promise<{
+    jobId: string;
+    started: boolean;
+  }>;
+  /** Imports: feed content into the configured knowledge base. */
+  imports: {
+    /**
+     * Import content. One entry point, discriminated on `type`: inline
+     * `text`, a website `crawl`, a Sanity `dataset` bind, or a `file`
+     * upload. Processing queues automatically. The file variant stages the
+     * upload, PUTs the bytes to a signed storage URL, and confirms; the
+     * bytes never pass through the Context API.
+     */
+    create: (params: CreateImportParams | CreateFileImportParams, options?: RequestOptions$2) => Promise<JobAccepted>;
+    list: (params?: ListOptions$1) => Promise<{
+      data: {
+        id: string;
+        knowledgeBaseId: string;
+        name: string | null;
+        sizeBytes: number | null;
+        status: 'uploading' | 'processing' | 'complete' | 'failed';
+        sourceKind: 'web' | 'file' | 'dataset';
+        lastCheckedAt: string | null;
+        sourceCount: number;
+        totalDistillableCount: number;
+        distilledCount: number;
+        unsupportedCount: number;
+        statusDetail: string | null;
+        error: string | null;
+        crawlOptions: {
+          includePaths?: string[];
+          excludePaths?: string[];
+          maxDepth?: number;
+          sitemapOnly?: boolean;
+          ignoreQueryParameters?: boolean;
+          pageLimit?: number;
+        } | null;
+        datasetSource: {
+          sanityProjectId: string;
+          sanityDatasetId: string;
+          query: string;
+        } | null;
+        createdBy: {
+          id: string | null;
+          displayName: string | null;
+        } | null;
+        createdAt: string;
+        completedAt: string | null;
+      }[];
+      nextCursor: string | null;
+    }>;
+    get: (params: {
+      importId: string;
+    }, options?: RequestOptions$2) => Promise<{
+      id: string;
+      knowledgeBaseId: string;
+      name: string | null;
+      sizeBytes: number | null;
+      status: 'uploading' | 'processing' | 'complete' | 'failed';
+      sourceKind: 'web' | 'file' | 'dataset';
+      lastCheckedAt: string | null;
+      sourceCount: number;
+      totalDistillableCount: number;
+      distilledCount: number;
+      unsupportedCount: number;
+      statusDetail: string | null;
+      error: string | null;
+      crawlOptions: {
+        includePaths?: string[];
+        excludePaths?: string[];
+        maxDepth?: number;
+        sitemapOnly?: boolean;
+        ignoreQueryParameters?: boolean;
+        pageLimit?: number;
+      } | null;
+      datasetSource: {
+        sanityProjectId: string;
+        sanityDatasetId: string;
+        query: string;
+      } | null;
+      createdBy: {
+        id: string | null;
+        displayName: string | null;
+      } | null;
+      createdAt: string;
+      completedAt: string | null;
+    }>;
+    /** A short-lived signed URL for the original uploaded bytes. */
+    download: (params: {
+      importId: string;
+    }, options?: RequestOptions$2) => Promise<{
+      url: string;
+      expiresAt: string;
+    }>;
+    delete: (params: {
+      importId: string;
+    }, options?: RequestOptions$2) => Promise<void>;
+  };
+  /** Jobs: poll async work (builds, imports) to a terminal state. */
+  jobs: {
+    get: (params: {
+      jobId: string;
+    }, options?: RequestOptions$2) => Promise<{
+      id: string;
+      status: 'pending' | 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+      startedAt: string | null;
+      completedAt: string | null;
+      result?: unknown;
+      error?: string | null;
+    }>;
+  };
+  /**
+   * Issues: findings from builds awaiting triage. Reads are canned GROQ
+   * queries against the organization's document store; for anything more,
+   * use {@link fetch}. Reads require `context.organizationId` alongside the
+   * knowledge-base `resource` in the client configuration.
+   */
+  issues: {
+    /**
+     * Every issue on the knowledge base, oldest first, optionally narrowed
+     * to one status. Drains keyset pages internally and resolves with the
+     * complete set. Runs:
+     *
+     * `*[_type == "sanity.context.issue" && knowledgeBaseId == $kb && status == $status] | order(_createdAt asc, _id asc)`
+     *
+     * (the status clause only when given). For anything more, use {@link fetch}.
+     */
+    list: (params?: {
+      status?: 'open' | 'accepted' | 'rejected';
+    }, options?: ContextRequestOptions) => Promise<IssueDoc[]>;
+    /**
+     * One issue by its document id, or `null` when it does not exist. Runs:
+     *
+     * `*[_type == "sanity.context.issue" && knowledgeBaseId == $kb && _id == $id][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      issueId: string;
+    }, options?: ContextRequestOptions) => Promise<IssueDoc | null>;
+    /** Resolve a conflict issue. Mints the standing instruction, same as the dashboard. */
+    resolve: (params: {
+      issueId: string;
+    } & ResolveIssueParams, options?: RequestOptions$2) => Promise<{
+      issue: {
+        id: string;
+        knowledgeBaseId: string;
+        content: {
+          kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+          severity: 'critical' | 'suggestion';
+          scopePath: string;
+          issue: string;
+          suggestedFix: string;
+          citedSourceIds?: string[];
+          claimKey?: string;
+          involvedScopes?: string[];
+          currentClaim?: string;
+          alternativeClaim?: string;
+          currentAuthority?: 'primary' | 'secondary' | 'community';
+          alternativeAuthority?: 'primary' | 'secondary' | 'community';
+          suggestedResolution?: 'keep_existing' | 'accept_new';
+        };
+        status: 'open' | 'accepted' | 'rejected';
+        resolution: 'keep_existing' | 'accept_new' | null;
+        resolvedBy: {
+          id: string;
+          kind: 'user' | 'robot';
+        } | null;
+        createdAt: string;
+        resolvedAt: string | null;
+      };
+      jobId: string | null;
+    }>;
+    dismiss: (params: {
+      issueId: string;
+    }, options?: RequestOptions$2) => Promise<{
+      id: string;
+      knowledgeBaseId: string;
+      content: {
+        kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+        severity: 'critical' | 'suggestion';
+        scopePath: string;
+        issue: string;
+        suggestedFix: string;
+        citedSourceIds?: string[];
+        claimKey?: string;
+        involvedScopes?: string[];
+        currentClaim?: string;
+        alternativeClaim?: string;
+        currentAuthority?: 'primary' | 'secondary' | 'community';
+        alternativeAuthority?: 'primary' | 'secondary' | 'community';
+        suggestedResolution?: 'keep_existing' | 'accept_new';
+      };
+      status: 'open' | 'accepted' | 'rejected';
+      resolution: 'keep_existing' | 'accept_new' | null;
+      resolvedBy: {
+        id: string;
+        kind: 'user' | 'robot';
+      } | null;
+      createdAt: string;
+      resolvedAt: string | null;
+    }>;
+    reopen: (params: {
+      issueId: string;
+    }, options?: RequestOptions$2) => Promise<{
+      id: string;
+      knowledgeBaseId: string;
+      content: {
+        kind: 'conflict' | 'gap' | 'update_required' | 'add_entry' | 'remove_entry' | 'split_entry' | 'merge_entry';
+        severity: 'critical' | 'suggestion';
+        scopePath: string;
+        issue: string;
+        suggestedFix: string;
+        citedSourceIds?: string[];
+        claimKey?: string;
+        involvedScopes?: string[];
+        currentClaim?: string;
+        alternativeClaim?: string;
+        currentAuthority?: 'primary' | 'secondary' | 'community';
+        alternativeAuthority?: 'primary' | 'secondary' | 'community';
+        suggestedResolution?: 'keep_existing' | 'accept_new';
+      };
+      status: 'open' | 'accepted' | 'rejected';
+      resolution: 'keep_existing' | 'accept_new' | null;
+      resolvedBy: {
+        id: string;
+        kind: 'user' | 'robot';
+      } | null;
+      createdAt: string;
+      resolvedAt: string | null;
+    }>;
+    /** Apply already-accepted issues to the knowledge base in one batch. */
+    apply: (params: ApplyIssuesParams, options?: RequestOptions$2) => Promise<{
+      jobId: string;
+    }>;
+  };
+  /** Instructions: standing decisions that steer every build. */
+  instructions: {
+    create: (params: CreateInstructionParams, options?: RequestOptions$2) => Promise<CreateInstructionResponse>;
+    /**
+     * Every current-schema instruction on the knowledge base, oldest first.
+     * Drains keyset pages internally and resolves with the complete set.
+     * Runs:
+     *
+     * `*[_type == "sanity.context.instruction" && knowledgeBaseId == $kb && schemaVersion == 1] | order(_createdAt asc, _id asc)`
+     *
+     * For anything more, use {@link fetch}. Requires `context.organizationId`
+     * alongside the knowledge-base `resource` in the client configuration.
+     */
+    list: (options?: ContextRequestOptions) => Promise<InstructionDoc[]>;
+    edit: (params: {
+      instructionId: string;
+    } & EditInstructionParams, options?: RequestOptions$2) => Promise<{
+      id: string;
+      knowledgeBaseId: string;
+      origin: 'conflict' | 'human';
+      status: 'active' | 'archived';
+      statement: string;
+      scopeSourceIds: string[] | null;
+      archivedAt: string | null;
+      archivedReason: string | null;
+      sourceIssueId: string | null;
+      createdBy: {
+        id: string | null;
+        displayName: string | null;
+      } | null;
+      updatedBy: {
+        id: string | null;
+        displayName: string | null;
+      } | null;
+      createdAt: string;
+      updatedAt: string | null;
+    }>;
+    delete: (params: {
+      instructionId: string;
+    }, options?: RequestOptions$2) => Promise<void>;
+  };
+  /**
+   * Entries: the built outline, one entry per node. Reads are canned GROQ
+   * queries against the organization's document store; for anything more,
+   * use {@link fetch}. Requires `context.organizationId` alongside the
+   * knowledge-base `resource` in the client configuration.
+   */
+  entries: {
+    /**
+     * Every entry, path-ordered, as a metadata view (`_id`, `path`,
+     * `title`, `tldr`, `status`) with bodies excluded. Drains keyset pages
+     * internally and resolves with the complete set. Runs:
+     *
+     * `*[_type == "sanity.context.entry" && knowledgeBaseId == $kb && path > $after] | order(path asc) [0...200] {_id, path, title, tldr, status}`
+     *
+     * For bodies, use `entries.get` or {@link fetch}.
+     */
+    list: (options?: ContextRequestOptions) => Promise<Entry[]>;
+    /**
+     * One entry with its full body and citations, by outline path (e.g.
+     * `billing/refunds`), or `null` when no entry sits at that path. Runs:
+     *
+     * `*[_type == "sanity.context.entry" && knowledgeBaseId == $kb && path == $path][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      path: string;
+    }, options?: ContextRequestOptions) => Promise<EntryDoc | null>;
+    /**
+     * Rebuild one entry from its already-placed sources, by outline path.
+     * Poll the returned job with {@link jobs}; `affectedEntries` lists every
+     * entry the rebuild touches.
+     */
+    rebuild: (params: {
+      path: string;
+    }, options?: RequestOptions$2) => Promise<RebuildEntryResponse>;
+  };
+  /**
+   * MCP endpoint configurations, org-owned documents read with canned GROQ
+   * queries. Requires `context.organizationId` in the client configuration.
+   */
+  mcpEndpoints: {
+    /**
+     * The organization's MCP endpoint configurations, oldest first. Runs:
+     *
+     * `*[_type == "sanity.context.mcp" && organizationId == $org] | order(_createdAt asc, _id asc) [0...500]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    list: (options?: ContextRequestOptions) => Promise<McpDoc[]>;
+    /**
+     * One MCP endpoint configuration by its URL name, or `null` when none
+     * carries that name. Runs:
+     *
+     * `*[_type == "sanity.context.mcp" && organizationId == $org && name == $name][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      name: string;
+    }, options?: ContextRequestOptions) => Promise<McpDoc | null>;
+  };
+  /** Sources: the distilled units builds cite. */
+  sources: {
+    /**
+     * List sources, optionally filtered by `status` or the `importId` they
+     * came from. `ids` is a lookup mode: it resolves those exact sources
+     * (e.g. from an entry's citations) and overrides `status` and `cursor`.
+     */
+    list: (params?: {
+      status?: Source['status'];
+      importId?: string;
+      ids?: string[];
+    } & ListOptions$1) => Promise<{
+      data: {
+        id: string;
+        knowledgeBaseId: string;
+        filename: string;
+        kind: 'web' | 'file' | 'dataset';
+        sizeBytes: number;
+        status: 'pending' | 'processing' | 'ready' | 'failed' | 'skipped';
+        tldr: string | null;
+        topics: string[] | null;
+        canonicalUrl: string | null;
+        fetchedAt: string | null;
+        distilledAt: string | null;
+        createdAt: string;
+      }[];
+      nextCursor: string | null;
+    }>;
+    get: (params: {
+      sourceId: string;
+    }, options?: RequestOptions$2) => Promise<{
+      id: string;
+      knowledgeBaseId: string;
+      filename: string;
+      kind: 'web' | 'file' | 'dataset';
+      sizeBytes: number;
+      status: 'pending' | 'processing' | 'ready' | 'failed' | 'skipped';
+      tldr: string | null;
+      topics: string[] | null;
+      canonicalUrl: string | null;
+      fetchedAt: string | null;
+      distilledAt: string | null;
+      createdAt: string;
+    }>;
+    /**
+     * Distilled source content, optionally a line range: the evidence behind
+     * a citation or an issue.
+     */
+    content: (params: {
+      sourceId: string;
+      startLine?: number;
+      endLine?: number;
+    }, options?: RequestOptions$2) => Promise<{
+      sourceId: string;
+      content: string;
+      totalLines: number;
+      slice: {
+        start: number;
+        end: number;
+      };
+    }>;
+    delete: (params: {
+      sourceId: string;
+    }, options?: RequestOptions$2) => Promise<void>;
+  };
+}
+/**
+ * Observable counterpart of {@link ContextClient}. Collection-level
+ * methods and the GROQ-backed reads; knowledge-base scoped write
+ * operations are promise-based, so use the promise client
+ * (`client.context`) for those.
+ *
+ * @beta
+ */
+declare class ObservableContextClient {
+  #private;
+  constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
+  /** The knowledge base collection: management addressed per call. */
+  knowledgeBases: {
+    /** Create a knowledge base. Requires the org-level knowledge-base create grant. */
+    create: (params: CreateKnowledgeBaseParams, options?: RequestOptions$2) => Observable<KnowledgeBase>;
+    /** List the organization's knowledge bases. */
+    list: (params: {
+      organizationId: string;
+    } & ListOptions$1) => Observable<KnowledgeBasesResponse>;
+    /** Fetch a knowledge base by its id. */
+    get: (knowledgeBaseId: string, options?: RequestOptions$2) => Observable<KnowledgeBase>;
+    /** Edit a knowledge base's configuration. */
+    edit: (knowledgeBaseId: string, params: EditKnowledgeBaseParams, options?: RequestOptions$2) => Observable<KnowledgeBase>;
+    /** Delete a knowledge base and its generated content. */
+    delete: (knowledgeBaseId: string, options?: RequestOptions$2) => Observable<void>;
+  };
+  /**
+   * GROQ over the organization's Context documents (conversation telemetry
+   * today; the store holds every Context family and the caller's access
+   * decides what a query returns, so filter on `_type`).
+   *
+   * Requires `context.organizationId` in the client configuration.
    */
-  getTargetDocumentRef(documentId: string): CollaborationCommentDocument['target']['document']['_ref'];
+  fetch<R = unknown>(query: string, params?: QueryParams, options?: ContextRequestOptions): Observable<R>;
   /**
-   * Fetch comments on the configured resource.
-   *
-   * Takes the same `query` and `params` as `client.fetch`, and switches from a
-   * GET to a POST for queries too large for the request URL in the same way,
-   * but queries the comments endpoint, which accepts none of the query options
-   * `client.fetch` does (`perspective`, `useCdn`, `filterResponse`,
-   * `resultSourceMap`, stega).
-   *
-   * The query runs against the organization store, which is not scoped to
-   * comments, so filter on `_type == "sanity.comment"`.
-   *
-   * @param query - GROQ-query to perform
-   * @param params - Optional query parameters
-   * @param options - Optional request options
+   * Listen for changes to the organization's Context documents. Mirrors
+   * `client.listen(query, params, options)` and emits mutation events by
+   * default.
    */
-  fetch<R = unknown>(query: string, params?: QueryParams, options?: CollaborationCommentsRequestOptions): Promise<R>;
+  listen<Opts extends ContextListenOptions | undefined = undefined>(query: string, params?: QueryParams, options?: Opts): Observable<ListenEventFromOptions<SanityDocument, Opts>>;
   /**
-   * Listen for changes to comments on the configured resource.
-   *
-   * Mirrors `client.listen(query, params)`, and emits mutation events.
+   * Conversation telemetry. `threadId` identifies the conversation within
+   * the organization — reuse means the same conversation. Beyond the canned
+   * `get`, reads go through {@link fetch} and {@link listen} with GROQ
+   * (`_type == "sanity.context.conversation"`).
    *
-   * @param query - GROQ-filter to listen to changes for
-   * @param params - Optional query parameters
+   * Requires `context.organizationId` in the client configuration.
    */
-  listen(query: string, params?: QueryParams): Observable<MutationEvent<CollaborationCommentDocument>>;
+  conversations: {
+    /**
+     * Record a conversation. Messages replace the stored transcript
+     * wholesale; `metadata` and model fields only overwrite when present.
+     * Last write per thread wins — retries are safe.
+     */
+    save: (params: {
+      threadId: string;
+    } & SaveConversationParams, options?: RequestOptions$2) => Observable<Conversation>;
+    /**
+     * Record the classification your own model produced for one thread:
+     * exactly one of `coreMetrics` (a verdict) or `classificationError`
+     * (why classification failed).
+     */
+    classify: (params: {
+      threadId: string;
+    } & ClassifyConversationParams, options?: RequestOptions$2) => Observable<Conversation>;
+    /**
+     * One recorded conversation by its thread id, or `null` when the thread
+     * was never recorded. Runs:
+     *
+     * `*[_type == "sanity.context.conversation" && organizationId == $org && threadId == $threadId][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      threadId: string;
+    }, options?: ContextRequestOptions) => Observable<ConversationDoc | null>;
+  };
   /**
-   * Listen for changes to comments on the configured resource.
-   *
-   * Mirrors `client.listen(query, params, options)`.
-   *
-   * @param query - GROQ-filter to listen to changes for
-   * @param params - Optional query parameters
-   * @param options - The same listener options `client.listen` takes, forwarded
-   *   to the organization store's listener
+   * Entries: the built outline, one entry per node. Reads are canned GROQ
+   * queries against the organization's document store; for anything more,
+   * use {@link fetch}. Requires `context.organizationId` alongside the
+   * knowledge-base `resource` in the client configuration.
    */
-  listen<Opts extends CollaborationCommentsListenOptions>(query: string, params: QueryParams | undefined, options: Opts): Observable<ListenEventFromOptions<CollaborationCommentDocument, Opts>>;
+  entries: {
+    /**
+     * Every entry, path-ordered, as a metadata view (`_id`, `path`,
+     * `title`, `tldr`, `status`) with bodies excluded. Drains keyset pages
+     * internally and emits the complete set. Runs:
+     *
+     * `*[_type == "sanity.context.entry" && knowledgeBaseId == $kb && path > $after] | order(path asc) [0...200] {_id, path, title, tldr, status}`
+     *
+     * For bodies, use `entries.get` or {@link fetch}.
+     */
+    list: (options?: ContextRequestOptions) => Observable<Entry[]>;
+    /**
+     * One entry with its full body and citations, by outline path (e.g.
+     * `billing/refunds`), or `null` when no entry sits at that path. Runs:
+     *
+     * `*[_type == "sanity.context.entry" && knowledgeBaseId == $kb && path == $path][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      path: string;
+    }, options?: ContextRequestOptions) => Observable<EntryDoc | null>;
+    /**
+     * Rebuild one entry from its already-placed sources, by outline path.
+     * Poll the returned job with the promise client's `jobs`;
+     * `affectedEntries` lists every entry the rebuild touches.
+     */
+    rebuild: (params: {
+      path: string;
+    }, options?: RequestOptions$2) => Observable<RebuildEntryResponse>;
+  };
+  /**
+   * Issues: findings from builds awaiting triage. Reads are canned GROQ
+   * queries against the organization's document store; for anything more,
+   * use {@link fetch}. Requires `context.organizationId` alongside the
+   * knowledge-base `resource` in the client configuration.
+   */
+  issues: {
+    /**
+     * Every issue on the knowledge base, oldest first, optionally narrowed
+     * to one status. Drains keyset pages internally and emits the complete
+     * set. Runs:
+     *
+     * `*[_type == "sanity.context.issue" && knowledgeBaseId == $kb && status == $status] | order(_createdAt asc, _id asc)`
+     *
+     * (the status clause only when given). For anything more, use {@link fetch}.
+     */
+    list: (params?: {
+      status?: 'open' | 'accepted' | 'rejected';
+    }, options?: ContextRequestOptions) => Observable<IssueDoc[]>;
+    /**
+     * One issue by its document id, or `null` when it does not exist. Runs:
+     *
+     * `*[_type == "sanity.context.issue" && knowledgeBaseId == $kb && _id == $id][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      issueId: string;
+    }, options?: ContextRequestOptions) => Observable<IssueDoc | null>;
+  };
+  /**
+   * Instructions: standing decisions that steer every build. The canned
+   * GROQ read; writes are promise-based on `client.context`.
+   */
+  instructions: {
+    /**
+     * Every current-schema instruction on the knowledge base, oldest first.
+     * Drains keyset pages internally and emits the complete set. Runs:
+     *
+     * `*[_type == "sanity.context.instruction" && knowledgeBaseId == $kb && schemaVersion == 1] | order(_createdAt asc, _id asc)`
+     *
+     * For anything more, use {@link fetch}. Requires `context.organizationId`
+     * alongside the knowledge-base `resource` in the client configuration.
+     */
+    list: (options?: ContextRequestOptions) => Observable<InstructionDoc[]>;
+  };
+  /**
+   * MCP endpoint configurations, org-owned documents read with canned GROQ
+   * queries. Requires `context.organizationId` in the client configuration.
+   */
+  mcpEndpoints: {
+    /**
+     * The organization's MCP endpoint configurations, oldest first. Runs:
+     *
+     * `*[_type == "sanity.context.mcp" && organizationId == $org] | order(_createdAt asc, _id asc) [0...500]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    list: (options?: ContextRequestOptions) => Observable<McpDoc[]>;
+    /**
+     * One MCP endpoint configuration by its URL name, or `null` when none
+     * carries that name. Runs:
+     *
+     * `*[_type == "sanity.context.mcp" && organizationId == $org && name == $name][0]`
+     *
+     * For anything more, use {@link fetch}.
+     */
+    get: (params: {
+      name: string;
+    }, options?: ContextRequestOptions) => Observable<McpDoc | null>;
+  };
 }
 /**
  * @public
+ * @inline
  */
 declare class LiveClient {
   #private;
@@ -2105,7 +5347,10 @@ declare class ObservableTransaction extends BaseTransaction {
    */
   patch(patch: ObservablePatch): this;
 }
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class ObservableDatasetsClient {
   #private;
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
@@ -2149,7 +5394,10 @@ declare class ObservableDatasetsClient {
    */
   editEmbeddingsSettings(name: string, settings: EmbeddingsSettingsBody): Observable<void>;
 }
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class DatasetsClient {
   #private;
   constructor(client: SanityClient, httpRequest: HttpRequest);
@@ -2289,7 +5537,10 @@ declare class FunctionsClient {
   }): Promise<R>;
   invoke<R = unknown>(functionName: string, request?: InvokeFunctionRequest, options?: InvokeFunctionOptions): Promise<R | undefined>;
 }
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class ObservableMediaLibraryVideoClient {
   #private;
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
@@ -2301,7 +5552,10 @@ declare class ObservableMediaLibraryVideoClient {
    */
   getPlaybackInfo(assetIdentifier: MediaLibraryAssetInstanceIdentifier, options?: MediaLibraryPlaybackInfoOptions): Observable<VideoPlaybackInfo>;
 }
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class MediaLibraryVideoClient {
   #private;
   constructor(client: SanityClient, httpRequest: HttpRequest);
@@ -2324,7 +5578,10 @@ type OmittedProjectFields<T extends ListOptions | undefined> = (T extends {
 } ? 'members' : never) | (T extends {
   includeFeatures: false;
 } ? 'features' : never);
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class ObservableProjectsClient {
   #private;
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
@@ -2345,7 +5602,10 @@ declare class ObservableProjectsClient {
    */
   getById(projectId: string): Observable<SanityProject>;
 }
-/** @internal */
+/**
+ * @internal
+ * @inline
+ */
 declare class ProjectsClient {
   #private;
   constructor(client: SanityClient, httpRequest: HttpRequest);
@@ -2366,7 +5626,10 @@ declare class ProjectsClient {
    */
   getById(projectId: string): Promise<SanityProject>;
 }
-/** @public */
+/**
+ * @public
+ * @inline
+ */
 declare class ObservableReleasesClient {
   #private;
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
@@ -2611,7 +5874,10 @@ declare class ObservableReleasesClient {
     releaseId: string;
   }, options?: BaseMutationOptions): Observable<RawQueryResponse<SanityDocument[]>>;
 }
-/** @public */
+/**
+ * @public
+ * @inline
+ */
 declare class ReleasesClient {
   #private;
   constructor(client: SanityClient, httpRequest: HttpRequest);
@@ -2847,7 +6113,10 @@ declare class ReleasesClient {
     releaseId: string;
   }, options?: BaseMutationOptions): Promise<RawQueryResponse<SanityDocument[]>>;
 }
-/** @public */
+/**
+ * @public
+ * @inline
+ */
 declare class ObservableUsersClient {
   #private;
   constructor(client: ObservableSanityClient, httpRequest: HttpRequest);
@@ -2858,7 +6127,10 @@ declare class ObservableUsersClient {
    */
   getById<T extends string>(id: T): Observable<T extends 'me' ? CurrentSanityUser : SanityUser>;
 }
-/** @public */
+/**
+ * @public
+ * @inline
+ */
 declare class UsersClient {
   #private;
   constructor(client: SanityClient, httpRequest: HttpRequest);
@@ -2872,15 +6144,52 @@ declare class UsersClient {
 /** @public */
 declare class ObservableSanityClient {
   #private;
+  /**
+   * Upload, fetch and delete assets (images and files) in the configured dataset
+   *
+   * @category Assets
+   */
   assets: ObservableAssetsClient;
+  /**
+   * Create, list, edit and delete datasets in the configured project
+   *
+   * @category Projects & Datasets
+   */
   datasets: ObservableDatasetsClient;
+  /**
+   * Subscribe to live content updates through the Live Content API
+   *
+   * @category Real-time
+   */
   live: LiveClient;
+  /**
+   * Interact with Media Library assets
+   *
+   * @category Assets
+   */
   mediaLibrary: {
+    /** Upload and manage Media Library video assets */
     video: ObservableMediaLibraryVideoClient;
   };
+  /**
+   * Fetch information about the projects the authenticated user has access to
+   *
+   * @category Projects & Datasets
+   */
   projects: ObservableProjectsClient;
+  /**
+   * Fetch information about users in the configured project
+   *
+   * @category Projects & Datasets
+   */
   users: ObservableUsersClient;
+  /**
+   * Run Agent Actions - AI-powered operations to generate, transform, translate, prompt and patch documents
+   *
+   * @category Agent Actions
+   */
   agent: {
+    /** Run individual Agent Action operations */
     action: ObservableAgentsActionClient;
   };
   collaboration: {
@@ -2888,18 +6197,31 @@ declare class ObservableSanityClient {
     comments: ObservableCollaborationCommentsClient;
   };
   functions: ObservableFunctionsClient;
+  /**
+   * Create and manage content releases and their scheduled publishing
+   *
+   * @category Releases
+   */
   releases: ObservableReleasesClient;
+  /** @beta */
+  context: ObservableContextClient;
   /**
-   * Instance properties
+   * Listen to document changes matching a GROQ query, delivered as server-sent events
+   *
+   * @category Real-time
    */
   listen: typeof _listen;
   constructor(httpRequest: HttpRequest, config?: ClientConfig);
   /**
    * Clone the client - returns a new instance
+   *
+   * @category Configuration
    */
   clone(): ObservableSanityClient;
   /**
    * Returns the current client configuration
+   *
+   * @category Configuration
    */
   config(): InitializedClientConfig;
   /**
@@ -2909,12 +6231,16 @@ declare class ObservableSanityClient {
   /**
    * Clone the client with a new (partial) configuration.
    *
+   * @category Configuration
+   *
    * @param newConfig - New client configuration properties, shallowly merged with existing configuration
    */
   withConfig(newConfig?: Partial<ClientConfig>): ObservableSanityClient;
   /**
    * Perform a GROQ-query against the configured dataset.
    *
+   * @category Querying
+   *
    * @param query - GROQ-query to perform
    */
   fetch<R = Any, Q extends QueryWithoutParams = QueryWithoutParams, const G extends string = string>(query: G, params?: Q | QueryWithoutParams): Observable<ClientReturn<G, R>>;
@@ -2945,6 +6271,8 @@ declare class ObservableSanityClient {
   /**
    * Fetch a single document with the given ID.
    *
+   * @category Querying
+   *
    * @param id - Document ID to fetch
    * @param options - Request options
    */
@@ -2972,6 +6300,8 @@ declare class ObservableSanityClient {
    * The order/position of documents is preserved based on the original array of IDs.
    * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
    *
+   * @category Querying
+   *
    * @param ids - Document IDs to fetch
    * @param options - Request options
    */
@@ -2982,6 +6312,8 @@ declare class ObservableSanityClient {
    * Convenient and bandwidth efficient method of checking wether a set of document IDs exists.
    * Returns a set of the IDs that exist.
    *
+   * @category Querying
+   *
    * @param ids - Document IDs to check
    * @param options - Request options
    */
@@ -2993,6 +6325,8 @@ declare class ObservableSanityClient {
    * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
    * Returns an observable that resolves to the created document.
    *
+   * @category Mutations
+   *
    * @param document - Document to create
    * @param options - Mutation options
    */
@@ -3033,6 +6367,8 @@ declare class ObservableSanityClient {
    * Create a document if no document with the same ID already exists.
    * Returns an observable that resolves to the created document.
    *
+   * @category Mutations
+   *
    * @param document - Document to create
    * @param options - Mutation options
    */
@@ -3073,6 +6409,8 @@ declare class ObservableSanityClient {
    * Create a document if it does not exist, or replace a document with the same document ID
    * Returns an observable that resolves to the created document.
    *
+   * @category Mutations
+   *
    * @param document - Document to either create or replace
    * @param options - Mutation options
    */
@@ -3197,6 +6535,8 @@ declare class ObservableSanityClient {
    * Deletes a document with the given document ID.
    * Returns an observable that resolves to the deleted document.
    *
+   * @category Mutations
+   *
    * @param id - Document ID to delete
    * @param options - Options for the mutation
    */
@@ -3282,6 +6622,8 @@ declare class ObservableSanityClient {
    * * Discarding a version with no `releaseId` will discard the draft version of the published document.
    * * If the draft or release version does not exist, any error will throw.
    *
+   * @category Versions
+   *
    * @param params - Version action parameters:
    *   - `releaseId` - The ID of the release to discard the document from.
    *   - `publishedId` - The published ID of the document to discard.
@@ -3317,6 +6659,8 @@ declare class ObservableSanityClient {
    * * Replacing a version with no `releaseId` will replace the draft version of the published document.
    * * At least one of the **version** or **published** documents must exist.
    *
+   * @category Versions
+   *
    * @param params - Version action parameters:
    *   - `document` - The new document to replace the version with.
    *   - `releaseId` - The ID of the release where the document version is replaced.
@@ -3389,6 +6733,8 @@ declare class ObservableSanityClient {
    * @remarks
    * * If the published document does not exist, an error will be thrown.
    *
+   * @category Versions
+   *
    * @param params - Version action parameters:
    *   - `releaseId` - The ID of the release to unpublish the document from.
    *   - `publishedId` - The published ID of the document to unpublish.
@@ -3409,6 +6755,8 @@ declare class ObservableSanityClient {
    * Perform mutation operations against the configured dataset
    * Returns an observable that resolves to the first mutated document.
    *
+   * @category Mutations
+   *
    * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
@@ -3448,6 +6796,8 @@ declare class ObservableSanityClient {
   /**
    * Create a new buildable patch of operations to perform
    *
+   * @category Mutations
+   *
    * @param documentId - Document ID to patch
    * @param operations - Optional object of patch operations to initialize the patch instance with
    * @returns Patch instance - call `.commit()` to perform the operations defined
@@ -3472,12 +6822,16 @@ declare class ObservableSanityClient {
   /**
    * Create a new transaction of mutations
    *
+   * @category Mutations
+   *
    * @param operations - Optional array of mutation operations to initialize the transaction instance with
    */
   transaction<R extends Record<string, Any> = Record<string, Any>>(operations?: Mutation<R>[]): ObservableTransaction;
   /**
    * Perform action operations against the configured dataset
    *
+   * @category Mutations
+   *
    * @param operations - Action operation(s) to execute
    * @param options - Action options
    */
@@ -3485,12 +6839,16 @@ declare class ObservableSanityClient {
   /**
    * Perform an HTTP request against the Sanity API
    *
+   * @category HTTP
+   *
    * @param options - Request options
    */
   request<R = Any>(options: RawRequestOptions): Observable<R>;
   /**
    * Get a Sanity API URL for the URI provided
    *
+   * @category HTTP
+   *
    * @param uri - URI/path to build URL for
    * @param canUseCdn - Whether or not to allow using the API CDN for this route
    */
@@ -3498,6 +6856,8 @@ declare class ObservableSanityClient {
   /**
    * Get a Sanity API URL for the data operation and path provided
    *
+   * @category HTTP
+   *
    * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
    * @param path - Path to append after the operation
    */
@@ -3506,15 +6866,52 @@ declare class ObservableSanityClient {
 /** @public */
 declare class SanityClient {
   #private;
+  /**
+   * Upload, fetch and delete assets (images and files) in the configured dataset
+   *
+   * @category Assets
+   */
   assets: AssetsClient;
+  /**
+   * Create, list, edit and delete datasets in the configured project
+   *
+   * @category Projects & Datasets
+   */
   datasets: DatasetsClient;
+  /**
+   * Subscribe to live content updates through the Live Content API
+   *
+   * @category Real-time
+   */
   live: LiveClient;
+  /**
+   * Interact with Media Library assets
+   *
+   * @category Assets
+   */
   mediaLibrary: {
+    /** Upload and manage Media Library video assets */
     video: MediaLibraryVideoClient;
   };
+  /**
+   * Fetch information about the projects the authenticated user has access to
+   *
+   * @category Projects & Datasets
+   */
   projects: ProjectsClient;
+  /**
+   * Fetch information about users in the configured project
+   *
+   * @category Projects & Datasets
+   */
   users: UsersClient;
+  /**
+   * Run Agent Actions - AI-powered operations to generate, transform, translate, prompt and patch documents
+   *
+   * @category Agent Actions
+   */
   agent: {
+    /** Run individual Agent Action operations */
     action: AgentActionsClient;
   };
   collaboration: {
@@ -3522,22 +6919,37 @@ declare class SanityClient {
     comments: CollaborationCommentsClient;
   };
   functions: FunctionsClient;
+  /**
+   * Create and manage content releases and their scheduled publishing
+   *
+   * @category Releases
+   */
   releases: ReleasesClient;
+  /** @beta */
+  context: ContextClient;
   /**
    * Observable version of the Sanity client, with the same configuration as the promise-based one
+   *
+   * @category Configuration
    */
   observable: ObservableSanityClient;
   /**
-   * Instance properties
+   * Listen to document changes matching a GROQ query, delivered as server-sent events
+   *
+   * @category Real-time
    */
   listen: typeof _listen;
   constructor(httpRequest: HttpRequest, config?: ClientConfig);
   /**
    * Clone the client - returns a new instance
+   *
+   * @category Configuration
    */
   clone(): SanityClient;
   /**
    * Returns the current client configuration
+   *
+   * @category Configuration
    */
   config(): InitializedClientConfig;
   /**
@@ -3547,12 +6959,16 @@ declare class SanityClient {
   /**
    * Clone the client with a new (partial) configuration.
    *
+   * @category Configuration
+   *
    * @param newConfig - New client configuration properties, shallowly merged with existing configuration
    */
   withConfig(newConfig?: Partial<ClientConfig>): SanityClient;
   /**
    * Perform a GROQ-query against the configured dataset.
    *
+   * @category Querying
+   *
    * @param query - GROQ-query to perform
    */
   fetch<R = Any, Q extends QueryWithoutParams = QueryWithoutParams, const G extends string = string>(query: G, params?: Q | QueryWithoutParams): Promise<ClientReturn<G, R>>;
@@ -3583,6 +6999,8 @@ declare class SanityClient {
   /**
    * Fetch a single document with the given ID.
    *
+   * @category Querying
+   *
    * @param id - Document ID to fetch
    * @param options - Request options
    */
@@ -3610,6 +7028,8 @@ declare class SanityClient {
    * The order/position of documents is preserved based on the original array of IDs.
    * If any of the documents are missing, they will be replaced by a `null` entry in the returned array
    *
+   * @category Querying
+   *
    * @param ids - Document IDs to fetch
    * @param options - Request options
    */
@@ -3621,6 +7041,8 @@ declare class SanityClient {
    * Convenient and bandwidth efficient method of checking wether a set of document IDs exists.
    * Returns a set of the IDs that exist.
    *
+   * @category Querying
+   *
    * @param ids - Document IDs to check
    * @param options - Request options
    */
@@ -3632,6 +7054,8 @@ declare class SanityClient {
    * Create a document. Requires a `_type` property. If no `_id` is provided, it will be generated by the database.
    * Returns a promise that resolves to the created document.
    *
+   * @category Mutations
+   *
    * @param document - Document to create
    * @param options - Mutation options
    */
@@ -3672,6 +7096,8 @@ declare class SanityClient {
    * Create a document if no document with the same ID already exists.
    * Returns a promise that resolves to the created document.
    *
+   * @category Mutations
+   *
    * @param document - Document to create
    * @param options - Mutation options
    */
@@ -3712,6 +7138,8 @@ declare class SanityClient {
    * Create a document if it does not exist, or replace a document with the same document ID
    * Returns a promise that resolves to the created document.
    *
+   * @category Mutations
+   *
    * @param document - Document to either create or replace
    * @param options - Mutation options
    */
@@ -3824,6 +7252,8 @@ declare class SanityClient {
    * Deletes a document with the given document ID.
    * Returns a promise that resolves to the deleted document.
    *
+   * @category Mutations
+   *
    * @param id - Document ID to delete
    * @param options - Options for the mutation
    */
@@ -3909,6 +7339,8 @@ declare class SanityClient {
    * * Discarding a version with no `releaseId` will discard the draft version of the published document.
    * * If the draft or release version does not exist, any error will throw.
    *
+   * @category Versions
+   *
    * @param params - Version action parameters:
    *   - `releaseId` - The ID of the release to discard the document from.
    *   - `publishedId` - The published ID of the document to discard.
@@ -3944,6 +7376,8 @@ declare class SanityClient {
    * * Replacing a version with no `releaseId` will replace the draft version of the published document.
    * * At least one of the **version** or **published** documents must exist.
    *
+   * @category Versions
+   *
    * @param params - Version action parameters:
    *   - `document` - The new document to replace the version with.
    *   - `releaseId` - The ID of the release where the document version is replaced.
@@ -4016,6 +7450,8 @@ declare class SanityClient {
    * @remarks
    * * If the published document does not exist, an error will be thrown.
    *
+   * @category Versions
+   *
    * @param params - Version action parameters:
    *   - `releaseId` - The ID of the release to unpublish the document from.
    *   - `publishedId` - The published ID of the document to unpublish.
@@ -4036,6 +7472,8 @@ declare class SanityClient {
    * Perform mutation operations against the configured dataset
    * Returns a promise that resolves to the first mutated document.
    *
+   * @category Mutations
+   *
    * @param operations - Mutation operations to execute
    * @param options - Mutation options
    */
@@ -4075,6 +7513,8 @@ declare class SanityClient {
   /**
    * Create a new buildable patch of operations to perform
    *
+   * @category Mutations
+   *
    * @param documentId - Document ID to patch
    * @param operations - Optional object of patch operations to initialize the patch instance with
    * @returns Patch instance - call `.commit()` to perform the operations defined
@@ -4099,6 +7539,8 @@ declare class SanityClient {
   /**
    * Create a new transaction of mutations
    *
+   * @category Mutations
+   *
    * @param operations - Optional array of mutation operations to initialize the transaction instance with
    */
   transaction<R extends Record<string, Any> = Record<string, Any>>(operations?: Mutation<R>[]): Transaction;
@@ -4106,6 +7548,8 @@ declare class SanityClient {
    * Perform action operations against the configured dataset
    * Returns a promise that resolves to the transaction result
    *
+   * @category Mutations
+   *
    * @param operations - Action operation(s) to execute
    * @param options - Action options
    */
@@ -4114,6 +7558,8 @@ declare class SanityClient {
    * Perform a request against the Sanity API
    * NOTE: Only use this for Sanity API endpoints, not for your own APIs!
    *
+   * @category HTTP
+   *
    * @param options - Request options
    * @returns Promise resolving to the response body
    */
@@ -4132,6 +7578,8 @@ declare class SanityClient {
   /**
    * Get a Sanity API URL for the URI provided
    *
+   * @category HTTP
+   *
    * @param uri - URI/path to build URL for
    * @param canUseCdn - Whether or not to allow using the API CDN for this route
    */
@@ -4139,6 +7587,8 @@ declare class SanityClient {
   /**
    * Get a Sanity API URL for the data operation and path provided
    *
+   * @category HTTP
+   *
    * @param operation - Data operation (eg `query`, `mutate`, `listen` or similar)
    * @param path - Path to append after the operation
    */
@@ -4472,6 +7922,9 @@ type ClientVariant = ClientVariantConditions | string;
 type ClientConfigResource = {
   type: 'canvas';
   id: string;
+} | {
+  type: 'knowledge-base';
+  id: string;
 } | {
   type: 'media-library';
   id: string;
@@ -4659,6 +8112,16 @@ interface ClientConfig {
   collaboration?: {
     organizationId?: string;
   };
+  /**
+   * Organization-scoped configuration for Context APIs.
+   *
+   * Currently this is used by `context.insights` methods.
+   *
+   * @beta
+   */
+  context?: {
+    organizationId?: string;
+  };
 }
 /** @public */
 interface InitializedClientConfig extends ClientConfig {
@@ -4924,6 +8387,7 @@ type DatasetAclMode = 'public' | 'private' | 'custom';
 /** @public */
 type DatasetCreateOptions = {
   aclMode?: DatasetAclMode;
+  description?: string | null;
   embeddings?: {
     enabled: boolean;
     projection?: string;
@@ -4932,6 +8396,7 @@ type DatasetCreateOptions = {
 /** @public */
 type DatasetEditOptions = {
   aclMode?: DatasetAclMode;
+  description?: string | null;
 };
 /** @public */
 type EmbeddingsSettings = {
@@ -4948,17 +8413,22 @@ type EmbeddingsSettingsBody = {
 type DatasetResponse = {
   datasetName: string;
   aclMode: DatasetAclMode;
+  description: string | null;
 };
 /** @public */
 type DatasetsResponse = {
   name: string;
   aclMode: DatasetAclMode;
+  description?: string;
   createdAt: string;
   createdByUserId: string;
   addonFor: string | null;
   datasetProfile: string;
   features: string[];
-  tags: string[];
+  tags: {
+    name: string;
+    title: string;
+  }[];
 }[];
 /** @public */
 interface SanityProjectMember {
@@ -6325,8 +9795,46 @@ interface LiveEventGoAway {
 }
 /** @public */
 type LiveEvent = LiveEventRestart | LiveEventReconnect | LiveEventMessage | LiveEventWelcome | LiveEventGoAway;
-/** @public */
-interface SanityQueries {}
+declare global {
+  /**
+   * Query result types, keyed by GROQ query string. Empty by default, `sanity typegen` registers
+   * the queries it finds:
+   * ```ts
+   * declare global {
+   *   interface SanityQueries {
+   *     '*[_type == "post"]': PostsQueryResult
+   *   }
+   * }
+   * ```
+   * `client.fetch(query)` and `ClientReturn<typeof query>` then resolve to the registered type.
+   *
+   * The registry is a global rather than a module augmentation of `@sanity/client` so that it
+   * does not depend on module resolution: it resolves the same whether `@sanity/client` is a
+   * direct dependency, how many copies of it are installed, and from every subpath export.
+   */
+  interface SanityQueries {}
+}
+/**
+ * The query registry as seen from `@sanity/client`. Inherits every query registered on the global
+ * `SanityQueries` interface, and still accepts the older module augmentation form:
+ * ```ts
+ * declare module '@sanity/client' {
+ *   interface SanityQueries {
+ *     '*[_type == "post"]': PostsQueryResult
+ *   }
+ * }
+ * ```
+ * `@sanity/client` releases that predate the global registry only read this interface, so a
+ * generated file that registers queries globally can bridge them with an augmentation that adds
+ * the global as a base type. It is harmless on releases that already inherit it:
+ * ```ts
+ * declare module '@sanity/client' {
+ *   interface SanityQueries extends globalThis.SanityQueries {}
+ * }
+ * ```
+ * @public
+ */
+interface SanityQueries extends globalThis.SanityQueries {}
 /** @public */
 type ClientReturn<GroqString extends string, Fallback = Any> = GroqString extends keyof SanityQueries ? SanityQueries[GroqString] : Fallback;
 /**
@@ -6722,5 +10230,5 @@ declare const createClient: (config: ClientConfig) => SanityClient;
  * @deprecated Use the named export `createClient` instead of the `default` export
  */
 declare const deprecatedCreateClient: (config: ClientConfig) => SanityClient;
-export { Action, ActionError, ActionErrorItem, type AgentActionParam, type AgentActionParams, type AgentActionPath, type AgentActionPathSegment, type AgentActionTarget, AllDocumentIdsMutationOptions, AllDocumentsMutationOptions, AnimatedImageFormat, AnimatedTransformOptions, Any, ApiError, ArchiveReleaseAction, AssetMetadataType, type AssetsClient, AttributeSet, AuthProvider, AuthProviderResponse, BaseActionOptions, BaseMutationOptions, BasePatch, BaseTransaction, ChannelError, ChannelErrorEvent, ClientConfig, ClientError, ClientPerspective, ClientReturn, ClientVariant, ClientVariantConditions, type CollaborationCommentCreate, type CollaborationCommentDocument, type CollaborationCommentFieldValue, type CollaborationCommentMessage, type CollaborationCommentPortableTextBlock, type CollaborationCommentRange, type CollaborationCommentReactionShortName, type CollaborationCommentSelection, type CollaborationCommentStatus, type CollaborationCommentTarget, type CollaborationCommentUpdate, type CollaborationCommentsClient, type CollaborationCommentsListenOptions, type CollaborationCommentsRequestOptions, type CollaborationCommentsWriteOptions, ConnectionFailedError, type ConstantAgentActionParam, ContentSourceMap, ContentSourceMapDocument, ContentSourceMapDocumentBase, ContentSourceMapDocumentValueSource, ContentSourceMapDocuments, ContentSourceMapLiteralSource, ContentSourceMapMapping, ContentSourceMapMappings, type ContentSourceMapParsedPath, type ContentSourceMapParsedPathKeyedSegment, ContentSourceMapPaths, ContentSourceMapRemoteDocument, ContentSourceMapSource, ContentSourceMapUnknownSource, ContentSourceMapValueMapping, CorsOriginError, CreateAction, CreateReleaseAction, CreateVariantAction, CreateVariantDefinitionAction, CreateVersionAction, CurrentSanityUser, DatasetAclMode, DatasetCreateOptions, DatasetEditOptions, DatasetResponse, type DatasetsClient, DatasetsResponse, DeleteAction, DeleteReleaseAction, DeleteVariantAction, DeleteVariantDefinitionAction, DiscardAction, DiscardVersionAction, DisconnectError, DisconnectEvent, type DocumentAgentActionParam, EXPERIMENTAL_API_WARNING, EditAction, EditReleaseAction, EditVariantAction, EditVariantDefinitionAction, EditableReleaseDocument, EmbeddingsSettings, EmbeddingsSettingsBody, ErrorProps, type EventSourceEvent, type EventSourceInstance, type FieldAgentActionParam, type FilterDefault, FilteredResponseQueryOptions, FirstDocumentIdMutationOptions, FirstDocumentMutationOptions, FitMode, type GenerateInstruction, type GenerateOperation, type GenerateTarget, type GenerateTargetDocument, type GenerateTargetInclude, type GroqAgentActionParam, type HttpError, HttpRequest, IdentifiedSanityDocumentStub, type ImageDescriptionOperation, ImportReleaseAction, InitializedClientConfig, type InitializedStegaConfig, InsertPatch, type InvokeFunctionEvent, type InvokeFunctionOptions, type InvokeFunctionRequest, ListenEvent, ListenEventName, ListenOptions, ListenParams, type LiveClient, LiveEvent, LiveEventGoAway, LiveEventMessage, LiveEventReconnect, LiveEventRestart, LiveEventWelcome, type Logger, MediaLibraryAssetDocument, MediaLibraryAssetInstanceIdentifier, MediaLibraryAssetVersion, MediaLibraryPlaybackInfoOptions, type MediaLibraryVideoClient, MediaLibraryVideoPlaybackTransformations, MessageError, MessageParseError, MultipleActionResult, MultipleMutationResult, Mutation, MutationError, MutationErrorItem, MutationEvent, MutationOperation, MutationSelection, MutationSelectionQueryParams, type ObservableAssetsClient, type ObservableCollaborationCommentsClient, type ObservableDatasetsClient, type ObservableMediaLibraryVideoClient, ObservablePatch, ObservablePatchBuilder, type ObservableProjectsClient, ObservableSanityClient, ObservableTransaction, type ObservableUsersClient, OpenEvent, PartialExcept, Patch, PatchBuilder, type PatchDocument, PatchMutationOperation, type PatchOperation, PatchOperations, PatchSelection, type PatchTarget, type ProjectsClient, type PromptRequest, PublishAction, PublishReleaseAction, PublishVariantAction, QueryOptions, QueryParams, QueryParseError, QueryWithoutParams, RawQueryResponse, RawQuerylessQueryResponse, RawRequestOptions, ReconnectEvent, ReleaseAction, ReleaseCardinality, ReleaseDocument, ReleaseId, ReleaseState, ReleaseType, ReplaceDraftAction, ReplaceVersionAction, RequestHandler, RequestHandlerOptions, RequestObservableOptions, RequestOptions, RequestUrlOptions, Requester, ResetEvent, type ResolveStudioUrl, ResponseQueryOptions, ResumableListenEventNames, ResumableListenOptions, SanityAssetDocument, SanityClient, SanityDocument, SanityDocumentStub, SanityImageAssetDocument, SanityImagePalette, SanityProject, SanityProjectMember, SanityQueries, SanityReference, SanityUser, ScheduleReleaseAction, ServerError, type ServerSentEvent, SingleActionResult, SingleMutationResult, StackablePerspective, type StegaConfig, type StegaConfigRequiredKeys, StillImageFormat, StoryboardTransformOptions, type StudioBaseRoute, type StudioBaseUrl, type StudioUrl, SyncTag, ThumbnailTransformOptions, type TimeoutErrorLike, Transaction, TransactionAllDocumentIdsMutationOptions, TransactionAllDocumentsMutationOptions, TransactionFirstDocumentIdMutationOptions, TransactionFirstDocumentMutationOptions, TransactionMutationOptions, type TransformDocument, type TransformOperation, type TransformTarget, type TransformTargetDocument, type TransformTargetInclude, type TranslateDocument, type TranslateTarget, type TranslateTargetInclude, UnarchiveReleaseAction, UnfilteredResponseQueryOptions, UnfilteredResponseWithoutQuery, UnpublishAction, UnpublishVariantAction, UnpublishVersionAction, UnscheduleReleaseAction, UploadBody, UploadClientConfig, UploadEvent, UploadProgressEvent, UploadResponseEvent, type UsersClient, VariantAction, VariantDefinitionAction, VersionAction, VideoPlaybackInfo, VideoPlaybackInfoItem, VideoPlaybackInfoItemPublic, VideoPlaybackInfoItemSigned, VideoPlaybackInfoPublic, VideoPlaybackInfoSigned, VideoPlaybackTokens, VideoRenditionInfo, VideoRenditionInfoPublic, VideoRenditionInfoSigned, VideoSubtitleInfo, VideoSubtitleInfoPublic, VideoSubtitleInfoSigned, WelcomeBackEvent, WelcomeEvent, type _listen, connectEventSource, createClient, deprecatedCreateClient as default, formatQueryParseError, isHttpError, isQueryParseError, isTimeoutError, requester, validateApiPerspective };
+export { Action, ActionError, ActionErrorItem, type AgentActionParam, type AgentActionParams, type AgentActionPath, type AgentActionPathSegment, type AgentActionTarget, AllDocumentIdsMutationOptions, AllDocumentsMutationOptions, AnimatedImageFormat, AnimatedTransformOptions, Any, ApiError, ArchiveReleaseAction, AssetMetadataType, type AssetsClient, AttributeSet, AuthProvider, AuthProviderResponse, BaseActionOptions, BaseMutationOptions, BasePatch, BaseTransaction, ChannelError, ChannelErrorEvent, ClientConfig, ClientError, ClientPerspective, ClientReturn, ClientVariant, ClientVariantConditions, type CollaborationCommentCreate, type CollaborationCommentDocument, type CollaborationCommentFieldValue, type CollaborationCommentMessage, type CollaborationCommentPortableTextBlock, type CollaborationCommentRange, type CollaborationCommentReactionShortName, type CollaborationCommentSelection, type CollaborationCommentStatus, type CollaborationCommentTarget, type CollaborationCommentUpdate, type CollaborationCommentsClient, type CollaborationCommentsListenOptions, type CollaborationCommentsRequestOptions, type CollaborationCommentsWriteOptions, ConnectionFailedError, type ConstantAgentActionParam, ContentSourceMap, ContentSourceMapDocument, ContentSourceMapDocumentBase, ContentSourceMapDocumentValueSource, ContentSourceMapDocuments, ContentSourceMapLiteralSource, ContentSourceMapMapping, ContentSourceMapMappings, type ContentSourceMapParsedPath, type ContentSourceMapParsedPathKeyedSegment, ContentSourceMapPaths, ContentSourceMapRemoteDocument, ContentSourceMapSource, ContentSourceMapUnknownSource, ContentSourceMapValueMapping, types_d_exports as Context, CorsOriginError, CreateAction, CreateReleaseAction, CreateVariantAction, CreateVariantDefinitionAction, CreateVersionAction, CurrentSanityUser, DatasetAclMode, DatasetCreateOptions, DatasetEditOptions, DatasetResponse, type DatasetsClient, DatasetsResponse, DeleteAction, DeleteReleaseAction, DeleteVariantAction, DeleteVariantDefinitionAction, DiscardAction, DiscardVersionAction, DisconnectError, DisconnectEvent, type DocumentAgentActionParam, EXPERIMENTAL_API_WARNING, EditAction, EditReleaseAction, EditVariantAction, EditVariantDefinitionAction, EditableReleaseDocument, EmbeddingsSettings, EmbeddingsSettingsBody, ErrorProps, type EventSourceEvent, type EventSourceInstance, type FieldAgentActionParam, type FilterDefault, FilteredResponseQueryOptions, FirstDocumentIdMutationOptions, FirstDocumentMutationOptions, FitMode, type GenerateInstruction, type GenerateOperation, type GenerateTarget, type GenerateTargetDocument, type GenerateTargetInclude, type GroqAgentActionParam, type HttpError, HttpRequest, IdentifiedSanityDocumentStub, type ImageDescriptionOperation, ImportReleaseAction, InitializedClientConfig, type InitializedStegaConfig, InsertPatch, type InvokeFunctionEvent, type InvokeFunctionOptions, type InvokeFunctionRequest, ListenEvent, ListenEventName, ListenOptions, ListenParams, type LiveClient, LiveEvent, LiveEventGoAway, LiveEventMessage, LiveEventReconnect, LiveEventRestart, LiveEventWelcome, type Logger, MediaLibraryAssetDocument, MediaLibraryAssetInstanceIdentifier, MediaLibraryAssetVersion, MediaLibraryPlaybackInfoOptions, type MediaLibraryVideoClient, MediaLibraryVideoPlaybackTransformations, MessageError, MessageParseError, MultipleActionResult, MultipleMutationResult, Mutation, MutationError, MutationErrorItem, MutationEvent, MutationOperation, MutationSelection, MutationSelectionQueryParams, type ObservableAssetsClient, type ObservableCollaborationCommentsClient, type ObservableDatasetsClient, type ObservableMediaLibraryVideoClient, ObservablePatch, ObservablePatchBuilder, type ObservableProjectsClient, ObservableSanityClient, ObservableTransaction, type ObservableUsersClient, OpenEvent, PartialExcept, Patch, PatchBuilder, type PatchDocument, PatchMutationOperation, type PatchOperation, PatchOperations, PatchSelection, type PatchTarget, type ProjectsClient, type PromptRequest, PublishAction, PublishReleaseAction, PublishVariantAction, QueryOptions, QueryParams, QueryParseError, QueryWithoutParams, RawQueryResponse, RawQuerylessQueryResponse, RawRequestOptions, ReconnectEvent, ReleaseAction, ReleaseCardinality, ReleaseDocument, ReleaseId, ReleaseState, ReleaseType, ReplaceDraftAction, ReplaceVersionAction, RequestHandler, RequestHandlerOptions, RequestObservableOptions, RequestOptions, RequestUrlOptions, Requester, ResetEvent, type ResolveStudioUrl, ResponseQueryOptions, ResumableListenEventNames, ResumableListenOptions, SanityAssetDocument, SanityClient, SanityDocument, SanityDocumentStub, SanityImageAssetDocument, SanityImagePalette, SanityProject, SanityProjectMember, SanityQueries, SanityReference, SanityUser, ScheduleReleaseAction, ServerError, type ServerSentEvent, SingleActionResult, SingleMutationResult, StackablePerspective, type StegaConfig, type StegaConfigRequiredKeys, StillImageFormat, StoryboardTransformOptions, type StudioBaseRoute, type StudioBaseUrl, type StudioUrl, SyncTag, ThumbnailTransformOptions, type TimeoutErrorLike, Transaction, TransactionAllDocumentIdsMutationOptions, TransactionAllDocumentsMutationOptions, TransactionFirstDocumentIdMutationOptions, TransactionFirstDocumentMutationOptions, TransactionMutationOptions, type TransformDocument, type TransformOperation, type TransformTarget, type TransformTargetDocument, type TransformTargetInclude, type TranslateDocument, type TranslateTarget, type TranslateTargetInclude, UnarchiveReleaseAction, UnfilteredResponseQueryOptions, UnfilteredResponseWithoutQuery, UnpublishAction, UnpublishVariantAction, UnpublishVersionAction, UnscheduleReleaseAction, UploadBody, UploadClientConfig, UploadEvent, UploadProgressEvent, UploadResponseEvent, type UsersClient, VariantAction, VariantDefinitionAction, VersionAction, VideoPlaybackInfo, VideoPlaybackInfoItem, VideoPlaybackInfoItemPublic, VideoPlaybackInfoItemSigned, VideoPlaybackInfoPublic, VideoPlaybackInfoSigned, VideoPlaybackTokens, VideoRenditionInfo, VideoRenditionInfoPublic, VideoRenditionInfoSigned, VideoSubtitleInfo, VideoSubtitleInfoPublic, VideoSubtitleInfoSigned, WelcomeBackEvent, WelcomeEvent, type _listen, connectEventSource, createClient, deprecatedCreateClient as default, formatQueryParseError, isHttpError, isQueryParseError, isTimeoutError, requester, validateApiPerspective };
 //# sourceMappingURL=index.node.d.ts.map