@sanity/client 6.29.0-generate.0 → 6.29.0-generate.2

package/dist/index.browser.d.cts

@@ -1,3 +1,10 @@
+import type {AgentActionAsync} from '@sanity/client/agent/actions/commonTypes'
+import type {AgentActionPath as AgentActionPath_2} from '@sanity/client/agent/actions/commonTypes'
+import type {AgentActionPathSegment as AgentActionPathSegment_2} from '@sanity/client/agent/actions/commonTypes'
+import type {AgentActionRequestBase} from '@sanity/client/agent/actions/commonTypes'
+import type {AgentActionSync} from '@sanity/client/agent/actions/commonTypes'
+import type {AgentActionTarget as AgentActionTarget_2} from '@sanity/client/agent/actions/commonTypes'
+import type {AgentActionTargetInclude} from '@sanity/client/agent/actions/commonTypes'
 import type {ContentSourceMapDocuments as ContentSourceMapDocuments_2} from '@sanity/client/csm'
 import {ContentSourceMapParsedPath} from '@sanity/client/csm'
 import {ContentSourceMapParsedPathKeyedSegment} from '@sanity/client/csm'
@@ -39,6 +46,27 @@ export declare interface ActionErrorItem {
   index: number
 }
 
+/** @beta */
+export declare type AgentActionParam =
+  | string
+  | ConstantAgentActionParam
+  | FieldAgentActionParam
+  | DocumentAgentActionParam
+  | GroqAgentActionParam
+
+/** @beta */
+export declare type AgentActionParams = Record<string, AgentActionParam>
+
+/**  @beta */
+export declare type AgentActionPath = AgentActionPathSegment[]
+
+/**  @beta */
+export declare type AgentActionPathSegment =
+  | string
+  | {
+      _key: string
+    }
+
 /** @public */
 declare class AgentActionsClient {
   #private
@@ -49,8 +77,82 @@ declare class AgentActionsClient {
   generate<DocumentShape extends Record<string, Any>>(
     request: GenerateSyncInstruction<DocumentShape>,
   ): Promise<IdentifiedSanityDocumentStub & DocumentShape>
+  transform(request: TransformDocumentAsync): Promise<{
+    _id: string
+  }>
+  transform<DocumentShape extends Record<string, Any>>(
+    request: TransformDocumentSync,
+  ): Promise<IdentifiedSanityDocumentStub & DocumentShape>
+  translate(request: TranslateDocumentAsync): Promise<{
+    _id: string
+  }>
+  translate<DocumentShape extends Record<string, Any>>(
+    request: TranslateDocumentSync,
+  ): Promise<IdentifiedSanityDocumentStub & DocumentShape>
 }
 
+/**
+ * @beta
+ */
+export declare interface AgentActionTarget {
+  /**
+   * Root target path.
+   *
+   * Use this to have the instruction only affect a part of the document.
+   *
+   * To further control the behavior of individual paths under the root, use `include`, `exclude`, `types.include`
+   * and `types.exclude`.
+   *
+   * Example:
+   *
+   * `path: ['body', {_key: 'someKey'}, 'nestedObject']`
+   *
+   * Here, the instruction will only write to fields under the nestedObject.
+   *
+   * Default: [] = the document itself
+   *
+   * @see #AgentActionPathSegment
+   * @see #AgentActionPath
+   * */
+  path?: AgentActionPathSegment | AgentActionPath
+  /**
+   * maxPathDepth controls how deep into the schema from the target root the instruction will affect.
+   *
+   * Depth is based on path segments:
+   * - `title` has depth 1
+   * - `array[_key="no"].title` has depth 3
+   *
+   * Be careful not to set this too high in studios with recursive document schemas, as it could have
+   * negative impact on performance; both for runtime and quality of responses.
+   *
+   * Default: 4
+   */
+  maxPathDepth?: number
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   * Fields or array items not on the exclude list, are implicitly included.
+   */
+  exclude?: AgentActionPathSegment[]
+  /**
+   * Types can be used to exclude array item types or all fields directly under the target path of a certain type.
+   * If you do exclude: ['string'] all string fields under the target will be excluded, for instance.
+   *
+   * `types.include` and `types.exclude` are mutually exclusive.
+   */
+  types?: AgentActionTypeConfig
+}
+
+/**  @beta */
+declare type AgentActionTypeConfig =
+  | {
+      include: string[]
+      exclude?: never
+    }
+  | {
+      exclude: string[]
+      include?: never
+    }
+
 /** @internal */
 export declare type AllDocumentIdsMutationOptions = BaseMutationOptions & {
   returnFirst: false
@@ -69,12 +171,6 @@ export declare type AllDocumentsMutationOptions = BaseMutationOptions & {
  */
 export declare type Any = any
 
-/**
- * Used to tag types that is set to `any` as a temporary measure, but should be replaced with proper typings in the future
- * @internal
- */
-declare type Any_2 = any
-
 /** @internal */
 export declare interface ApiError {
   error: string
@@ -134,18 +230,6 @@ export declare class AssetsClient {
   ): Promise<SanityAssetDocument | SanityImageAssetDocument>
 }
 
-declare interface Async {
-  /**
-   * When async: true, requests responds with status 201 and {_id} as response body as soon as the request is validated.
-   * The instruction operation will carry on in the background.
-   *
-   * When async: false (default), requests respond with status 200 and the document value after instruction has been applied.
-   *
-   * async: true is incompatible with noWrite, as async: true does not return the resulting document
-   */
-  async: true
-}
-
 /** @internal */
 export declare type AttributeSet = {
   [key: string]: Any
@@ -505,6 +589,12 @@ export declare class ConnectionFailedError extends Error {
   readonly name = 'ConnectionFailedError'
 }
 
+/** @beta */
+export declare interface ConstantAgentActionParam {
+  type: 'constant'
+  value: string
+}
+
 /** @public */
 export declare interface ContentSourceMap {
   mappings: ContentSourceMapMappings
@@ -624,19 +714,6 @@ export declare type CreateAction = {
 /** @public */
 export declare const createClient: (config: ClientConfig) => SanityClient
 
-/**
- * Instruction to create a new document
- * @beta
- */
-declare interface CreateDocumentRequest<T extends Record<string, Any_2> = Record<string, Any_2>> {
-  createDocument: {
-    /** if no _id is provided, one will be generated. _id is always returned when the requests succeed */
-    _id?: string
-    _type: string
-  } & SanityDocumentStub_2<T>
-  documentId?: never
-}
-
 /** @public */
 export declare interface CurrentSanityUser {
   id: string
@@ -788,6 +865,19 @@ export declare type DisconnectEvent = {
   reason: string
 }
 
+/**
+ *
+ * Includes a LLM-friendly version of the document in the instruction
+ * @beta
+ * */
+export declare interface DocumentAgentActionParam {
+  type: 'document'
+  /**
+   * If omitted, implicitly uses the documentId of the instruction target
+   */
+  documentId?: string
+}
+
 /**
  * Modifies an existing draft document.
  * It applies the given patch to the document referenced by draftId.
@@ -831,12 +921,20 @@ export declare type EventSourceEvent<Name extends string> = ServerSentEvent<Name
 export declare type EventSourceInstance = InstanceType<typeof globalThis.EventSource>
 
 /**
- * Instruction for an existing document.
+ *
+ * Includes a LLM-friendly version of the field value in the instruction
  * @beta
- */
-declare interface ExistingDocumentRequest {
-  documentId: string
-  createDocument?: never
+ * */
+export declare interface FieldAgentActionParam {
+  type: 'field'
+  /**
+   * Examples: ['title'], ['array', {_key: 'arrayItemKey'}, 'field']
+   */
+  path: AgentActionPath
+  /**
+   * If omitted, implicitly uses the documentId of the instruction target
+   */
+  documentId?: string
 }
 
 /** @public */
@@ -906,89 +1004,53 @@ export declare type FirstDocumentMutationOptions = BaseMutationOptions & {
 }
 
 /** @beta */
-export declare type GenerateAsyncInstruction<
-  T extends Record<string, Any_2> = Record<string, Any_2>,
-> = (ExistingDocumentRequest | CreateDocumentRequest<T>) & GenerateRequestBase & Async
-
-/** @beta */
-export declare interface GenerateConstantInstructionParam {
-  type: 'constant'
-  value: string
-}
-
-/**
- *
- * Includes a LLM-friendly version of the document in the instruction
- * @beta
- * */
-declare interface GenerateDocumentInstructionParam {
-  type: 'document'
-  /**
-   * If omitted, implicitly uses the documentId of the instruction target
-   */
-  documentId?: string
-}
+declare type GenerateAsyncInstruction<T extends Record<string, Any> = Record<string, Any>> = (
+  | GenerateExistingDocumentRequest
+  | GenerateCreateDocumentRequest<T>
+) &
+  GenerateRequestBase &
+  AgentActionAsync
 
 /**
- *
- * Includes a LLM-friendly version of the field value in the instruction
+ * Instruction to create a new document
  * @beta
- * */
-export declare interface GenerateFieldInstructionParam {
-  type: 'field'
-  /**
-   * Examples: ['title'], ['array', {_key: 'arrayItemKey'}, 'field']
-   */
-  path: GeneratePath
-  /**
-   * If omitted, implicitly uses the documentId of the instruction target
-   */
-  documentId?: string
+ */
+declare interface GenerateCreateDocumentRequest<
+  T extends Record<string, Any> = Record<string, Any>,
+> {
+  createDocument: {
+    /** if no _id is provided, one will be generated. _id is always returned when the requests succeed */
+    _id?: string
+    _type: string
+  } & SanityDocumentStub<T>
+  documentId?: never
 }
 
 /**
- * Includes a LLM-friendly version of GROQ query result in the instruction
+ * Instruction for an existing document.
  * @beta
- * */
-export declare interface GenerateGroqInstructionParam {
-  type: 'groq'
-  query: string
-  params?: Record<string, string>
+ */
+declare interface GenerateExistingDocumentRequest {
+  documentId: string
+  createDocument?: never
 }
 
 /** @beta */
-export declare type GenerateInstruction<T extends Record<string, Any_2> = Record<string, Any_2>> =
+export declare type GenerateInstruction<T extends Record<string, Any> = Record<string, Any>> =
   | GenerateSyncInstruction<T>
   | GenerateAsyncInstruction<T>
 
-/** @beta */
-export declare type GenerateInstructionParam =
-  | string
-  | GenerateConstantInstructionParam
-  | GenerateFieldInstructionParam
-  | GenerateDocumentInstructionParam
-  | GenerateGroqInstructionParam
+/**  @beta */
+export declare type GenerateOperation = 'set' | 'append' | 'mixed'
 
-/** @beta */
-export declare type GenerateInstructionParams = Record<string, GenerateInstructionParam>
-
-declare type GenerateOperation = 'set' | 'append' | 'mixed'
-
-declare type GeneratePath = GeneratePathSegment[]
-
-declare type GeneratePathSegment =
-  | string
-  | {
-      _key: string
-    }
-
-declare interface GenerateRequestBase {
+/**  @beta */
+declare interface GenerateRequestBase extends AgentActionRequestBase {
   /** schemaId as reported by sanity deploy / sanity schema store */
   schemaId: string
-  /** string template using $variable – more on this below under "Dynamic instruction" */
+  /** string template using $variable  */
   instruction: string
   /** param values for the string template, keys are the variable name, ie if the template has "$variable", one key must be "variable" */
-  instructionParams?: GenerateInstructionParams
+  instructionParams?: AgentActionParams
   /**
    * Target defines which parts of the document will be affected by the instruction.
    * It can be an array, so multiple parts of the document can be separately configured in detail.
@@ -1000,106 +1062,21 @@ declare interface GenerateRequestBase {
    * - when multiple targets are provided, they will be coalesced into a single target sharing a common target root.
    * It is therefor an error to provide conflicting include/exclude across targets (ie, include title in one, and exclude it in another)
    *
-   * @see GenerateRequestBase#conditionalPaths
+   * @see AgentActionRequestBase#conditionalPaths
    */
   target?: GenerateTarget | GenerateTarget[]
-  /**
-   * When a type or field in the schema has a function set for `hidden` or `readOnly`, it is conditional.
-   *
-   * By default, Generate will not output to conditional `readOnly` and `hidden` fields,
-   * ie, they are considered to resolve to `readOnly: true` / `hidden: true`.
-   *
-   * `conditionalPaths` param allows setting the default conditional value for
-   * `hidden` and `readOnly` to false,
-   * or individually set `hidden` and `readOnly` state for individual document paths.
-   *
-   *
-   * Note: fields and types with explicit readOnly: true or hidden: true in the schema, are not available to Generate,
-   * and cannot be changed via conditionalPaths
-   *
-   * conditionalPaths state only apply to fields and types that have conditional `hidden` or `readOnly` in their schema definition.
-   *
-   * Consider using `hidden: () => true` in schema config, if a field should be writeable only by Generate and never
-   * visible in the studio – then make the field visible to the Generate using `conditionalPaths`.
-   *
-   * @see GenerateRequestBase#target
-   */
-  conditionalPaths?: {
-    defaultReadOnly?: boolean
-    defaultHidden?: boolean
-    paths?: {
-      /** path here is not a relative path: it must be the full document path, regardless of `path` param used in targets */
-      path: GeneratePath
-      readOnly: boolean
-      hidden: boolean
-    }[]
-  }
-  /**
-   * When localeSettings is provided on the request, instruct can write to date and datetime fields.
-   * Otherwise, such fields will be ignored.
-   */
-  localeSettings?: {
-    /**
-     * A valid Unicode BCP 47 locale identifier used to interpret and format
-     * natural language inputs and date output. Examples include "en-US", "fr-FR", or "ja-JP".
-     *
-     * This affects how phrases like "next Friday" or "in two weeks" are parsed,
-     * and how resulting dates are presented (e.g., 12-hour vs 24-hour format).
-     *
-     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#getcanonicalocales
-     */
-    locale: string
-    /**
-     * A valid IANA time zone identifier used to resolve relative and absolute
-     * date expressions to a specific point in time. Examples include
-     * "America/New_York", "Europe/Paris", or "Asia/Tokyo".
-     *
-     * This ensures phrases like "tomorrow at 9am" are interpreted correctly
-     * based on the user's local time.
-     *
-     * @see https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
-     */
-    timeZone: string
-  }
-  /**
-   * Controls how much variance the instructions will run with.
-   *
-   * Value must be in the range [0, 1] (inclusive).
-   *
-   * Default: 0.3
-   */
-  temperature?: number
 }
 
 /** @beta */
-export declare type GenerateSyncInstruction<
-  T extends Record<string, Any_2> = Record<string, Any_2>,
-> = (ExistingDocumentRequest | CreateDocumentRequest<T>) & GenerateRequestBase & Sync
+declare type GenerateSyncInstruction<T extends Record<string, Any> = Record<string, Any>> = (
+  | GenerateExistingDocumentRequest
+  | GenerateCreateDocumentRequest<T>
+) &
+  GenerateRequestBase &
+  AgentActionSync
 
-/**
- * @beta
- */
-declare interface GenerateTarget {
-  /**
-   * Root target path.
-   *
-   * Use this to have the instruction only affect a part of the document.
-   *
-   * To further control the behavior of individual paths under the root, use `include`, `exclude`, `types.include`
-   * and `types.exclude`.
-   *
-   * Example:
-   *
-   * `path: ['body', {_key: 'someKey'}, 'nestedObject']`
-   *
-   * Here, the instruction will only write to fields under the nestedObject.
-   *
-   * Default: [] = the document itself
-   *
-   * @see #GeneratePathSegment
-   * @see #GeneratePath
-   * */
-  path?: GeneratePathSegment | GeneratePath
+/**  @beta */
+export declare interface GenerateTarget extends AgentActionTarget_2 {
   /**
    * Sets the default operation for all paths in the target.
    * Generate runs in `'mixed'` operation mode by default:
@@ -1128,24 +1105,11 @@ declare interface GenerateTarget {
    * To insert in the middle of the array, use `target: {path: ['array', {_key: 'appendAfterKey'}], operation: 'append'}`.
    * Here, the output of the instruction will be appended after the array item with key `'appendAfterKey'`.
    *
-   * @see #GenerateTargetInclude.operation
+   * @see #AgentActionTargetInclude.operation
    * @see #include
-   * @see #GenerateTargetInclude.include
+   * @see #AgentActionTargetInclude.include
    */
   operation?: GenerateOperation
-  /**
-   * maxPathDepth controls how deep into the schema from the target root the instruction will affect.
-   *
-   * Depth is based on path segments:
-   * - `title` has depth 1
-   * - `array[_key="no"].title` has depth 3
-   *
-   * Be careful not to set this too high in studios with recursive document schemas, as it could have
-   * negative impact on performance; both for runtime and quality of responses.
-   *
-   * Default: 4
-   */
-  maxPathDepth?: number
   /**
    * By default, all children up to `target.maxPathDepth` are included.
    *
@@ -1153,23 +1117,11 @@ declare interface GenerateTarget {
    *
    * Fields or array items not on the include list, are implicitly excluded.
    */
-  include?: (GeneratePathSegment | GenerateTargetInclude)[]
-  /**
-   * By default, all children up to `target.maxPathDepth` are included.
-   * Fields or array items not on the exclude list, are implicitly included.
-   */
-  exclude?: GeneratePathSegment[]
-  /**
-   * Types can be used to exclude array item types or all fields directly under the target path of a certain type.
-   * If you do exclude: ['string'] all string fields under the target will be excluded, for instance.
-   *
-   * `types.include` and `types.exclude` are mutually exclusive.
-   */
-  types?: GenerateTypeConfig
+  include?: (AgentActionPathSegment_2 | GenerateTargetInclude)[]
 }
 
-declare interface GenerateTargetInclude {
-  path: GeneratePathSegment | GeneratePath
+/**  @beta */
+export declare interface GenerateTargetInclude extends AgentActionTargetInclude {
   /**
    * Sets the operation for this path, and all its children.
    * This overrides any operation set parents or the root target.
@@ -1184,30 +1136,18 @@ declare interface GenerateTargetInclude {
    *
    * Fields or array items not on the include list, are implicitly excluded.
    */
-  include?: (GeneratePathSegment | GenerateTargetInclude)[]
-  /**
-   * By default, all children up to `target.maxPathDepth` are included.
-   * Fields or array items not on the exclude list, are implicitly included.
-   */
-  exclude?: GeneratePathSegment[]
-  /**
-   * Types can be used to exclude array item types or all fields directly under the target path of a certain type.
-   * If you do exclude: ['string'] all string fields under the target will be excluded, for instance.
-   *
-   * `types.include` and `types.exclude` are mutually exclusive.
-   */
-  types?: GenerateTypeConfig
+  include?: (AgentActionPathSegment_2 | GenerateTargetInclude)[]
 }
 
-declare type GenerateTypeConfig =
-  | {
-      include: string[]
-      exclude?: never
-    }
-  | {
-      exclude: string[]
-      include?: never
-    }
+/**
+ * Includes a LLM-friendly version of GROQ query result in the instruction
+ * @beta
+ * */
+export declare interface GroqAgentActionParam {
+  type: 'groq'
+  query: string
+  params?: Record<string, string>
+}
 
 /** @public */
 export declare type HttpRequest = {
@@ -1651,6 +1591,18 @@ declare class ObservableAgentsActionClient {
   generate<DocumentShape extends Record<string, Any>>(
     request: GenerateSyncInstruction<DocumentShape>,
   ): Observable<IdentifiedSanityDocumentStub & DocumentShape>
+  transform(request: TransformDocumentAsync): Observable<{
+    _id: string
+  }>
+  transform<DocumentShape extends Record<string, Any>>(
+    request: TransformDocumentSync,
+  ): Observable<IdentifiedSanityDocumentStub & DocumentShape>
+  translate(request: TranslateDocumentAsync): Observable<{
+    _id: string
+  }>
+  translate<DocumentShape extends Record<string, Any>>(
+    request: TranslateDocumentSync,
+  ): Observable<IdentifiedSanityDocumentStub & DocumentShape>
 }
 
 /** @internal */
@@ -3293,13 +3245,6 @@ export declare type SanityDocumentStub<T extends Record<string, Any> = Record<st
   _type: string
 }
 
-/** @public */
-declare type SanityDocumentStub_2<T extends Record<string, Any_2> = Record<string, Any_2>> = {
-  [P in keyof T]: T[P]
-} & {
-  _type: string
-}
-
 /** @internal */
 export declare interface SanityImageAssetDocument extends SanityAssetDocument {
   metadata: {
@@ -3476,29 +3421,6 @@ export {StudioBaseUrl}
 
 export {StudioUrl}
 
-declare interface Sync {
-  /**
-   * By default, noWrite: false.
-   * Write enabled operations will mutate the target document, and emit AI presence in the studio.
-   *
-   * When noWrite: true, the api will not mutate any documents nor emit presence.
-   * Ie, when true, no changes will be made to content-lake
-   *
-   * noWrite: true is incompatible with async: true,
-   * as noWrite implies that you will use the return value of the operation
-   */
-  noWrite?: boolean
-  /**
-   * When async: true, requests responds with status 201 and {_id} as response body as soon as the request is validated.
-   * The instruction operation will carry on in the background.
-   *
-   * When async: false (default), requests respond with status 200 and the document value after instruction has been applied.
-   *
-   * async: true is incompatible with noWrite: true, as async: true does not return the resulting document
-   */
-  async?: false
-}
-
 /** @public */
 export declare type SyncTag = `s1:${string}`
 
@@ -3599,6 +3521,161 @@ export declare type TransactionMutationOptions =
   | TransactionAllDocumentsMutationOptions
   | TransactionAllDocumentIdsMutationOptions
 
+/** @beta */
+export declare type TransformDocument = TransformDocumentSync | TransformDocumentAsync
+
+/** @beta */
+declare type TransformDocumentAsync = TransformRequestBase & AgentActionAsync
+
+/** @beta */
+declare type TransformDocumentSync = TransformRequestBase & AgentActionSync
+
+/**  @beta */
+declare interface TransformRequestBase extends AgentActionRequestBase {
+  /** schemaId as reported by sanity deploy / sanity schema store */
+  schemaId: string
+  documentId: string
+  targetDocument?: TransformTargetDocument
+  /** string template using $variable  */
+  transformation: string
+  /** param values for the string template, keys are the variable name, ie if the template has "$variable", one key must be "variable" */
+  transformationParams?: AgentActionParams
+  /**
+   * Target defines which parts of the document will be affected by the instruction.
+   * It can be an array, so multiple parts of the document can be separately configured in detail.
+   *
+   * Omitting target implies that the document itself is the root.
+   *
+   * Notes:
+   * - instruction can only affect fields up to `maxPathDepth`
+   * - when multiple targets are provided, they will be coalesced into a single target sharing a common target root.
+   * It is therefor an error to provide conflicting include/exclude across targets (ie, include title in one, and exclude it in another)
+   *
+   * @see AgentActionRequestBase#conditionalPaths
+   */
+  target?: TransformTarget | TransformTarget[]
+}
+
+/**  @beta */
+export declare interface TransformTarget extends AgentActionTarget_2 {
+  /** string template using $variable from instructionParams  */
+  transformation?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment_2 | TransformTargetInclude)[]
+}
+
+/**  @beta */
+export declare type TransformTargetDocument =
+  | {
+      operation: 'get'
+      _id: string
+    }
+  | {
+      operation: 'create'
+      _id?: string
+    }
+  | {
+      operation: 'createIfNotExists'
+      _id: string
+    }
+  | {
+      operation: 'createOrReplace'
+      _id: string
+    }
+
+/**  @beta */
+export declare interface TransformTargetInclude extends AgentActionTargetInclude {
+  /** string template using $variable from instructionParams  */
+  transformation?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment_2 | TransformTargetInclude)[]
+}
+
+/** @beta */
+export declare type TranslateDocument = TranslateDocumentSync | TranslateDocumentAsync
+
+/** @beta */
+declare type TranslateDocumentAsync = TranslateRequestBase & AgentActionAsync
+
+/** @beta */
+declare type TranslateDocumentSync = TranslateRequestBase & AgentActionSync
+
+/**  @beta */
+declare interface TranslateLanguage {
+  id: string
+  title?: string
+}
+
+/**  @beta */
+declare interface TranslateRequestBase extends AgentActionRequestBase {
+  /** schemaId as reported by sanity deploy / sanity schema store */
+  schemaId: string
+  documentId: string
+  targetDocument?: TransformTargetDocument
+  fromLanguage?: TranslateLanguage
+  toLanguage: TranslateLanguage
+  /** string template using $variable  */
+  styleGuide?: string
+  /** param values for the string template, keys are the variable name, ie if the template has "$variable", one key must be "variable" */
+  styleGuideParams?: AgentActionParams
+  /**
+   * Target defines which parts of the document will be affected by the instruction.
+   * It can be an array, so multiple parts of the document can be separately configured in detail.
+   *
+   * Omitting target implies that the document itself is the root.
+   *
+   * Notes:
+   * - instruction can only affect fields up to `maxPathDepth`
+   * - when multiple targets are provided, they will be coalesced into a single target sharing a common target root.
+   * It is therefor an error to provide conflicting include/exclude across targets (ie, include title in one, and exclude it in another)
+   *
+   * @see AgentActionRequestBase#conditionalPaths
+   */
+  target?: TranslateTarget | TranslateTarget[]
+  languageFieldPath?: AgentActionPathSegment | AgentActionPath_2
+  protectedPhrases?: string[]
+}
+
+/**  @beta */
+export declare interface TranslateTarget extends AgentActionTarget {
+  /** string template using $variable from instructionParams  */
+  styleGuide?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment | TranslateTargetInclude)[]
+}
+
+/**  @beta */
+export declare interface TranslateTargetInclude extends AgentActionTargetInclude {
+  /** string template using $variable from instructionParams  */
+  styleGuide?: string
+  /**
+   * By default, all children up to `target.maxPathDepth` are included.
+   *
+   * When `include` is specified, only segments explicitly listed will be included.
+   *
+   * Fields or array items not on the include list, are implicitly excluded.
+   */
+  include?: (AgentActionPathSegment | TranslateTargetInclude)[]
+}
+
 /** @public */
 export declare interface UnfilteredResponseQueryOptions extends ResponseQueryOptions {
   filterResponse: false