@sanity/media-library-types 1.2.0 → 1.4.0

package/lib/index.d.cts

@@ -1,11 +1,11 @@
-import {Asset as Asset_3} from '@sanity/media-library-types'
-import {AssetInstanceDocument as AssetInstanceDocument_2} from '@sanity/media-library-types'
-import {ClientPerspective} from '@sanity/client'
-import {ComponentType} from 'react'
-import {ElementType} from 'react'
-import {ReactNode} from 'react'
-import {SanityClient} from '@sanity/client'
-import {StackablePerspective} from '@sanity/client'
+import { Asset as Asset_3 } from "@sanity/media-library-types";
+import { AssetInstanceDocument as AssetInstanceDocument_2 } from "@sanity/media-library-types";
+import { ClientPerspective } from "@sanity/client";
+import { ComponentType } from "react";
+import { ElementType } from "react";
+import { ReactNode } from "react";
+import { SanityClient } from "@sanity/client";
+import { StackablePerspective } from "@sanity/client";
 
 /**
  * Types of array actions that can be performed
@@ -15,198 +15,272 @@ declare type ArrayActionName =
   /**
    * Add any item to the array at any position
    */
-  | 'add'
+  | "add"
   /**
    * Add item after an existing item
    */
-  | 'addBefore'
+  | "addBefore"
   /**
    * Add item after an existing item
    */
-  | 'addAfter'
+  | "addAfter"
   /**
    * Remove any item
    */
-  | 'remove'
+  | "remove"
   /**
    * Duplicate item
    */
-  | 'duplicate'
+  | "duplicate"
   /**
    * Copy item
    */
-  | 'copy'
+  | "copy";
 
 /** @public */
 declare interface ArrayDefinition extends BaseSchemaDefinition {
-  type: 'array'
-  of: ArrayOfType[]
-  initialValue?: InitialValueProperty<any, unknown[]>
-  validation?: ValidationBuilder<ArrayRule<unknown[]>, unknown[]>
-  options?: ArrayOptions
+  type: "array";
+  of: ArrayOfType[];
+  initialValue?: InitialValueProperty<any, unknown[]>;
+  validation?: ValidationBuilder<ArrayRule<unknown[]>, unknown[]>;
+  options?: ArrayOptions;
 }
 
 /** @public */
-declare type ArrayOfEntry<T> = Omit<T, 'name' | 'hidden'> & {
-  name?: string
-}
+declare type ArrayOfEntry<T> = Omit<T, "name" | "hidden"> & {
+  name?: string;
+};
 
 /** @public */
 declare type ArrayOfType<
   TType extends IntrinsicTypeName = IntrinsicTypeName,
   TAlias extends IntrinsicTypeName | undefined = undefined,
-> = IntrinsicArrayOfDefinition[TType] | ArrayOfEntry<TypeAliasDefinition<string, TAlias>>
+> =
+  | IntrinsicArrayOfDefinition[TType]
+  | ArrayOfEntry<TypeAliasDefinition<AutocompleteString, TAlias>>;
 
 /** @public */
-declare interface ArrayOptions<V = unknown> extends SearchConfiguration, BaseSchemaTypeOptions {
-  list?: TitledListValue<V>[] | V[]
-  layout?: 'list' | 'tags' | 'grid'
+declare interface ArrayOptions<V = unknown>
+  extends SearchConfiguration, BaseSchemaTypeOptions {
+  list?: TitledListValue<V>[] | V[];
+  layout?: "list" | "tags" | "grid";
   /** @deprecated This option does not have any effect anymore */
-  direction?: 'horizontal' | 'vertical'
-  sortable?: boolean
+  direction?: "horizontal" | "vertical";
+  sortable?: boolean;
   modal?: {
-    type?: 'dialog' | 'popover'
-    width?: number | 'auto'
-  }
+    type?: "dialog" | "popover";
+    width?: number | "auto";
+  };
   /** @alpha This API may change */
-  insertMenu?: InsertMenuOptions
+  insertMenu?: InsertMenuOptions;
   /**
    * A boolean flag to enable or disable tree editing for the array.
    * If there are any nested arrays, they will inherit this value.
    * @deprecated tree editing beta feature has been disabled
    */
-  treeEditing?: boolean
+  treeEditing?: boolean;
   /**
    * A list of array actions to disable
    * Possible options are defined by {@link ArrayActionName}
    * @beta
    */
-  disableActions?: ArrayActionName[]
+  disableActions?: ArrayActionName[];
 }
 
 /** @public */
 declare interface ArrayRule<Value> extends RuleDef<ArrayRule<Value>, Value> {
-  min: (length: number | FieldReference) => ArrayRule<Value>
-  max: (length: number | FieldReference) => ArrayRule<Value>
-  length: (length: number | FieldReference) => ArrayRule<Value>
-  unique: () => ArrayRule<Value>
+  min: (length: number | FieldReference) => ArrayRule<Value>;
+  max: (length: number | FieldReference) => ArrayRule<Value>;
+  length: (length: number | FieldReference) => ArrayRule<Value>;
+  unique: () => ArrayRule<Value>;
 }
 
 /** @public */
 declare interface ArraySchemaType<V = unknown> extends BaseSchemaType {
-  jsonType: 'array'
-  of: (Exclude<SchemaType, ArraySchemaType> | ReferenceSchemaType)[]
+  jsonType: "array";
+  of: (Exclude<SchemaType, ArraySchemaType> | ReferenceSchemaType)[];
   options?: ArrayOptions<V> & {
-    layout?: V extends string ? 'tag' : 'grid'
-  }
+    layout?: V extends string ? "tag" : "grid";
+  };
 }
 
 export declare interface Asset<
   AssetInstance extends AssetInstanceDocument = AssetInstanceDocument,
 > {
-  _id: string
-  _type: SanityAsset['_type']
-  title: string
-  assetType: AssetInstance['_type']
-  cdnAccessPolicy: SanityAsset['cdnAccessPolicy']
+  _id: string;
+  _originalId?: string;
+  _type: SanityAsset["_type"];
+  title: string;
+  assetType: AssetInstance["_type"];
+  cdnAccessPolicy: SanityAsset["cdnAccessPolicy"];
   currentVersion: {
-    _ref: string
-  }
-  aspects?: unknown
-  versions: AssetVersion<AssetInstance>[]
-  collections: SanityAssetCollection[]
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  url?: string
+    _ref: string;
+  };
+  aspects?: unknown;
+  versions: AssetVersion<AssetInstance>[];
+  collections: SanityAssetCollection[];
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  url?: string;
 }
 
 /** @public */
 declare interface Asset_2 extends SanityDocument {
-  url: string
-  path: string
-  assetId: string
-  extension: string
-  mimeType: string
-  sha1hash: string
-  size: number
-  originalFilename?: string
-  label?: string
-  title?: string
-  description?: string
-  creditLine?: string
-  source?: AssetSourceSpec
+  url: string;
+  path: string;
+  assetId: string;
+  extension: string;
+  mimeType: string;
+  sha1hash: string;
+  size: number;
+  originalFilename?: string;
+  label?: string;
+  title?: string;
+  description?: string;
+  creditLine?: string;
+  source?: AssetSourceSpec;
 }
 
 export declare interface AssetAspectDocument extends BaseDocument {
-  _type: 'sanity.asset.aspect'
+  _type: "sanity.asset.aspect";
   /**
    * The asset type this aspect definition applies to
    * Undefined means that it applies to all asset types
    */
-  assetType?: Asset['assetType']
-  definition: FieldDefinition
-  public?: boolean
+  assetType?: Asset["assetType"];
+  definition: FieldDefinition;
+  public?: boolean;
 }
 
 /** @public */
 declare type AssetFromSource = {
-  kind: 'assetDocumentId' | 'file' | 'base64' | 'url'
-  value: string | File_2
-  assetDocumentProps?: ImageAsset
+  kind: "assetDocumentId" | "file" | "base64" | "url";
+  value: string | File_2;
+  assetDocumentProps?: ImageAsset;
   mediaLibraryProps?: {
-    mediaLibraryId: string
-    assetId: string
-    assetInstanceId: string
-  }
-}
+    mediaLibraryId: string;
+    assetId: string;
+    assetInstanceId: string;
+  };
+};
 
-export declare type AssetInstanceDocument = SanityImageAsset | SanityVideoAsset | SanityFileAsset
+export declare type AssetInstanceDocument =
+  | SanityImageAsset
+  | SanityVideoAsset
+  | SanityFileAsset;
 
 export declare interface AssetSelectionItem {
-  asset: Asset
-  assetInstanceId?: string | null
+  asset: Asset;
+  assetInstanceId?: string | null;
 }
 
 declare interface AssetSelectionItemWithLegacySupport extends AssetSelectionItem {
-  assetId: string
-  assetType: string
-  assetInstanceId: string
+  assetId: string;
+  assetType: string;
+  assetInstanceId: string;
 }
 
 /** @public */
 declare interface AssetSource {
-  name: string
+  name: string;
   /** @deprecated provide `i18nKey` instead */
-  title?: string
-  i18nKey?: string
-  component: ComponentType<AssetSourceComponentProps>
-  icon?: ComponentType<EmptyProps>
+  title?: string;
+  i18nKey?: string;
+  component: ComponentType<AssetSourceComponentProps>;
+  icon?: ComponentType;
   /** @beta */
-  Uploader?: AssetSourceUploaderClass
+  Uploader?: AssetSourceUploaderClass;
+  /**
+   * Specifies how uploads should be initiated for this source.
+   *
+   * - `'picker'` (default): The studio opens a native file picker first,
+   *   then passes the selected files to the source via the `uploader` prop.
+   *   Progress is tracked via the uploader and shown in the studio UI.
+   *
+   * - `'component'`: The studio renders the source component directly with
+   *   `action: 'upload'`. The source provides its own UI for selecting and
+   *   uploading files, and tracks progress internally. When complete, the
+   *   source calls `onSelect` with the uploaded assets.
+   *
+   * @beta
+   */
+  uploadMode?: "picker" | "component";
+  /**
+   * Resolve how to open an asset in its original source.
+   *
+   * This function is called for each AssetSource when determining if
+   * "Open in Source" should be available. The plugin should check
+   * `asset.source.name` to determine if it can handle this asset.
+   *
+   * Return values:
+   * - `{ type: 'url', url: string }` - Open the URL (in new window by default)
+   * - `{ type: 'component' }` - Render the asset source component with action='openInSource'
+   * - `false` or `undefined` - This plugin cannot handle this asset
+   *
+   * @beta
+   */
+  openInSource?: (asset: Asset_2) => AssetSourceOpenInSourceResult;
 }
 
+/** @public */
+declare type AssetSourceComponentAction = "select" | "upload" | "openInSource";
+
 /** @public */
 declare interface AssetSourceComponentProps {
-  action?: 'select' | 'upload'
-  assetSource: AssetSource
-  assetType?: 'file' | 'image' | 'sanity.video'
-  accept: string
-  selectionType: 'single'
-  dialogHeaderTitle?: React.ReactNode
-  selectedAssets: Asset_2[]
-  onClose: () => void
-  onSelect: (assetFromSource: AssetFromSource[]) => void
-  schemaType?: ImageSchemaType | FileSchemaType
-  /** @beta */
-  uploader?: AssetSourceUploader
+  action?: AssetSourceComponentAction;
+  assetSource: AssetSource;
+  assetType?: "file" | "image" | "sanity.video";
+  accept: string;
+  selectionType: "single";
+  dialogHeaderTitle?: React.ReactNode;
+  selectedAssets: Asset_2[];
+  onClose: () => void;
+  onSelect: (assetFromSource: AssetFromSource[]) => void;
+  onChangeAction?: (action: AssetSourceComponentAction) => void;
+  schemaType?: ImageSchemaType | FileSchemaType;
+  /**
+   * The uploader instance for tracking upload progress.
+   *
+   * When `action` is `'upload'`:
+   * - If `uploader` is provided: Picker mode. Files are available via
+   *   `uploader.getFiles()`. The source should upload these files and report
+   *   progress via the uploader.
+   * - If `uploader` is undefined: Component mode. The source should show its
+   *   own file selection UI, handle uploads internally, and call `onSelect`
+   *   when complete.
+   *
+   * @beta
+   */
+  uploader?: AssetSourceUploader;
+  /**
+   * The asset to open in source. Only provided when action is 'openInSource'.
+   * @beta
+   */
+  assetToOpen?: Asset_2;
 }
 
+/**
+ * The result of calling `AssetSource.openInSource`.
+ * @beta
+ */
+declare type AssetSourceOpenInSourceResult =
+  | {
+      type: "url";
+      url: string;
+      target?: "_blank" | "_self";
+    }
+  | {
+      type: "component";
+    }
+  | false
+  | undefined;
+
 /** @public */
 declare interface AssetSourceSpec {
-  id: string
-  name: string
-  url?: string
+  id: string;
+  name: string;
+  url?: string;
 }
 
 /** @beta */
@@ -218,45 +292,47 @@ declare interface AssetSourceUploader {
        * The schema type of the field the asset is being uploaded to.
        * May be of interest to the uploader to read file and image options.
        */
-      schemaType?: SchemaType
+      schemaType?: SchemaType;
       /**
        * The uploader may send patches directly to the field
        * Typed 'unknown' as we don't have patch definitions in sanity/types yet.
        */
-      onChange?: (patch: unknown) => void
+      onChange?: (patch: unknown) => void;
     },
-  ): AssetSourceUploadFile[]
+  ): AssetSourceUploadFile[];
   /**
    * Abort the upload of a file
    */
-  abort(file?: AssetSourceUploadFile): void
+  abort(file?: AssetSourceUploadFile): void;
   /**
    * Get the files that are currently being uploaded
    */
-  getFiles(): AssetSourceUploadFile[]
+  getFiles(): AssetSourceUploadFile[];
   /**
    * Subscribe to upload events from the uploader
    */
-  subscribe(subscriber: (event: AssetSourceUploadEvent) => void): () => void
+  subscribe(subscriber: (event: AssetSourceUploadEvent) => void): () => void;
   /**
    * Update the status of a file. Will be emitted to subscribers.
    */
   updateFile(
     fileId: string,
     data: {
-      progress?: number
-      status?: string
-      error?: Error
+      progress?: number;
+      status?: string;
+      error?: Error;
     },
-  ): void
+  ): void;
   /**
    * Reset the uploader (clear files). Should be called by the uploader when all files are done.
    */
-  reset(): void
+  reset(): void;
 }
 
 /** @beta */
-declare type AssetSourceUploaderClass = new (...args: any[]) => AssetSourceUploader
+declare type AssetSourceUploaderClass = new (
+  ...args: any[]
+) => AssetSourceUploader;
 
 /** @beta */
 declare type AssetSourceUploadEvent =
@@ -264,128 +340,148 @@ declare type AssetSourceUploadEvent =
   | AssetSourceUploadEventStatus
   | AssetSourceUploadEventAllComplete
   | AssetSourceUploadEventError
-  | AssetSourceUploadEventAbort
+  | AssetSourceUploadEventAbort;
 
 /**
  * Emitted when all files are done, either successfully, aborted or with errors
  * @beta */
 declare type AssetSourceUploadEventAbort = {
-  type: 'abort'
+  type: "abort";
   /**
    * Files aborted
    */
-  files: AssetSourceUploadFile[]
-}
+  files: AssetSourceUploadFile[];
+};
 
 /**
  * Emitted when all files are done, either successfully, aborted or with errors
  * @beta */
 declare type AssetSourceUploadEventAllComplete = {
-  type: 'all-complete'
-  files: AssetSourceUploadFile[]
-}
+  type: "all-complete";
+  files: AssetSourceUploadFile[];
+};
 
 /**
  * Emitted when all files are done, either successfully, aborted or with errors
  * @beta */
 declare type AssetSourceUploadEventError = {
-  type: 'error'
+  type: "error";
   /**
    * Files errored
    */
-  files: AssetSourceUploadFile[]
-}
+  files: AssetSourceUploadFile[];
+};
 
 /**
  * Emitted when a file upload is progressing
  * @beta */
 declare type AssetSourceUploadEventProgress = {
-  type: 'progress'
-  file: AssetSourceUploadFile
-  progress: number
-}
+  type: "progress";
+  file: AssetSourceUploadFile;
+  progress: number;
+};
 
 /**
  * Emitted when a file upload is changing status
  * @beta */
 declare type AssetSourceUploadEventStatus = {
-  type: 'status'
-  file: AssetSourceUploadFile
-  status: AssetSourceUploadFile['status']
-}
+  type: "status";
+  file: AssetSourceUploadFile;
+  status: AssetSourceUploadFile["status"];
+};
 
 /** @beta */
 declare interface AssetSourceUploadFile {
-  id: string
-  file: globalThis.File
-  progress: number
-  status: 'pending' | 'uploading' | 'complete' | 'error' | 'aborted' | 'alreadyExists'
-  error?: Error
-  result?: unknown
+  id: string;
+  file: globalThis.File;
+  progress: number;
+  status:
+    | "pending"
+    | "uploading"
+    | "complete"
+    | "error"
+    | "aborted"
+    | "alreadyExists";
+  error?: Error;
+  result?: unknown;
 }
 
 export declare interface AssetVersion<
   AssetInstance extends AssetInstanceDocument = AssetInstanceDocument,
 > {
-  _key: string
-  _type: SanityAssetVersion['_type']
-  title?: string
-  instance: AssetInstance
+  _key: string;
+  _type: SanityAssetVersion["_type"];
+  title?: string;
+  instance: AssetInstance;
 }
 
+/**
+ * Enhances VSCode autocomplete by using a distinct type for strings.
+ *
+ * `AllowOtherStrings` is defined as `string & {}`, an intersection that behaves
+ * like `string` but is treated differently by TypeScript's type system for
+ * internal processing. This helps in improving the specificity and relevance of
+ * autocomplete suggestions by potentially prioritizing `IntrinsicTypeName`
+ * over general string inputs, addressing issues where `string` type suggestions
+ * might overshadow more useful specific literals.
+ *
+ * @beta
+ */
+declare type AutocompleteString = string & {};
+
 export declare type BaseDocument = {
-  _id: string
-  _type: string
-  _rev: string
-  _createdAt: string
-  _updatedAt: string
-  [key: string]: any
-}
+  _id: string;
+  _type: string;
+  _rev: string;
+  _createdAt: string;
+  _updatedAt: string;
+  [key: string]: any;
+};
 
 /** @public */
 declare interface BaseSchemaDefinition {
-  name: string
-  title?: string
-  description?: string | React.JSX.Element
-  hidden?: ConditionalProperty
-  readOnly?: ConditionalProperty
-  icon?: ComponentType | ReactNode
-  validation?: unknown
-  initialValue?: unknown
-  deprecated?: DeprecatedProperty
+  name: string;
+  title?: string;
+  description?: string | React.JSX.Element;
+  hidden?: ConditionalProperty;
+  readOnly?: ConditionalProperty;
+  icon?: ComponentType | ReactNode;
+  validation?: unknown;
+  initialValue?: unknown;
+  deprecated?: DeprecatedProperty;
 }
 
 /** @public */
 declare interface BaseSchemaType extends Partial<DeprecationConfiguration> {
-  name: string
-  title?: string
-  description?: string
-  type?: SchemaType
-  liveEdit?: boolean
-  readOnly?: ConditionalProperty
-  hidden?: ConditionalProperty
-  icon?: ComponentType
-  initialValue?: InitialValueProperty<any, any>
-  validation?: SchemaValidationValue
-  preview?: PreviewConfig
+  name: string;
+  title?: string;
+  description?: string;
+  type?: SchemaType;
+  liveEdit?: boolean;
+  readOnly?: ConditionalProperty;
+  hidden?: ConditionalProperty;
+  icon?: ComponentType;
+  initialValue?: InitialValueProperty<any, any>;
+  validation?: SchemaValidationValue;
+  preview?: PreviewConfig;
   /** @beta */
   components?: {
-    block?: ComponentType<any>
-    inlineBlock?: ComponentType<any>
-    annotation?: ComponentType<any>
-    diff?: ComponentType<any>
-    field?: ComponentType<any>
-    input?: ComponentType<any>
-    item?: ComponentType<any>
-    preview?: ComponentType<any>
+    block?: ComponentType<any>;
+    inlineBlock?: ComponentType<any>;
+    annotation?: ComponentType<any>;
+    diff?: ComponentType<any>;
+    field?: ComponentType<any>;
+    input?: ComponentType<any>;
+    item?: ComponentType<any>;
+    preview?: ComponentType<any>;
     portableText?: {
-      plugins?: ComponentType<any>
-    }
-  }
+      plugins?: ComponentType<any>;
+    };
+  };
   /**
    * @deprecated This will be removed.
    */
-  placeholder?: string
+  placeholder?: string;
 }
 
 /**
@@ -396,8 +492,8 @@ declare interface BaseSchemaType extends Partial<DeprecationConfiguration> {
  *  @public
  *  */
 declare interface BaseSchemaTypeOptions {
-  sanityCreate?: SanityCreateOptions
-  canvasApp?: CanvasAppOptions
+  sanityCreate?: SanityCreateOptions;
+  canvasApp?: CanvasAppOptions;
 }
 
 /**
@@ -428,10 +524,10 @@ declare interface BaseSchemaTypeOptions {
  * ```
  */
 declare interface BlockDecoratorDefinition {
-  title: string
-  i18nTitleKey?: string
-  value: string
-  icon?: ReactNode | ComponentType
+  title: string;
+  i18nTitleKey?: string;
+  value: string;
+  icon?: ReactNode | ComponentType;
 }
 
 /**
@@ -488,14 +584,14 @@ declare interface BlockDecoratorDefinition {
  * ```
  */
 declare interface BlockDefinition extends BaseSchemaDefinition {
-  type: 'block'
-  styles?: BlockStyleDefinition[]
-  lists?: BlockListDefinition[]
-  marks?: BlockMarksDefinition
-  of?: ArrayOfType<'object' | 'reference'>[]
-  initialValue?: InitialValueProperty<any, any[]>
-  options?: BlockOptions
-  validation?: ValidationBuilder<BlockRule, any[]>
+  type: "block";
+  styles?: BlockStyleDefinition[];
+  lists?: BlockListDefinition[];
+  marks?: BlockMarksDefinition;
+  of?: ArrayOfType<"object" | "reference">[];
+  initialValue?: InitialValueProperty<any, any[]>;
+  options?: BlockOptions;
+  validation?: ValidationBuilder<BlockRule, any[]>;
 }
 
 /**
@@ -521,10 +617,10 @@ declare interface BlockDefinition extends BaseSchemaDefinition {
  * ```
  */
 declare interface BlockListDefinition {
-  title: string
-  i18nTitleKey?: string
-  value: string
-  icon?: ReactNode | ComponentType
+  title: string;
+  i18nTitleKey?: string;
+  value: string;
+  icon?: ReactNode | ComponentType;
 }
 
 /**
@@ -532,8 +628,8 @@ declare interface BlockListDefinition {
  *
  * @public */
 declare interface BlockMarksDefinition {
-  decorators?: BlockDecoratorDefinition[]
-  annotations?: ArrayOfType<'object' | 'reference'>[]
+  decorators?: BlockDecoratorDefinition[];
+  annotations?: ArrayOfType<"object" | "reference">[];
 }
 
 /**
@@ -543,8 +639,8 @@ declare interface BlockOptions extends BaseSchemaTypeOptions {
   /**
    * Turn on or off the builtin browser spellchecking. Default is on.
    */
-  spellCheck?: boolean
-  unstable_whitespaceOnPasteMode?: 'preserve' | 'normalize' | 'remove'
+  spellCheck?: boolean;
+  unstable_whitespaceOnPasteMode?: "preserve" | "normalize" | "remove";
   /**
    * When enabled, the editor will restrict all line breaks and soft breaks,
    * forcing content to remain on a single line. This will also update
@@ -554,7 +650,7 @@ declare interface BlockOptions extends BaseSchemaTypeOptions {
    *
    * @defaultValue false
    */
-  oneLine?: boolean
+  oneLine?: boolean;
 }
 
 /** @public */
@@ -615,23 +711,23 @@ declare interface BlockRule extends RuleDef<BlockRule, any[]> {}
  * ```
  */
 declare interface BlockStyleDefinition {
-  title: string
-  value: string
-  i18nTitleKey?: string
-  icon?: ReactNode | ComponentType
+  title: string;
+  value: string;
+  i18nTitleKey?: string;
+  icon?: ReactNode | ComponentType;
 }
 
 /** @public */
 declare interface BooleanDefinition extends BaseSchemaDefinition {
-  type: 'boolean'
-  options?: BooleanOptions
-  initialValue?: InitialValueProperty<any, boolean>
-  validation?: ValidationBuilder<BooleanRule, boolean>
+  type: "boolean";
+  options?: BooleanOptions;
+  initialValue?: InitialValueProperty<any, boolean>;
+  validation?: ValidationBuilder<BooleanRule, boolean>;
 }
 
 /** @public */
 declare interface BooleanOptions extends BaseSchemaTypeOptions {
-  layout?: 'switch' | 'checkbox'
+  layout?: "switch" | "checkbox";
 }
 
 /** @public */
@@ -639,9 +735,9 @@ declare interface BooleanRule extends RuleDef<BooleanRule, boolean> {}
 
 /** @public */
 declare interface BooleanSchemaType extends BaseSchemaType {
-  jsonType: 'boolean'
-  options?: BooleanOptions
-  initialValue?: InitialValueProperty<any, boolean>
+  jsonType: "boolean";
+  options?: BooleanOptions;
+  initialValue?: InitialValueProperty<any, boolean>;
 }
 
 /**
@@ -651,82 +747,91 @@ declare interface BooleanSchemaType extends BaseSchemaType {
  */
 declare interface CanvasAppOptions {
   /** Set to true to exclude a type or field from appearing in Canvas */
-  exclude?: boolean
+  exclude?: boolean;
   /**
    * A short description of what the type or field is used for.
    * Purpose can be used to improve how and when content mapping uses the field.
    * */
-  purpose?: string
+  purpose?: string;
 }
 
 /** @public */
 declare interface CollapseOptions {
-  collapsed?: boolean
-  collapsible?: boolean
+  collapsed?: boolean;
+  collapsible?: boolean;
   /**
    * @deprecated Use `collapsible` instead
    */
-  collapsable?: boolean
+  collapsable?: boolean;
 }
 
 /** @public */
-declare type ConditionalProperty = boolean | ConditionalPropertyCallback | undefined
+declare type ConditionalProperty =
+  | boolean
+  | ConditionalPropertyCallback
+  | undefined;
 
 /** @public */
-declare type ConditionalPropertyCallback = (context: ConditionalPropertyCallbackContext) => boolean
+declare type ConditionalPropertyCallback = (
+  context: ConditionalPropertyCallbackContext,
+) => boolean;
 
 /** @public */
 declare interface ConditionalPropertyCallbackContext {
-  document: SanityDocument | undefined
-  parent: any
-  value: any
-  currentUser: Omit<CurrentUser, 'role'> | null
+  document: SanityDocument | undefined;
+  parent: any;
+  value: any;
+  currentUser: Omit<CurrentUser, "role"> | null;
+  path: Path;
 }
 
 /** @public */
 declare interface CrossDatasetReferenceDefinition extends BaseSchemaDefinition {
-  type: 'crossDatasetReference'
-  weak?: boolean
+  type: "crossDatasetReference";
+  weak?: boolean;
   to: {
-    type: string
-    title?: string
-    icon?: ComponentType
-    preview?: PreviewConfig
+    type: string;
+    title?: string;
+    icon?: ComponentType;
+    preview?: PreviewConfig;
     /**
      * @deprecated Unused. Configuring search is no longer supported.
      */
     __experimental_search?: {
-      path: string | string[]
-      weight?: number
-      mapWith?: string
-    }[]
-  }[]
-  dataset: string
-  studioUrl?: (document: {id: string; type?: string}) => string | null
-  tokenId?: string
-  options?: ReferenceOptions
+      path: string | string[];
+      weight?: number;
+      mapWith?: string;
+    }[];
+  }[];
+  dataset: string;
+  studioUrl?: (document: { id: string; type?: string }) => string | null;
+  tokenId?: string;
+  options?: ReferenceOptions;
   /**
    * @deprecated Cross-project references are no longer supported, only cross-dataset
    */
-  projectId?: string
+  projectId?: string;
 }
 
 /** @public */
 declare interface CurrentUser {
-  id: string
-  name: string
-  email: string
-  profileImage?: string
-  provider?: string
+  id: string;
+  name: string;
+  email: string;
+  profileImage?: string;
+  provider?: string;
   /** @deprecated use `roles` instead */
-  role: string
-  roles: Role[]
+  role: string;
+  roles: Role[];
 }
 
 /** @public */
 declare interface CustomValidator<T = unknown> {
-  (value: T, context: ValidationContext): CustomValidatorResult | Promise<CustomValidatorResult>
-  bypassConcurrencyLimit?: boolean
+  (
+    value: T,
+    context: ValidationContext,
+  ): CustomValidatorResult | Promise<CustomValidatorResult>;
+  bypassConcurrencyLimit?: boolean;
 }
 
 /** @public */
@@ -735,20 +840,20 @@ declare type CustomValidatorResult =
   | string
   | ValidationError
   | ValidationError[]
-  | LocalizedValidationMessages
+  | LocalizedValidationMessages;
 
 /** @public */
 declare interface DateDefinition extends BaseSchemaDefinition {
-  type: 'date'
-  options?: DateOptions
-  placeholder?: string
-  validation?: ValidationBuilder<DateRule, string>
-  initialValue?: InitialValueProperty<any, string>
+  type: "date";
+  options?: DateOptions;
+  placeholder?: string;
+  validation?: ValidationBuilder<DateRule, string>;
+  initialValue?: InitialValueProperty<any, string>;
 }
 
 /** @public */
 declare interface DateOptions extends BaseSchemaTypeOptions {
-  dateFormat?: string
+  dateFormat?: string;
 }
 
 /** @public */
@@ -756,29 +861,29 @@ declare interface DateRule extends RuleDef<DateRule, string> {
   /**
    * @param minDate - Minimum date (inclusive). minDate should be in ISO 8601 format.
    */
-  min: (minDate: string | FieldReference) => DateRule
+  min: (minDate: string | FieldReference) => DateRule;
   /**
    * @param maxDate - Maximum date (inclusive). maxDate should be in ISO 8601 format.
    */
-  max: (maxDate: string | FieldReference) => DateRule
+  max: (maxDate: string | FieldReference) => DateRule;
 }
 
 /** @public */
 declare interface DatetimeDefinition extends BaseSchemaDefinition {
-  type: 'datetime'
-  options?: DatetimeOptions
-  placeholder?: string
-  validation?: ValidationBuilder<DatetimeRule, string>
-  initialValue?: InitialValueProperty<any, string>
+  type: "datetime";
+  options?: DatetimeOptions;
+  placeholder?: string;
+  validation?: ValidationBuilder<DatetimeRule, string>;
+  initialValue?: InitialValueProperty<any, string>;
 }
 
 /** @public */
 declare interface DatetimeOptions extends BaseSchemaTypeOptions {
-  dateFormat?: string
-  timeFormat?: string
-  timeStep?: number
-  displayTimeZone?: string
-  allowTimeZoneSwitch?: boolean
+  dateFormat?: string;
+  timeFormat?: string;
+  timeStep?: number;
+  displayTimeZone?: string;
+  allowTimeZoneSwitch?: boolean;
 }
 
 /** @public */
@@ -786,47 +891,47 @@ declare interface DatetimeRule extends RuleDef<DatetimeRule, string> {
   /**
    * @param minDate - Minimum date (inclusive). minDate should be in ISO 8601 format.
    */
-  min: (minDate: string | FieldReference) => DatetimeRule
+  min: (minDate: string | FieldReference) => DatetimeRule;
   /**
    * @param maxDate - Maximum date (inclusive). maxDate should be in ISO 8601 format.
    */
-  max: (maxDate: string | FieldReference) => DatetimeRule
+  max: (maxDate: string | FieldReference) => DatetimeRule;
 }
 
 /** @public */
 declare interface DeprecatedProperty {
-  reason: string
+  reason: string;
 }
 
 /**
  * @public
  */
 declare interface DeprecationConfiguration {
-  deprecated: DeprecatedProperty
+  deprecated: DeprecatedProperty;
 }
 
 /** @public */
-declare interface DocumentDefinition extends Omit<ObjectDefinition, 'type'> {
-  type: 'document'
-  liveEdit?: boolean
+declare interface DocumentDefinition extends Omit<ObjectDefinition, "type"> {
+  type: "document";
+  liveEdit?: boolean;
   /** @beta */
-  orderings?: SortOrdering[]
-  options?: DocumentOptions
-  validation?: ValidationBuilder<DocumentRule, SanityDocument>
-  initialValue?: InitialValueProperty<any, Record<string, unknown>>
+  orderings?: SortOrdering[];
+  options?: DocumentOptions;
+  validation?: ValidationBuilder<DocumentRule, SanityDocument>;
+  initialValue?: InitialValueProperty<any, Record<string, unknown>>;
   /** @deprecated Unused. Use the new field-level search config. */
   __experimental_search?: {
-    path: string
-    weight: number
-    mapWith?: string
-  }[]
+    path: string;
+    weight: number;
+    mapWith?: string;
+  }[];
   /** @alpha */
-  __experimental_omnisearch_visibility?: boolean
+  __experimental_omnisearch_visibility?: boolean;
   /**
    * Determines whether the large preview title is displayed in the document pane form
    * @alpha
    * */
-  __experimental_formPreviewTitle?: boolean
+  __experimental_formPreviewTitle?: boolean;
 }
 
 /**
@@ -841,11 +946,11 @@ declare interface DocumentRule extends RuleDef<DocumentRule, SanityDocument> {}
 
 /** @public */
 declare interface EmailDefinition extends BaseSchemaDefinition {
-  type: 'email'
-  options?: EmailOptions
-  placeholder?: string
-  validation?: ValidationBuilder<EmailRule, string>
-  initialValue?: InitialValueProperty<any, string>
+  type: "email";
+  options?: EmailOptions;
+  placeholder?: string;
+  validation?: ValidationBuilder<EmailRule, string>;
+  initialValue?: InitialValueProperty<any, string>;
 }
 
 /** @public */
@@ -854,14 +959,11 @@ declare interface EmailOptions extends BaseSchemaTypeOptions {}
 /** @public */
 declare interface EmailRule extends RuleDef<EmailRule, string> {}
 
-/** @public */
-declare interface EmptyProps {}
-
 /** @public */
 declare interface EnumListProps<V = unknown> {
-  list?: Array<TitledListValue<V> | V>
-  layout?: 'radio' | 'dropdown'
-  direction?: 'horizontal' | 'vertical'
+  list?: Array<TitledListValue<V> | V>;
+  layout?: "radio" | "dropdown";
+  direction?: "horizontal" | "vertical";
 }
 
 /**
@@ -879,35 +981,39 @@ declare interface EnumListProps<V = unknown> {
 declare type FieldDefinition<
   TType extends IntrinsicTypeName = IntrinsicTypeName,
   TAlias extends IntrinsicTypeName | undefined = undefined,
-> = (InlineFieldDefinition[TType] | TypeAliasDefinition<string, TAlias>) & FieldDefinitionBase
+> = (
+  | InlineFieldDefinition[TType]
+  | TypeAliasDefinition<AutocompleteString, TAlias>
+) &
+  FieldDefinitionBase;
 
 /** @public */
 declare interface FieldDefinitionBase {
-  fieldset?: string
-  group?: string | string[]
+  fieldset?: string;
+  group?: string | string[];
 }
 
 /** @public */
 declare interface FieldGroup {
-  name: string
-  icon?: ComponentType
-  title?: string
-  description?: string
-  i18n?: I18nTextRecord<'title'>
-  hidden?: ConditionalProperty
-  default?: boolean
-  fields?: ObjectField[]
+  name: string;
+  icon?: ComponentType;
+  title?: string;
+  description?: string;
+  i18n?: I18nTextRecord<"title">;
+  hidden?: ConditionalProperty;
+  default?: boolean;
+  fields?: ObjectField[];
 }
 
 /** @public */
 declare type FieldGroupDefinition = {
-  name: string
-  title?: string
-  hidden?: ConditionalProperty
-  icon?: ComponentType
-  default?: boolean
-  i18n?: I18nTextRecord<'title'>
-}
+  name: string;
+  title?: string;
+  hidden?: ConditionalProperty;
+  icon?: ComponentType;
+  default?: boolean;
+  i18n?: I18nTextRecord<"title">;
+};
 
 /**
  * Holds a reference to a different field
@@ -916,53 +1022,58 @@ declare type FieldGroupDefinition = {
  * @public
  */
 declare interface FieldReference {
-  type: symbol
-  path: string | string[]
+  type: symbol;
+  path: string | string[];
 }
 
 /** @public */
 declare type FieldRules = {
-  [fieldKey: string]: SchemaValidationValue
-}
+  [fieldKey: string]: SchemaValidationValue;
+};
 
 /** @public */
-declare type Fieldset = SingleFieldSet | MultiFieldSet
+declare type Fieldset = SingleFieldSet | MultiFieldSet;
 
 /** @public */
-declare type FieldsetDefinition = {
-  name: string
-  title?: string
-  description?: string
-  group?: string
-  hidden?: ConditionalProperty
-  readOnly?: ConditionalProperty
-  options?: ObjectOptions
+declare interface FieldsetDefinition {
+  name: string;
+  title?: string;
+  description?: string;
+  group?: string;
+  hidden?: ConditionalProperty;
+  readOnly?: ConditionalProperty;
+  options?: ObjectOptions;
 }
 
 /** @public */
 declare interface File_2 {
-  [key: string]: unknown
-  asset?: Reference
+  [key: string]: unknown;
+  asset?: Reference;
 }
 
 /** @public */
 declare interface FileDefinition extends Omit<
   ObjectDefinition,
-  'type' | 'fields' | 'options' | 'groups' | 'validation'
+  "type" | "fields" | "options" | "groups" | "validation"
 > {
-  type: 'file'
-  fields?: ObjectDefinition['fields']
-  options?: FileOptions
-  validation?: ValidationBuilder<FileRule, FileValue>
-  initialValue?: InitialValueProperty<any, FileValue>
+  type: "file";
+  fields?: ObjectDefinition["fields"];
+  options?: FileOptions;
+  validation?: ValidationBuilder<FileRule, FileValue>;
+  initialValue?: InitialValueProperty<any, FileValue>;
 }
 
 /** @public */
 declare interface FileOptions extends ObjectOptions {
-  storeOriginalFilename?: boolean
-  accept?: string
-  sources?: AssetSource[]
-  mediaLibrary?: MediaLibraryOptions
+  storeOriginalFilename?: boolean;
+  accept?: string;
+  sources?: AssetSource[];
+  mediaLibrary?: MediaLibraryOptions;
+  /**
+   * When set to `true`, hides the upload UI, only allowing selection of existing assets from the media library.
+   * Useful for centralized asset management workflows where ad-hoc uploads should be prevented.
+   */
+  disableNew?: boolean;
 }
 
 /** @public */
@@ -980,46 +1091,51 @@ declare interface FileRule extends RuleDef<FileRule, FileValue> {
    * })
    * ```
    */
-  assetRequired(): FileRule
+  assetRequired(): FileRule;
 }
 
 /** @public */
-declare interface FileSchemaType extends Omit<ObjectSchemaType, 'options'> {
-  options?: FileOptions
+declare interface FileSchemaType extends Omit<ObjectSchemaType, "options"> {
+  options?: FileOptions;
 }
 
-export declare type FileStatus = 'pending' | 'uploading' | 'complete' | 'error' | 'alreadyExists'
+export declare type FileStatus =
+  | "pending"
+  | "uploading"
+  | "complete"
+  | "error"
+  | "alreadyExists";
 
 /**
  * Wrapper object for the file upload with progress and status
  */
 export declare interface FileUpload {
-  id: string
-  file: File
-  status: FileStatus
-  progress: number
-  error?: Error
+  id: string;
+  file: File;
+  status: FileStatus;
+  progress: number;
+  error?: Error;
 }
 
 /** @public */
 declare interface FileValue {
-  asset?: Reference
-  [index: string]: unknown
+  asset?: Reference;
+  [index: string]: unknown;
 }
 
 declare type Geopoint = {
-  _type: 'geopoint'
-  lat?: number
-  lng?: number
-  alt?: number
-}
+  _type: "geopoint";
+  lat?: number;
+  lng?: number;
+  alt?: number;
+};
 
 /** @public */
 declare interface GeopointDefinition extends BaseSchemaDefinition {
-  type: 'geopoint'
-  options?: GeopointOptions
-  validation?: ValidationBuilder<GeopointRule, GeopointValue>
-  initialValue?: InitialValueProperty<any, Omit<GeopointValue, '_type'>>
+  type: "geopoint";
+  options?: GeopointOptions;
+  validation?: ValidationBuilder<GeopointRule, GeopointValue>;
+  initialValue?: InitialValueProperty<any, Omit<GeopointValue, "_type">>;
 }
 
 /** @public */
@@ -1039,131 +1155,141 @@ declare interface GeopointValue {
   /**
    * Type of the object. Must be `geopoint`.
    */
-  _type: 'geopoint'
+  _type: "geopoint";
   /**
    * Latitude in degrees
    */
-  lat: number
+  lat: number;
   /**
    * Longitude in degrees
    */
-  lng: number
+  lng: number;
   /**
    * Altitude in meters
    */
-  alt?: number
+  alt?: number;
 }
 
 /** @public */
 declare interface GlobalDocumentReferenceDefinition extends BaseSchemaDefinition {
-  type: 'globalDocumentReference'
-  weak?: boolean
+  type: "globalDocumentReference";
+  weak?: boolean;
   to: {
-    type: string
-    title?: string
-    icon?: ComponentType
-    preview?: PreviewConfig
-  }[]
-  resourceType: string
-  resourceId: string
-  options?: ReferenceOptions
-  studioUrl?: string | ((document: {id: string; type?: string}) => string | null)
+    type: string;
+    title?: string;
+    icon?: ComponentType;
+    preview?: PreviewConfig;
+  }[];
+  resourceType: string;
+  resourceId: string;
+  options?: ReferenceOptions;
+  studioUrl?:
+    | string
+    | ((document: { id: string; type?: string }) => string | null);
 }
 
 /** @public */
 declare interface HotspotOptions {
-  previews?: HotspotPreview[]
+  previews?: HotspotPreview[];
 }
 
 /** @public */
 declare interface HotspotPreview {
-  title: string
-  aspectRatio: number
+  title: string;
+  aspectRatio: number;
 }
 
 /** @public */
 declare type I18nTextRecord<K extends string> = {
   [P in K]?: {
-    key: string
-    ns: string
-  }
-}
+    key: string;
+    ns: string;
+  };
+};
 
 /** @public */
 declare interface ImageAsset extends Asset_2 {
-  _type: 'sanity.imageAsset'
-  metadata: ImageMetadata
+  _type: "sanity.imageAsset";
+  metadata: ImageMetadata;
 }
 
 /** @public */
 declare interface ImageCrop {
-  _type?: 'sanity.imageCrop'
-  left: number
-  bottom: number
-  right: number
-  top: number
+  _type?: "sanity.imageCrop";
+  left: number;
+  bottom: number;
+  right: number;
+  top: number;
 }
 
 /** @public */
 declare interface ImageDefinition extends Omit<
   ObjectDefinition,
-  'type' | 'fields' | 'options' | 'groups' | 'validation'
+  "type" | "fields" | "options" | "groups" | "validation"
 > {
-  type: 'image'
-  fields?: FieldDefinition[]
-  options?: ImageOptions
-  validation?: ValidationBuilder<ImageRule, ImageValue>
-  initialValue?: InitialValueProperty<any, ImageValue>
+  type: "image";
+  fields?: FieldDefinition[];
+  options?: ImageOptions;
+  validation?: ValidationBuilder<ImageRule, ImageValue>;
+  initialValue?: InitialValueProperty<any, ImageValue>;
 }
 
 /** @public */
 declare interface ImageDimensions {
-  _type: 'sanity.imageDimensions'
-  height: number
-  width: number
-  aspectRatio: number
+  _type: "sanity.imageDimensions";
+  height: number;
+  width: number;
+  aspectRatio: number;
 }
 
 /** @public */
 declare interface ImageHotspot {
-  _type?: 'sanity.imageHotspot'
-  width: number
-  height: number
-  x: number
-  y: number
+  _type?: "sanity.imageHotspot";
+  width: number;
+  height: number;
+  x: number;
+  y: number;
 }
 
 /** @public */
 declare interface ImageMetadata {
-  [key: string]: unknown
-  _type: 'sanity.imageMetadata'
-  dimensions: ImageDimensions
-  palette?: ImagePalette
-  lqip?: string
-  blurHash?: string
-  hasAlpha: boolean
-  isOpaque: boolean
+  [key: string]: unknown;
+  _type: "sanity.imageMetadata";
+  dimensions: ImageDimensions;
+  palette?: ImagePalette;
+  lqip?: string;
+  blurHash?: string;
+  thumbHash?: string;
+  hasAlpha: boolean;
+  isOpaque: boolean;
 }
 
 /** @public */
-declare type ImageMetadataType = 'blurhash' | 'lqip' | 'palette' | 'exif' | 'image' | 'location'
+declare type ImageMetadataType =
+  | "blurhash"
+  | "thumbhash"
+  | "lqip"
+  | "palette"
+  | "exif"
+  | "image"
+  | "location";
 
 /** @public */
 declare interface ImageOptions extends FileOptions {
-  metadata?: ImageMetadataType[]
-  hotspot?: boolean | HotspotOptions
+  metadata?: ImageMetadataType[];
+  hotspot?: boolean | HotspotOptions;
 }
 
 /** @public */
 declare interface ImagePalette {
-  _type: 'sanity.imagePalette'
-  darkMuted?: ImageSwatch
-  darkVibrant?: ImageSwatch
-  dominant?: ImageSwatch
-  lightMuted?: ImageSwatch
-  lightVibrant?: ImageSwatch
-  muted?: ImageSwatch
-  vibrant?: ImageSwatch
+  _type: "sanity.imagePalette";
+  darkMuted?: ImageSwatch;
+  darkVibrant?: ImageSwatch;
+  dominant?: ImageSwatch;
+  lightMuted?: ImageSwatch;
+  lightVibrant?: ImageSwatch;
+  muted?: ImageSwatch;
+  vibrant?: ImageSwatch;
 }
 
 /** @public */
@@ -1181,64 +1307,64 @@ declare interface ImageRule extends RuleDef<ImageRule, ImageValue> {
    * })
    * ```
    */
-  assetRequired(): ImageRule
+  assetRequired(): ImageRule;
 }
 
 /** @public */
-declare interface ImageSchemaType extends Omit<ObjectSchemaType, 'options'> {
-  options?: ImageOptions
+declare interface ImageSchemaType extends Omit<ObjectSchemaType, "options"> {
+  options?: ImageOptions;
 }
 
 /** @public */
 declare interface ImageSwatch {
-  _type: 'sanity.imagePaletteSwatch'
-  background: string
-  foreground: string
-  population: number
-  title?: string
+  _type: "sanity.imagePaletteSwatch";
+  background: string;
+  foreground: string;
+  population: number;
+  title?: string;
 }
 
 /** @public */
 declare interface ImageValue extends FileValue {
-  crop?: ImageCrop
-  hotspot?: ImageHotspot
-  [index: string]: unknown
+  crop?: ImageCrop;
+  hotspot?: ImageHotspot;
+  [index: string]: unknown;
 }
 
 /** @public */
-declare type IndexTuple = [number | '', number | '']
+declare type IndexTuple = [number | "", number | ""];
 
 /** @public */
 declare type InitialValueProperty<Params, Value> =
   | Value
   | InitialValueResolver<Params, Value>
-  | undefined
+  | undefined;
 
 /** @public */
 declare type InitialValueResolver<Params, Value> = (
   params: Params | undefined,
   context: InitialValueResolverContext,
-) => Promise<Value> | Value
+) => Promise<Value> | Value;
 
 /** @public */
 declare interface InitialValueResolverContext {
-  projectId: string
-  dataset: string
-  schema: Schema
-  currentUser: CurrentUser | null
-  getClient: (options: {apiVersion: string}) => SanityClient
+  projectId: string;
+  dataset: string;
+  schema: Schema;
+  currentUser: CurrentUser | null;
+  getClient: (options: { apiVersion: string }) => SanityClient;
 }
 
 /** @public */
 declare type InlineFieldDefinition = {
   [K in keyof IntrinsicDefinitions]: Omit<
     IntrinsicDefinitions[K],
-    'initialValue' | 'validation'
+    "initialValue" | "validation"
   > & {
-    validation?: SchemaValidationValue
-    initialValue?: InitialValueProperty<any, any>
-  }
-}
+    validation?: SchemaValidationValue;
+    initialValue?: InitialValueProperty<any, any>;
+  };
+};
 
 /** @alpha This API may change */
 declare interface InsertMenuOptions {
@@ -1247,42 +1373,42 @@ declare interface InsertMenuOptions {
    * `filter: 'auto'` automatically turns on filtering if there are more than 5
    * schema types added to the menu.
    */
-  filter?: 'auto' | boolean | undefined
+  filter?: "auto" | boolean | undefined;
   groups?:
     | Array<{
-        name: string
-        title?: string
-        of?: Array<string>
+        name: string;
+        title?: string;
+        of?: Array<string>;
       }>
-    | undefined
+    | undefined;
   /** defaultValue `true` */
-  showIcons?: boolean | undefined
+  showIcons?: boolean | undefined;
   /** @defaultValue `[{name: 'list'}]` */
   views?:
     | Array<
         | {
-            name: 'list'
+            name: "list";
           }
         | {
-            name: 'grid'
-            previewImageUrl?: (schemaTypeName: string) => string | undefined
+            name: "grid";
+            previewImageUrl?: (schemaTypeName: string) => string | undefined;
           }
       >
-    | undefined
+    | undefined;
 }
 
-declare const internalGroqTypeReferenceTo: unique symbol
+declare const internalGroqTypeReferenceTo: unique symbol;
 
 /** @public */
 declare type IntrinsicArrayOfDefinition = {
   [K in keyof IntrinsicDefinitions]: Omit<
     ArrayOfEntry<IntrinsicDefinitions[K]>,
-    'validation' | 'initialValue'
+    "validation" | "initialValue"
   > & {
-    validation?: SchemaValidationValue
-    initialValue?: InitialValueProperty<any, any>
-  }
-}
+    validation?: SchemaValidationValue;
+    initialValue?: InitialValueProperty<any, any>;
+  };
+};
 
 /**
  * `IntrinsicDefinitions` is a lookup map for "predefined" schema definitions.
@@ -1300,25 +1426,25 @@ declare type IntrinsicArrayOfDefinition = {
  * @public
  */
 declare interface IntrinsicDefinitions {
-  array: ArrayDefinition
-  block: BlockDefinition
-  boolean: BooleanDefinition
-  date: DateDefinition
-  datetime: DatetimeDefinition
-  document: DocumentDefinition
-  file: FileDefinition
-  geopoint: GeopointDefinition
-  image: ImageDefinition
-  number: NumberDefinition
-  object: ObjectDefinition
-  reference: ReferenceDefinition
-  crossDatasetReference: CrossDatasetReferenceDefinition
-  globalDocumentReference: GlobalDocumentReferenceDefinition
-  slug: SlugDefinition
-  string: StringDefinition
-  text: TextDefinition
-  url: UrlDefinition
-  email: EmailDefinition
+  array: ArrayDefinition;
+  block: BlockDefinition;
+  boolean: BooleanDefinition;
+  date: DateDefinition;
+  datetime: DatetimeDefinition;
+  document: DocumentDefinition;
+  file: FileDefinition;
+  geopoint: GeopointDefinition;
+  image: ImageDefinition;
+  number: NumberDefinition;
+  object: ObjectDefinition;
+  reference: ReferenceDefinition;
+  crossDatasetReference: CrossDatasetReferenceDefinition;
+  globalDocumentReference: GlobalDocumentReferenceDefinition;
+  slug: SlugDefinition;
+  string: StringDefinition;
+  text: TextDefinition;
+  url: UrlDefinition;
+  email: EmailDefinition;
 }
 
 /**
@@ -1328,12 +1454,13 @@ declare interface IntrinsicDefinitions {
  *
  * @public
  */
-declare type IntrinsicTypeName = IntrinsicDefinitions[keyof IntrinsicDefinitions]['type']
+declare type IntrinsicTypeName =
+  IntrinsicDefinitions[keyof IntrinsicDefinitions]["type"];
 
 /** @public */
 declare type KeyedSegment = {
-  _key: string
-}
+  _key: string;
+};
 
 /**
  * Holds localized validation messages for a given field.
@@ -1348,25 +1475,27 @@ declare type KeyedSegment = {
  * @public
  */
 declare interface LocalizedValidationMessages {
-  [locale: string]: string
+  [locale: string]: string;
 }
 
 /** @public */
-declare type MediaAssetTypes = AssetInstanceDocument_2['_type']
+declare type MediaAssetTypes = AssetInstanceDocument_2["_type"];
 
 /** @public */
 declare interface MediaLibraryFilter {
-  name: string
-  query: string
+  name: string;
+  query: string;
 }
 
 /** @public */
 declare interface MediaLibraryOptions {
-  filters?: MediaLibraryFilter[]
+  filters?: MediaLibraryFilter[];
 }
 
 /** @public */
-declare interface MediaValidationValue<T extends MediaAssetTypes = MediaAssetTypes> {
+declare interface MediaValidationValue<
+  T extends MediaAssetTypes = MediaAssetTypes,
+> {
   /**
    * Media information
    */
@@ -1378,15 +1507,15 @@ declare interface MediaValidationValue<T extends MediaAssetTypes = MediaAssetTyp
       currentVersion: Extract<
         AssetInstanceDocument_2,
         {
-          _type: T
+          _type: T;
         }
-      >
-    }
-  }
+      >;
+    };
+  };
   /**
    * The field value which the media is used in.
    */
-  value: unknown
+  value: unknown;
 }
 
 /** @public */
@@ -1394,159 +1523,170 @@ declare interface MediaValidator<T extends MediaAssetTypes = MediaAssetTypes> {
   (
     value: MediaValidationValue<T>,
     context: ValidationContext,
-  ): CustomValidatorResult | Promise<CustomValidatorResult>
+  ): CustomValidatorResult | Promise<CustomValidatorResult>;
 }
 
 /** @public */
 declare interface MultiFieldSet {
-  name: string
-  title?: string
-  description?: string
-  single?: false
-  group?: string | string[]
+  name: string;
+  title?: string;
+  description?: string;
+  single?: false;
+  group?: string | string[];
   options?: CollapseOptions & {
-    columns?: number
-  }
-  fields: ObjectField[]
-  hidden?: ConditionalProperty
-  readOnly?: ConditionalProperty
+    columns?: number;
+  };
+  fields: ObjectField[];
+  hidden?: ConditionalProperty;
+  readOnly?: ConditionalProperty;
 }
 
 /** @public */
 declare interface NumberDefinition extends BaseSchemaDefinition {
-  type: 'number'
-  options?: NumberOptions
-  placeholder?: string
-  validation?: ValidationBuilder<NumberRule, number>
-  initialValue?: InitialValueProperty<any, number>
+  type: "number";
+  options?: NumberOptions;
+  placeholder?: string;
+  validation?: ValidationBuilder<NumberRule, number>;
+  initialValue?: InitialValueProperty<any, number>;
 }
 
 /** @public */
-declare interface NumberOptions extends EnumListProps<number>, BaseSchemaTypeOptions {}
+declare interface NumberOptions
+  extends EnumListProps<number>, BaseSchemaTypeOptions {}
 
 /** @public */
 declare interface NumberRule extends RuleDef<NumberRule, number> {
-  min: (minNumber: number | FieldReference) => NumberRule
-  max: (maxNumber: number | FieldReference) => NumberRule
-  lessThan: (limit: number | FieldReference) => NumberRule
-  greaterThan: (limit: number | FieldReference) => NumberRule
-  integer: () => NumberRule
-  precision: (limit: number | FieldReference) => NumberRule
-  positive: () => NumberRule
-  negative: () => NumberRule
+  min: (minNumber: number | FieldReference) => NumberRule;
+  max: (maxNumber: number | FieldReference) => NumberRule;
+  lessThan: (limit: number | FieldReference) => NumberRule;
+  greaterThan: (limit: number | FieldReference) => NumberRule;
+  integer: () => NumberRule;
+  precision: (limit: number | FieldReference) => NumberRule;
+  positive: () => NumberRule;
+  negative: () => NumberRule;
 }
 
 /** @public */
 declare interface NumberSchemaType extends BaseSchemaType {
-  jsonType: 'number'
-  options?: NumberOptions
-  initialValue?: InitialValueProperty<any, number>
+  jsonType: "number";
+  options?: NumberOptions;
+  initialValue?: InitialValueProperty<any, number>;
 }
 
 /** @public */
 declare interface ObjectDefinition extends BaseSchemaDefinition {
-  type: 'object'
+  type: "object";
   /**
    * Object must have at least one field. This is validated at Studio startup.
    */
-  fields: FieldDefinition[]
-  groups?: FieldGroupDefinition[]
-  fieldsets?: FieldsetDefinition[]
-  preview?: PreviewConfig
-  options?: ObjectOptions
-  validation?: ValidationBuilder<ObjectRule, Record<string, unknown>>
-  initialValue?: InitialValueProperty<any, Record<string, unknown>>
+  fields: FieldDefinition[];
+  groups?: FieldGroupDefinition[];
+  fieldsets?: FieldsetDefinition[];
+  preview?: PreviewConfig;
+  options?: ObjectOptions;
+  validation?: ValidationBuilder<ObjectRule, Record<string, unknown>>;
+  initialValue?: InitialValueProperty<any, Record<string, unknown>>;
 }
 
 /** @public */
 declare interface ObjectField<T extends SchemaType = SchemaType> {
-  name: string
-  fieldset?: string
-  group?: string | string[]
-  type: ObjectFieldType<T>
+  name: string;
+  fieldset?: string;
+  group?: string | string[];
+  type: ObjectFieldType<T>;
 }
 
 /** @public */
 declare type ObjectFieldType<T extends SchemaType = SchemaType> = T & {
-  hidden?: ConditionalProperty
-  readOnly?: ConditionalProperty
-}
+  hidden?: ConditionalProperty;
+  readOnly?: ConditionalProperty;
+};
 
 /** @public */
 declare interface ObjectOptions extends BaseSchemaTypeOptions {
-  collapsible?: boolean
-  collapsed?: boolean
-  columns?: number
+  collapsible?: boolean;
+  collapsed?: boolean;
+  columns?: number;
   modal?: {
-    type?: 'dialog' | 'popover'
-    width?: number | number[] | 'auto'
-  }
+    type?: "dialog" | "popover";
+    width?: number | number[] | "auto";
+  };
 }
 
 /** @public */
-declare interface ObjectRule extends RuleDef<ObjectRule, Record<string, unknown>> {}
+declare interface ObjectRule extends RuleDef<
+  ObjectRule,
+  Record<string, unknown>
+> {}
 
 /** @public */
 declare interface ObjectSchemaType extends BaseSchemaType {
-  jsonType: 'object'
-  fields: ObjectField[]
-  groups?: FieldGroup[]
-  fieldsets?: Fieldset[]
-  initialValue?: InitialValueProperty<any, Record<string, unknown>>
-  weak?: boolean
+  jsonType: "object";
+  fields: ObjectField[];
+  groups?: FieldGroup[];
+  fieldsets?: Fieldset[];
+  initialValue?: InitialValueProperty<any, Record<string, unknown>>;
+  weak?: boolean;
   /** @deprecated Unused. Use the new field-level search config. */
   __experimental_search?: {
-    path: (string | number)[]
-    weight: number
-    mapWith?: string
-  }[]
+    path: (string | number)[];
+    weight: number;
+    mapWith?: string;
+  }[];
   /** @alpha */
-  __experimental_omnisearch_visibility?: boolean
+  __experimental_omnisearch_visibility?: boolean;
   /** @alpha */
-  __experimental_actions?: string[]
+  __experimental_actions?: string[];
   /** @alpha */
-  __experimental_formPreviewTitle?: boolean
+  __experimental_formPreviewTitle?: boolean;
   /**
    * @beta
    */
-  orderings?: SortOrdering[]
-  options?: any
+  orderings?: SortOrdering[];
+  options?: any;
 }
 
 /** @public */
-declare type Path = PathSegment[]
+declare type Path = PathSegment[];
 
 /** @public */
-declare type PathSegment = string | number | KeyedSegment | IndexTuple
+declare type PathSegment = string | number | KeyedSegment | IndexTuple;
 
 /**
  * Media Library capabilities that the consumer can declare it supports
  */
 export declare type PluginCapabilities = {
-  privateAssets?: boolean
-}
+  privateAssets?: boolean;
+};
 
 /**
  * Filter that the plugin consumer can use to limit the assets shown
  */
 export declare type PluginFilter = {
-  type: 'groq'
-  name: string
-  query: string
-}
+  type: "groq";
+  name: string;
+  query: string;
+};
 
 /**
  * Payload used to configure the plugin behavior
  */
 export declare type PluginPayload = {
-  auth: 'token' | 'cookie'
-  capabilities?: PluginCapabilities
-  disableNavigation?: boolean
-  pluginFilters?: PluginFilter[]
-  scheme: 'light' | 'dark'
-  selectAssetTypes: PluginSelectAssetType[]
-  selectionType: 'single' | 'multiple'
-}
+  auth: "token" | "cookie";
+  capabilities?: PluginCapabilities;
+  disableNavigation?: boolean;
+  pluginFilters?: PluginFilter[];
+  scheme: "light" | "dark";
+  selectAssetTypes: PluginSelectAssetType[];
+  selectionType: "single" | "multiple";
+  /**
+   * Opaque string the host generates to **partition persisted picker UI state** (e.g. folder path,
+   * search query, filters) in the Media Library iframe. Huey derives `localStorage` key suffixes
+   * from this value; embedders often derive it from project + dataset + workspace (or any stable
+   * context).
+   */
+  pickerPersistenceKey?: string;
+};
 
 export declare type PluginPostMessage =
   | PluginPostMessageAbortUploadRequest
@@ -1558,93 +1698,93 @@ export declare type PluginPostMessage =
   | PluginPostMessageTokenResponse
   | PluginPostMessageUploadFilesProgress
   | PluginPostMessageUploadFilesRequest
-  | PluginPostMessageUploadFilesResponse
+  | PluginPostMessageUploadFilesResponse;
 
 export declare type PluginPostMessageAbortUploadRequest = {
-  type: 'abortUploadRequest'
+  type: "abortUploadRequest";
   files?: {
-    id: string
-  }[]
-}
+    id: string;
+  }[];
+};
 
 export declare type PluginPostMessageAssetSelection = {
-  type: 'assetSelection'
-  selection: AssetSelectionItemWithLegacySupport[]
-}
+  type: "assetSelection";
+  selection: AssetSelectionItemWithLegacySupport[];
+};
 
 /**
  * Message sent from the plugin that a document has been updated
  */
 export declare type PluginPostMessageDocumentUpdate = {
-  type: 'documentUpdate'
+  type: "documentUpdate";
   document: {
-    _id: string
-    _type: string
-    _rev: string
-  }
-}
+    _id: string;
+    _type: string;
+    _rev: string;
+  };
+};
 
 /**
  * Message sent from a plugin page to notify the host that the page is loaded and ready to be interacted with
  */
 export declare type PluginPostMessagePageLoaded = {
-  type: 'pageLoaded'
-  page: string
-}
+  type: "pageLoaded";
+  page: string;
+};
 
 /**
  * Message sent from a plugin page that a page is unloaded by the user (for closing the dialog and similar)
  */
 export declare type PluginPostMessagePageUnloaded = {
-  type: 'pageUnloaded'
-  page: string
-}
+  type: "pageUnloaded";
+  page: string;
+};
 
 export declare type PluginPostMessageTokenRequest = {
-  type: 'tokenRequest'
-}
+  type: "tokenRequest";
+};
 
 export declare type PluginPostMessageTokenResponse = {
-  type: 'tokenResponse'
-  token: string | null
-}
+  type: "tokenResponse";
+  token: string | null;
+};
 
 /**
  * Message sent from the plugin when files are uploading
  */
 export declare type PluginPostMessageUploadFilesProgress = {
-  type: 'uploadProgress'
-  files: FileUpload[]
-}
+  type: "uploadProgress";
+  files: FileUpload[];
+};
 
 /**
  * Message sent from the plugin that the user wants to upload files
  */
 export declare type PluginPostMessageUploadFilesRequest = {
-  type: 'uploadRequest'
+  type: "uploadRequest";
   files: {
-    id: string
-    file: File
-  }[]
-}
+    id: string;
+    file: File;
+  }[];
+};
 
 /**
  * Message sent from the app that the pending uploads are uploaded
  */
 export declare type PluginPostMessageUploadFilesResponse = {
-  type: 'uploadResponse'
-  assets: AssetSelectionItemWithLegacySupport[]
-}
+  type: "uploadResponse";
+  assets: AssetSelectionItemWithLegacySupport[];
+};
 
 /**
  * Asset types that can be selected by the plugin
  */
-export declare type PluginSelectAssetType = 'file' | 'image' | 'video'
+export declare type PluginSelectAssetType = "file" | "image" | "video";
 
 /** @public */
 declare interface PrepareViewOptions {
   /** @beta */
-  ordering?: SortOrdering
+  ordering?: SortOrdering;
 }
 
 /** @public */
@@ -1652,91 +1792,121 @@ declare interface PreviewConfig<
   Select extends Record<string, string> = Record<string, string>,
   PrepareValue extends Record<keyof Select, any> = Record<keyof Select, any>,
 > {
-  select?: Select
-  prepare?: (value: PrepareValue, viewOptions?: PrepareViewOptions) => PreviewValue
+  select?: Select;
+  prepare?: (
+    value: PrepareValue,
+    viewOptions?: PrepareViewOptions,
+  ) => PreviewValue;
 }
 
 /** @public */
 declare interface PreviewValue {
-  _id?: string
-  _createdAt?: string
-  _updatedAt?: string
-  title?: string
-  subtitle?: string
-  description?: string
-  media?: ReactNode | ElementType
-  imageUrl?: string
+  _id?: string;
+  _createdAt?: string;
+  _updatedAt?: string;
+  title?: string;
+  subtitle?: string;
+  description?: string;
+  media?: ReactNode | ElementType;
+  imageUrl?: string;
 }
 
 /** @public */
 declare interface Reference {
-  _type: string
-  _ref: string
-  _key?: string
-  _weak?: boolean
+  _type: string;
+  _ref: string;
+  _key?: string;
+  _weak?: boolean;
   _strengthenOnPublish?: {
-    type: string
-    weak?: boolean
+    type: string;
+    weak?: boolean;
     template?: {
-      id: string
-      params: Record<string, string | number | boolean>
-    }
-  }
+      id: string;
+      params: Record<string, string | number | boolean>;
+    };
+  };
 }
 
 /** @public */
 declare interface ReferenceBaseOptions extends BaseSchemaTypeOptions {
-  disableNew?: boolean
+  /**
+   * When `true`, hides the "Create new" button in the reference input,
+   * preventing users from creating new documents from this field.
+   *
+   * For more granular control (e.g., allowing creation of only specific types,
+   * or conditionally hiding the button based on document state), use the
+   * `creationTypeFilter` option instead.
+   */
+  disableNew?: boolean;
+  /**
+   * Callback function to dynamically filter which document types can be created
+   * from this reference field based on the current document state.
+   *
+   * This allows you to conditionally restrict the types available in the
+   * "Create new" dropdown based on other field values in the document.
+   *
+   * **Important**: This only affects document creation, not which existing documents
+   * appear in search results. To filter search results, use the `filter` option instead.
+   *
+   * @param context - Contains the current document, parent value, and field path
+   * @param toTypes - Array of all types configured in the reference field's `to` property
+   * @returns Array of type options that should be available for creation. Return the
+   *          original `toTypes` array to allow all types, a filtered subset to restrict
+   *          available types, or an empty array `[]` to hide the "Create new" button entirely.
+   */
+  creationTypeFilter?: ReferenceTypeFilter;
 }
 
 /** @public */
 declare interface ReferenceDefinition extends BaseSchemaDefinition {
-  type: 'reference'
-  to: ReferenceTo
-  weak?: boolean
-  options?: ReferenceOptions
-  validation?: ValidationBuilder<ReferenceRule, ReferenceValue>
-  initialValue?: InitialValueProperty<any, Omit<ReferenceValue, '_type'>>
+  type: "reference";
+  to: ReferenceTo;
+  weak?: boolean;
+  options?: ReferenceOptions;
+  validation?: ValidationBuilder<ReferenceRule, ReferenceValue>;
+  initialValue?: InitialValueProperty<any, Omit<ReferenceValue, "_type">>;
 }
 
 /** @public */
-declare type ReferenceFilterOptions = ReferenceFilterResolverOptions | ReferenceFilterQueryOptions
+declare type ReferenceFilterOptions =
+  | ReferenceFilterResolverOptions
+  | ReferenceFilterQueryOptions;
 
 /** @public */
 declare interface ReferenceFilterQueryOptions {
-  filter: string
-  filterParams?: Record<string, unknown>
+  filter: string;
+  filterParams?: Record<string, unknown>;
 }
 
 /** @public */
 declare type ReferenceFilterResolver = (
   context: ReferenceFilterResolverContext,
-) => ReferenceFilterSearchOptions | Promise<ReferenceFilterSearchOptions>
+) => ReferenceFilterSearchOptions | Promise<ReferenceFilterSearchOptions>;
 
 /** @public */
 declare interface ReferenceFilterResolverContext {
-  document: SanityDocument
-  parent?: Record<string, unknown> | Record<string, unknown>[]
-  parentPath: Path
-  perspective: StackablePerspective[]
-  getClient: (options: {apiVersion: string}) => SanityClient
+  document: SanityDocument;
+  parent?: Record<string, unknown> | Record<string, unknown>[];
+  parentPath: Path;
+  perspective: StackablePerspective[];
+  getClient: (options: { apiVersion: string }) => SanityClient;
 }
 
 /** @public */
 declare interface ReferenceFilterResolverOptions {
-  filter?: ReferenceFilterResolver
-  filterParams?: never
+  filter?: ReferenceFilterResolver;
+  filterParams?: never;
 }
 
 /** @public */
 declare type ReferenceFilterSearchOptions = {
-  filter?: string
-  params?: Record<string, unknown>
-  tag?: string
-  maxFieldDepth?: number
-  strategy?: SearchStrategy
-  perspective?: Exclude<ClientPerspective, 'raw' | 'previewDrafts'>
-}
+  filter?: string;
+  params?: Record<string, unknown>;
+  tag?: string;
+  maxFieldDepth?: number;
+  strategy?: SearchStrategy;
+  perspective?: Exclude<ClientPerspective, "raw" | "previewDrafts">;
+};
 
 /**
  * Types are closed for extension. To add properties via declaration merging to this type,
@@ -1748,33 +1918,77 @@ declare type ReferenceFilterSearchOptions = {
  *
  * @public
  */
-declare type ReferenceOptions = ReferenceBaseOptions & ReferenceFilterOptions
+declare type ReferenceOptions = ReferenceBaseOptions & ReferenceFilterOptions;
 
 /** @public */
-declare interface ReferenceRule extends RuleDef<ReferenceRule, ReferenceValue> {}
+declare interface ReferenceRule extends RuleDef<
+  ReferenceRule,
+  ReferenceValue
+> {}
 
 /** @public */
-declare interface ReferenceSchemaType extends Omit<ObjectSchemaType, 'options'> {
-  jsonType: 'object'
-  to: ObjectSchemaType[]
-  weak?: boolean
-  options?: ReferenceOptions
+declare interface ReferenceSchemaType extends Omit<
+  ObjectSchemaType,
+  "options"
+> {
+  jsonType: "object";
+  to: ObjectSchemaType[];
+  weak?: boolean;
+  options?: ReferenceOptions;
 }
 
 /** @public */
 declare type ReferenceTo =
   | SchemaTypeDefinition
   | TypeReference
-  | Array<SchemaTypeDefinition | TypeReference>
+  | Array<SchemaTypeDefinition | TypeReference>;
+
+/**
+ * Function type for filtering which document types can be created from a reference field.
+ *
+ * The `creationTypeFilter` specifically controls the types
+ * available when clicking "Create new" in the reference input.
+ *
+ * This is distinct from the `filter` option, which controls which existing documents appear in search results.
+ *
+ * @param context - Information about the current document and field location
+ * @param toTypes - Array of type options from the reference field's `to` configuration
+ * @returns Filtered array of type options that should be available for creation
+ *
+ * @public
+ */
+declare type ReferenceTypeFilter = (
+  context: ReferenceTypeFilterContext,
+  toTypes: ReferenceTypeOption[],
+) => ReferenceTypeOption[];
+
+/**
+ * Context object passed to the creationTypeFilter callback.
+ *
+ * @public
+ */
+declare interface ReferenceTypeFilterContext {
+  /** The current document being edited */
+  document: SanityDocument;
+  /** The parent value containing this reference field */
+  parent?: Record<string, unknown> | Record<string, unknown>[];
+  /** The path to the parent value in the document */
+  parentPath: Path;
+}
 
 /** @public */
-declare type ReferenceValue = Reference
+declare interface ReferenceTypeOption {
+  type: string;
+}
+
+/** @public */
+declare type ReferenceValue = Reference;
 
 /** @public */
 declare interface Role {
-  name: string
-  title: string
-  description?: string
+  name: string;
+  title: string;
+  description?: string;
 }
 
 /** @public */
@@ -1783,37 +1997,37 @@ declare interface Rule {
    * @internal
    * @deprecated internal use only
    */
-  _type: RuleTypeConstraint | undefined
+  _type: RuleTypeConstraint | undefined;
   /**
    * @internal
    * @deprecated internal use only
    */
-  _level: 'error' | 'warning' | 'info' | undefined
+  _level: "error" | "warning" | "info" | undefined;
   /**
    * @internal
    * @deprecated internal use only
    */
-  _required: 'required' | 'optional' | undefined
+  _required: "required" | "optional" | undefined;
   /**
    * @internal
    * @deprecated internal use only
    */
-  _typeDef: SchemaType | undefined
+  _typeDef: SchemaType | undefined;
   /**
    * @internal
    * @deprecated internal use only
    */
-  _message: string | LocalizedValidationMessages | undefined
+  _message: string | LocalizedValidationMessages | undefined;
   /**
    * @internal
    * @deprecated internal use only
    */
-  _rules: RuleSpec[]
+  _rules: RuleSpec[];
   /**
    * @internal
    * @deprecated internal use only
    */
-  _fieldRules: FieldRules | undefined
+  _fieldRules: FieldRules | undefined;
   /**
    * Takes in a path and returns an object with a symbol.
    *
@@ -1836,62 +2050,65 @@ declare interface Rule {
    * ]
    * ```
    */
-  valueOfField: (path: string | string[]) => FieldReference
-  error(message?: string | LocalizedValidationMessages): Rule
-  warning(message?: string | LocalizedValidationMessages): Rule
-  info(message?: string | LocalizedValidationMessages): Rule
-  reset(): this
-  isRequired(): boolean
-  clone(): Rule
-  cloneWithRules(rules: RuleSpec[]): Rule
-  merge(rule: Rule): Rule
-  type(targetType: RuleTypeConstraint | Lowercase<RuleTypeConstraint>): Rule
-  all(children: Rule[]): Rule
-  either(children: Rule[]): Rule
-  optional(): Rule
-  required(): Rule
+  valueOfField: (path: string | string[]) => FieldReference;
+  error(message?: string | LocalizedValidationMessages): Rule;
+  warning(message?: string | LocalizedValidationMessages): Rule;
+  info(message?: string | LocalizedValidationMessages): Rule;
+  reset(): this;
+  isRequired(): boolean;
+  clone(): Rule;
+  cloneWithRules(rules: RuleSpec[]): Rule;
+  merge(rule: Rule): Rule;
+  type(targetType: RuleTypeConstraint | Lowercase<RuleTypeConstraint>): Rule;
+  all(children: Rule[]): Rule;
+  either(children: Rule[]): Rule;
+  optional(): Rule;
+  required(): Rule;
+  skip(): Rule;
   custom<T = unknown>(
     fn: CustomValidator<T>,
     options?: {
-      bypassConcurrencyLimit?: boolean
+      bypassConcurrencyLimit?: boolean;
     },
-  ): Rule
-  media<T extends MediaAssetTypes = MediaAssetTypes>(fn: MediaValidator<T>): Rule
-  min(len: number | string | FieldReference): Rule
-  max(len: number | string | FieldReference): Rule
-  length(len: number | FieldReference): Rule
-  valid(value: unknown | unknown[]): Rule
-  integer(): Rule
-  precision(limit: number | FieldReference): Rule
-  positive(): Rule
-  negative(): Rule
-  greaterThan(num: number | FieldReference): Rule
-  lessThan(num: number | FieldReference): Rule
-  uppercase(): Rule
-  lowercase(): Rule
+  ): Rule;
+  media<T extends MediaAssetTypes = MediaAssetTypes>(
+    fn: MediaValidator<T>,
+  ): Rule;
+  min(len: number | string | FieldReference): Rule;
+  max(len: number | string | FieldReference): Rule;
+  length(len: number | FieldReference): Rule;
+  valid(value: unknown | unknown[]): Rule;
+  integer(): Rule;
+  precision(limit: number | FieldReference): Rule;
+  positive(): Rule;
+  negative(): Rule;
+  greaterThan(num: number | FieldReference): Rule;
+  lessThan(num: number | FieldReference): Rule;
+  uppercase(): Rule;
+  lowercase(): Rule;
   regex(
     pattern: RegExp,
     name: string,
     options: {
-      name?: string
-      invert?: boolean
+      name?: string;
+      invert?: boolean;
     },
-  ): Rule
+  ): Rule;
   regex(
     pattern: RegExp,
     options: {
-      name?: string
-      invert?: boolean
+      name?: string;
+      invert?: boolean;
     },
-  ): Rule
-  regex(pattern: RegExp, name: string): Rule
-  regex(pattern: RegExp): Rule
-  email(): Rule
-  uri(options?: UriValidationOptions): Rule
-  unique(): Rule
-  reference(): Rule
-  fields(rules: FieldRules): Rule
-  assetRequired(): Rule
+  ): Rule;
+  regex(pattern: RegExp, name: string): Rule;
+  regex(pattern: RegExp): Rule;
+  email(): Rule;
+  uri(options?: UriValidationOptions): Rule;
+  unique(): Rule;
+  reference(): Rule;
+  fields(rules: FieldRules): Rule;
+  assetRequired(): Rule;
   validate(
     value: unknown,
     options: ValidationContext & {
@@ -1901,194 +2118,208 @@ declare interface Rule {
        */
       __internal?: {
         customValidationConcurrencyLimiter?: {
-          ready: () => Promise<void>
-          release: () => void
-        }
-      }
+          ready: () => Promise<void>;
+          release: () => void;
+        };
+      };
     },
-  ): Promise<ValidationMarker[]>
+  ): Promise<ValidationMarker[]>;
 }
 
 /** @public */
-declare type RuleBuilder<T extends RuleDef<T, FieldValue>, FieldValue = unknown> = T | T[]
+declare type RuleBuilder<
+  T extends RuleDef<T, FieldValue>,
+  FieldValue = unknown,
+> = T | T[];
 
 /** @public */
 declare interface RuleDef<T, FieldValue = unknown> {
-  required: () => T
+  required: () => T;
+  skip: () => T;
   custom: <LenientFieldValue extends FieldValue>(
     fn: CustomValidator<LenientFieldValue | undefined>,
-  ) => T
-  info: (message?: string | LocalizedValidationMessages) => T
-  error: (message?: string | LocalizedValidationMessages) => T
-  warning: (message?: string | LocalizedValidationMessages) => T
-  valueOfField: (path: string | string[]) => FieldReference
+  ) => T;
+  info: (message?: string | LocalizedValidationMessages) => T;
+  error: (message?: string | LocalizedValidationMessages) => T;
+  warning: (message?: string | LocalizedValidationMessages) => T;
+  valueOfField: (path: string | string[]) => FieldReference;
 }
 
 /** @public */
 declare type RuleSpec =
   | {
-      flag: 'integer'
+      flag: "integer";
     }
   | {
-      flag: 'email'
+      flag: "email";
     }
   | {
-      flag: 'unique'
+      flag: "unique";
     }
   | {
-      flag: 'reference'
+      flag: "reference";
     }
   | {
-      flag: 'type'
-      constraint: RuleTypeConstraint
+      flag: "type";
+      constraint: RuleTypeConstraint;
     }
   | {
-      flag: 'all'
-      constraint: Rule[]
+      flag: "all";
+      constraint: Rule[];
     }
   | {
-      flag: 'either'
-      constraint: Rule[]
+      flag: "either";
+      constraint: Rule[];
     }
   | {
-      flag: 'presence'
-      constraint: 'optional' | 'required'
+      flag: "presence";
+      constraint: "optional" | "required";
     }
   | {
-      flag: 'custom'
-      constraint: CustomValidator
+      flag: "custom";
+      constraint: CustomValidator;
     }
   | {
-      flag: 'min'
-      constraint: number | string | FieldReference
+      flag: "min";
+      constraint: number | string | FieldReference;
     }
   | {
-      flag: 'max'
-      constraint: number | string | FieldReference
+      flag: "max";
+      constraint: number | string | FieldReference;
     }
   | {
-      flag: 'length'
-      constraint: number | FieldReference
+      flag: "length";
+      constraint: number | FieldReference;
     }
   | {
-      flag: 'valid'
-      constraint: unknown[]
+      flag: "valid";
+      constraint: unknown[];
     }
   | {
-      flag: 'precision'
-      constraint: number | FieldReference
+      flag: "precision";
+      constraint: number | FieldReference;
     }
   | {
-      flag: 'lessThan'
-      constraint: number | FieldReference
+      flag: "lessThan";
+      constraint: number | FieldReference;
     }
   | {
-      flag: 'greaterThan'
-      constraint: number | FieldReference
+      flag: "greaterThan";
+      constraint: number | FieldReference;
     }
   | {
-      flag: 'stringCasing'
-      constraint: 'uppercase' | 'lowercase'
+      flag: "stringCasing";
+      constraint: "uppercase" | "lowercase";
     }
   | {
-      flag: 'assetRequired'
+      flag: "assetRequired";
       constraint: {
-        assetType: 'asset' | 'image' | 'file'
-      }
+        assetType: "asset" | "image" | "file";
+      };
     }
   | {
-      flag: 'media'
-      constraint: MediaValidator<any>
+      flag: "media";
+      constraint: MediaValidator<any>;
     }
   | {
-      flag: 'regex'
+      flag: "regex";
       constraint: {
-        pattern: RegExp
-        name?: string
-        invert: boolean
-      }
+        pattern: RegExp;
+        name?: string;
+        invert: boolean;
+      };
     }
   | {
-      flag: 'uri'
+      flag: "uri";
       constraint: {
         options: {
-          scheme: RegExp[]
-          allowRelative: boolean
-          relativeOnly: boolean
-          allowCredentials: boolean
-        }
-      }
-    }
-
-/** @public */
-declare type RuleTypeConstraint = 'Array' | 'Boolean' | 'Date' | 'Number' | 'Object' | 'String'
+          scheme: RegExp[];
+          allowRelative: boolean;
+          relativeOnly: boolean;
+          allowCredentials: boolean;
+        };
+      };
+    };
+
+/** @public */
+declare type RuleTypeConstraint =
+  | "Array"
+  | "Boolean"
+  | "Date"
+  | "Number"
+  | "Object"
+  | "String";
 
 declare type SanityAsset = {
-  _id: string
-  _type: 'sanity.asset'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  title?: string
-  aspects?: Record<string, unknown>
-  currentVersion: {
-    _ref: string
-    _type: 'reference'
-    _weak?: boolean
-    [internalGroqTypeReferenceTo]?: 'sanity.asset.version'
-  }
+  _id: string;
+  _type: "sanity.asset";
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  title?: string;
+  aspects?: Record<string, unknown>;
+  currentVersion: SanityAssetVersionReference;
   versions: Array<
     {
-      _key: string
+      _key: string;
     } & SanityAssetVersion
-  >
-  assetType: 'sanity.imageAsset' | 'sanity.videoAsset' | 'sanity.fileAsset'
-  cdnAccessPolicy: 'public' | 'private'
-  url?: string
-}
+  >;
+  assetType: "sanity.imageAsset" | "sanity.videoAsset" | "sanity.fileAsset";
+  cdnAccessPolicy: "public" | "private";
+  parent?: SanityDirectoryReference | SanityTreeReference;
+  rootDirectory?: SanityDirectoryReference;
+  url?: string;
+  _system?: SanitySystem;
+};
 
 declare type SanityAssetCollection = {
-  _id: string
-  _type: 'sanity.asset.collection'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  title: string
-  description?: string
-  assets?: Array<{
-    _ref: string
-    _type: 'reference'
-    _weak?: boolean
-    _key: string
-    [internalGroqTypeReferenceTo]?: 'sanity.asset'
-  }>
-}
-
-declare type SanityAssetInstanceState = string
+  _id: string;
+  _type: "sanity.asset.collection";
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  title: string;
+  description?: string;
+  parent?: SanityDirectoryReference | SanityTreeReference;
+  rootDirectory?: SanityDirectoryReference;
+  assets?: Array<
+    {
+      _key: string;
+    } & SanityAssetReference
+  >;
+};
+
+declare type SanityAssetInstanceState = string;
+
+declare type SanityAssetReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.asset";
+};
+
+declare type SanityAssetSubtitleReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.asset.subtitle";
+};
 
 declare type SanityAssetVersion = {
-  _type: 'sanity.asset.version'
-  title?: string
+  _type: "sanity.asset.version";
+  title?: string;
   instance:
-    | {
-        _ref: string
-        _type: 'reference'
-        _weak?: boolean
-        [internalGroqTypeReferenceTo]?: 'sanity.imageAsset'
-      }
-    | {
-        _ref: string
-        _type: 'reference'
-        _weak?: boolean
-        [internalGroqTypeReferenceTo]?: 'sanity.fileAsset'
-      }
-    | {
-        _ref: string
-        _type: 'reference'
-        _weak?: boolean
-        [internalGroqTypeReferenceTo]?: 'sanity.videoAsset'
-      }
-}
+    | SanityImageAssetReference
+    | SanityFileAssetReference
+    | SanityVideoAssetReference;
+};
+
+declare type SanityAssetVersionReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.asset.version";
+};
 
 /**
  * Options for configuring how Sanity Create interfaces with the type or field.
@@ -2097,260 +2328,306 @@ declare type SanityAssetVersion = {
  */
 declare interface SanityCreateOptions {
   /** Set to true to exclude a type or field from appearing in Sanity Create */
-  exclude?: boolean
+  exclude?: boolean;
   /**
    * A short description of what the type or field is used for.
    * Purpose can be used to improve how and when content mapping uses the field.
    * */
-  purpose?: string
+  purpose?: string;
 }
 
+declare type SanityDirectoryReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.directory";
+};
+
 /** @public */
 declare interface SanityDocument {
-  _id: string
-  _type: string
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  [key: string]: unknown
+  _id: string;
+  _type: string;
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  [key: string]: unknown;
 }
 
 declare type SanityFileAsset = {
-  _id: string
-  _type: 'sanity.fileAsset'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  title?: string
+  _id: string;
+  _type: "sanity.fileAsset";
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  title?: string;
   description?: Array<{
     children?: Array<{
-      marks?: Array<string>
-      text?: string
-      _type: 'span'
-      _key: string
-    }>
-    style?: 'normal' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'blockquote'
-    listItem?: 'bullet' | 'number'
+      marks?: Array<string>;
+      text?: string;
+      _type: "span";
+      _key: string;
+    }>;
+    style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
+    listItem?: "bullet" | "number";
     markDefs?: Array<{
-      href?: string
-      _type: 'link'
-      _key: string
-    }>
-    level?: number
-    _type: 'block'
-    _key: string
-  }>
-  state: SanityAssetInstanceState
-  sha1hash?: string
-  mimeType?: string
-  originalFilename?: string
-  size?: number
-  uploadId?: string
-  path: string
-  extension?: string
-  url: string
-  previewUrl?: string
-}
+      href?: string;
+      _type: "link";
+      _key: string;
+    }>;
+    level?: number;
+    _type: "block";
+    _key: string;
+  }>;
+  state: SanityAssetInstanceState;
+  sha1hash?: string;
+  mimeType?: string;
+  originalFilename?: string;
+  size?: number;
+  uploadId?: string;
+  path: string;
+  extension?: string;
+  url: string;
+  previewUrl?: string;
+  rootDirectory?: SanityDirectoryReference;
+  _system?: SanitySystem;
+};
+
+declare type SanityFileAssetReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.fileAsset";
+};
 
 declare type SanityImageAsset = {
-  _id: string
-  _type: 'sanity.imageAsset'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  altText?: string
-  state: SanityAssetInstanceState
-  sha1hash?: string
-  mimeType?: string
-  originalFilename?: string
-  size?: number
-  uploadId?: string
-  path?: string
-  extension?: string
-  url: string
-  metadata: SanityImageMetadata
-}
+  _id: string;
+  _type: "sanity.imageAsset";
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  altText?: string;
+  state: SanityAssetInstanceState;
+  sha1hash?: string;
+  mimeType?: string;
+  originalFilename?: string;
+  size?: number;
+  uploadId?: string;
+  path?: string;
+  extension?: string;
+  url: string;
+  metadata: SanityImageMetadata;
+  rootDirectory?: SanityDirectoryReference;
+  _system?: SanitySystem;
+};
+
+declare type SanityImageAssetReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.imageAsset";
+};
 
 declare type SanityImageDimensions = {
-  _type: 'sanity.imageDimensions'
-  height: number
-  width: number
-  aspectRatio: number
-}
+  _type: "sanity.imageDimensions";
+  height: number;
+  width: number;
+  aspectRatio: number;
+};
 
 declare type SanityImageExifMetadata = {
-  _type: 'sanity.imageExifMetadata'
-  ApertureValue?: number
-  BrightnessValue?: number
-  DateTimeDigitized?: string
-  DateTimeOriginal?: string
-  ExposureBiasValue?: number
-  ExposureMode?: number
-  ExposureProgram?: number
-  ExposureTime?: number
-  FNumber?: number
-  Flash?: number
-  FocalLength?: number
-  FocalLengthIn35mmFormat?: number
-  ISO?: number
-  LensModel?: string
-  WhiteBalance?: number
-  GPSLatitude?: number
-  GPSLongitude?: number
-  GPSAltitude?: number
-  Copyright?: string
-  Artist?: string
-}
+  _type: "sanity.imageExifMetadata";
+  ApertureValue?: number;
+  BrightnessValue?: number;
+  DateTimeDigitized?: string;
+  DateTimeOriginal?: string;
+  ExposureBiasValue?: number;
+  ExposureMode?: number;
+  ExposureProgram?: number;
+  ExposureTime?: number;
+  FNumber?: number;
+  Flash?: number;
+  FocalLength?: number;
+  FocalLengthIn35mmFormat?: number;
+  ISO?: number;
+  LensModel?: string;
+  WhiteBalance?: number;
+  GPSLatitude?: number;
+  GPSLongitude?: number;
+  GPSAltitude?: number;
+  Copyright?: string;
+  Artist?: string;
+};
 
 declare type SanityImageExifTags = {
-  _type: 'sanity.imageExifTags'
-  Make?: string
-  Model?: string
-  Orientation?: number
-  XResolution?: number
-  YResolution?: number
-  ResolutionUnit?: number
-  Software?: string
-  ModifyDate?: string
-  ExifOffset?: number
-  GPSInfo?: number
-}
+  _type: "sanity.imageExifTags";
+  Make?: string;
+  Model?: string;
+  Orientation?: number;
+  XResolution?: number;
+  YResolution?: number;
+  ResolutionUnit?: number;
+  Software?: string;
+  ModifyDate?: string;
+  ExifOffset?: number;
+  GPSInfo?: number;
+};
 
 declare type SanityImageMetadata = {
-  _type: 'sanity.imageMetadata'
-  location?: Geopoint
-  dimensions: SanityImageDimensions
-  exif?: SanityImageExifMetadata
-  image?: SanityImageExifTags
-  palette: SanityImagePalette
-  lqip: string
-  blurHash: string
-  hasAlpha: boolean
-  isOpaque: boolean
-}
+  _type: "sanity.imageMetadata";
+  location?: Geopoint;
+  dimensions: SanityImageDimensions;
+  exif?: SanityImageExifMetadata;
+  image?: SanityImageExifTags;
+  palette: SanityImagePalette;
+  lqip: string;
+  blurHash: string;
+  hasAlpha: boolean;
+  isOpaque: boolean;
+};
 
 declare type SanityImagePalette = {
-  _type: 'sanity.imagePalette'
-  darkMuted?: SanityImagePaletteSwatch
-  lightVibrant?: SanityImagePaletteSwatch
-  darkVibrant?: SanityImagePaletteSwatch
-  vibrant?: SanityImagePaletteSwatch
-  dominant?: SanityImagePaletteSwatch
-  lightMuted?: SanityImagePaletteSwatch
-  muted?: SanityImagePaletteSwatch
-}
+  _type: "sanity.imagePalette";
+  darkMuted?: SanityImagePaletteSwatch;
+  lightVibrant?: SanityImagePaletteSwatch;
+  darkVibrant?: SanityImagePaletteSwatch;
+  vibrant?: SanityImagePaletteSwatch;
+  dominant?: SanityImagePaletteSwatch;
+  lightMuted?: SanityImagePaletteSwatch;
+  muted?: SanityImagePaletteSwatch;
+};
 
 declare type SanityImagePaletteSwatch = {
-  _type: 'sanity.imagePaletteSwatch'
-  background?: string
-  foreground?: string
-  population?: number
-  title?: string
-}
+  _type: "sanity.imagePaletteSwatch";
+  background?: string;
+  foreground?: string;
+  population?: number;
+  title?: string;
+};
 
 declare type SanitySystem = {
-  _type: 'sanity.system'
-  createdBy?: string
-}
+  _type: "sanity.system";
+  createdBy?: string;
+};
+
+declare type SanityTreeReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.tree";
+};
 
 export declare type SanityVideoAsset = {
-  _id: string
-  _type: 'sanity.videoAsset'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  title?: string
+  _id: string;
+  _type: "sanity.videoAsset";
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  title?: string;
   description?: Array<{
     children?: Array<{
-      marks?: Array<string>
-      text?: string
-      _type: 'span'
-      _key: string
-    }>
-    style?: 'normal' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'blockquote'
-    listItem?: 'bullet' | 'number'
+      marks?: Array<string>;
+      text?: string;
+      _type: "span";
+      _key: string;
+    }>;
+    style?: "normal" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "blockquote";
+    listItem?: "bullet" | "number";
     markDefs?: Array<{
-      href?: string
-      _type: 'link'
-      _key: string
-    }>
-    level?: number
-    _type: 'block'
-    _key: string
-  }>
-  state: SanityAssetInstanceState
-  sha1hash?: string
-  mimeType?: string
-  originalFilename?: string
-  size?: number
-  uploadId?: string
-  path?: string
-  url?: string
-  extension?: string
+      href?: string;
+      _type: "link";
+      _key: string;
+    }>;
+    level?: number;
+    _type: "block";
+    _key: string;
+  }>;
+  state: SanityAssetInstanceState;
+  sha1hash?: string;
+  mimeType?: string;
+  originalFilename?: string;
+  size?: number;
+  uploadId?: string;
+  path?: string;
+  url?: string;
+  extension?: string;
   source?: {
-    id?: string
-    name?: string
-    url?: string
-  }
-  metadata: SanityVideoMetadata
-}
+    id?: string;
+    name?: string;
+    url?: string;
+  };
+  metadata: SanityVideoMetadata;
+  rootDirectory?: SanityDirectoryReference;
+  _system?: SanitySystem;
+};
+
+declare type SanityVideoAssetReference = {
+  _ref: string;
+  _type: "reference";
+  _weak?: boolean;
+  [internalGroqTypeReferenceTo]?: "sanity.videoAsset";
+};
 
 declare type SanityVideoMetadata = {
-  _type: 'sanity.videoMetadata'
-  aspectRatio?: string
-  duration?: number
-  framerate?: number
+  _type: "sanity.videoMetadata";
+  aspectRatio?: string;
+  duration?: number;
+  framerate?: number;
   playbacks?: Array<
     {
-      _key: string
+      _key: string;
     } & SanityVideoMetadataPlayback
-  >
+  >;
   renditions?: Array<
     {
-      _key: string
+      _key: string;
     } & SanityVideoMetadataRendition
-  >
-}
+  >;
+  subtitles?: Array<
+    {
+      _key: string;
+    } & SanityAssetSubtitleReference
+  >;
+};
 
 declare type SanityVideoMetadataPlayback = {
-  _type: 'sanity.videoMetadata.playback'
-  _id: string
-  name?: string
-  policy: string
-}
+  _type: "sanity.videoMetadata.playback";
+  _id: string;
+  name?: string;
+  policy: string;
+};
 
 export declare type SanityVideoMetadataRendition = {
-  _type: 'sanity.videoMetadata.rendition'
-  name: string
-  resolution: string
-}
+  _type: "sanity.videoMetadata.rendition";
+  name: string;
+  resolution: string;
+};
 
 /** @public */
 declare interface Schema {
   /** @internal */
   _original?: {
-    name: string
-    types: SchemaTypeDefinition[]
-  }
+    name: string;
+    types: SchemaTypeDefinition[];
+  };
   /** @internal */
   _registry: {
-    [typeName: string]: any
-  }
+    [typeName: string]: any;
+  };
   /** @internal */
-  _validation?: SchemaValidationProblemGroup[]
-  name: string
-  get: (name: string) => SchemaType | undefined
-  has: (name: string) => boolean
-  getTypeNames: () => string[]
+  _validation?: SchemaValidationProblemGroup[];
+  name: string;
+  get: (name: string) => SchemaType | undefined;
+  has: (name: string) => boolean;
+  getTypeNames: () => string[];
   /**
    * Returns the types which were explicitly defined in this schema,
    * as opposed to the types which were inherited from the parent.
    */
-  getLocalTypeNames: () => string[]
+  getLocalTypeNames: () => string[];
   /**
    * Returns the parent schema.
    */
-  parent?: Schema
+  parent?: Schema;
 }
 
 /**
@@ -2366,7 +2643,7 @@ declare type SchemaType =
   | NumberSchemaType
   | ObjectSchemaType
   | StringSchemaType
-  | ReferenceSchemaType
+  | ReferenceSchemaType;
 
 /**
  * Represents a Sanity schema type definition with an optional type parameter.
@@ -2378,38 +2655,42 @@ declare type SchemaType =
  *
  * @public
  */
-declare type SchemaTypeDefinition<TType extends IntrinsicTypeName = IntrinsicTypeName> =
+declare type SchemaTypeDefinition<
+  TType extends IntrinsicTypeName = IntrinsicTypeName,
+> =
   | IntrinsicDefinitions[IntrinsicTypeName]
-  | TypeAliasDefinition<string, TType>
+  | TypeAliasDefinition<AutocompleteString, TType>;
 
 /** @public */
 declare interface SchemaValidationError {
-  helpId?: string
-  message: string
-  severity: 'error'
+  helpId?: string;
+  message: string;
+  severity: "error";
 }
 
 /** @internal */
-declare type SchemaValidationProblem = SchemaValidationError | SchemaValidationWarning
+declare type SchemaValidationProblem =
+  | SchemaValidationError
+  | SchemaValidationWarning;
 
 /** @internal */
 declare interface SchemaValidationProblemGroup {
-  path: SchemaValidationProblemPath
-  problems: SchemaValidationProblem[]
+  path: SchemaValidationProblemPath;
+  problems: SchemaValidationProblem[];
 }
 
 /** @internal */
 declare type SchemaValidationProblemPath = Array<
   | {
-      kind: 'type'
-      type: string
-      name?: string
+      kind: "type";
+      type: string;
+      name?: string;
     }
   | {
-      kind: 'property'
-      name: string
+      kind: "property";
+      name: string;
     }
->
+>;
 
 /**
  * Represents the possible values of a schema type's `validation` field.
@@ -2441,13 +2722,13 @@ declare type SchemaValidationValue =
   | undefined
   | Rule
   | SchemaValidationValue[]
-  | ((rule: Rule) => SchemaValidationValue)
+  | ((rule: Rule, context?: ValidationContext) => SchemaValidationValue);
 
 /** @internal */
 declare interface SchemaValidationWarning {
-  helpId?: string
-  message: string
-  severity: 'warning'
+  helpId?: string;
+  message: string;
+  severity: "warning";
 }
 
 /** @public */
@@ -2467,35 +2748,35 @@ declare interface SearchConfiguration {
      * Note: Search weight configuration is currently supported only for fields
      * of type string or portable text arrays.
      */
-    weight?: number
-  }
+    weight?: number;
+  };
 }
 
 /**
  * @public
  */
-declare const searchStrategies: readonly ['groqLegacy', 'groq2024']
+declare const searchStrategies: readonly ["groqLegacy", "groq2024"];
 
 /**
  * @public
  */
-declare type SearchStrategy = (typeof searchStrategies)[number]
+declare type SearchStrategy = (typeof searchStrategies)[number];
 
 /** @public */
 declare interface SingleFieldSet {
-  single: true
-  field: ObjectField
-  hidden?: ConditionalProperty
-  readOnly?: ConditionalProperty
-  group?: string | string[]
+  single: true;
+  field: ObjectField;
+  hidden?: ConditionalProperty;
+  readOnly?: ConditionalProperty;
+  group?: string | string[];
 }
 
 /** @public */
 declare interface SlugDefinition extends BaseSchemaDefinition {
-  type: 'slug'
-  options?: SlugOptions
-  validation?: ValidationBuilder<SlugRule, SlugValue>
-  initialValue?: InitialValueProperty<any, Omit<SlugValue, '_type'>>
+  type: "slug";
+  options?: SlugOptions;
+  validation?: ValidationBuilder<SlugRule, SlugValue>;
+  initialValue?: InitialValueProperty<any, Omit<SlugValue, "_type">>;
 }
 
 /** @public */
@@ -2503,86 +2784,102 @@ declare type SlugifierFn = (
   source: string,
   schemaType: SlugSchemaType,
   context: SlugSourceContext,
-) => string | Promise<string>
+) => string | Promise<string>;
 
 /** @public */
 declare type SlugIsUniqueValidator = (
   slug: string,
   context: SlugValidationContext,
-) => boolean | Promise<boolean>
+) => boolean | Promise<boolean>;
 
 /** @public */
-declare interface SlugOptions extends SearchConfiguration, BaseSchemaTypeOptions {
-  source?: string | Path | SlugSourceFn
-  maxLength?: number
-  slugify?: SlugifierFn
-  isUnique?: SlugIsUniqueValidator
-  disableArrayWarning?: boolean
+declare interface SlugOptions
+  extends SearchConfiguration, BaseSchemaTypeOptions {
+  source?: string | Path | SlugSourceFn;
+  maxLength?: number;
+  slugify?: SlugifierFn;
+  isUnique?: SlugIsUniqueValidator;
+  disableArrayWarning?: boolean;
 }
 
 /** @public */
-declare type SlugParent = Record<string, unknown> | Record<string, unknown>[]
+declare type SlugParent = Record<string, unknown> | Record<string, unknown>[];
 
 /** @public */
 declare interface SlugRule extends RuleDef<SlugRule, SlugValue> {}
 
 /** @public */
 declare interface SlugSchemaType extends ObjectSchemaType {
-  jsonType: 'object'
-  options?: SlugOptions
+  jsonType: "object";
+  options?: SlugOptions;
 }
 
 /** @public */
 declare interface SlugSourceContext {
-  parentPath: Path
-  parent: SlugParent
-  projectId: string
-  dataset: string
-  schema: Schema
-  currentUser: CurrentUser | null
-  getClient: (options: {apiVersion: string}) => SanityClient
+  parentPath: Path;
+  parent: SlugParent;
+  projectId: string;
+  dataset: string;
+  schema: Schema;
+  currentUser: CurrentUser | null;
+  getClient: (options: { apiVersion: string }) => SanityClient;
 }
 
 /** @public */
 declare type SlugSourceFn = (
   document: SanityDocument,
   context: SlugSourceContext,
-) => string | Promise<string>
+) => string | Promise<string>;
 
 /** @public */
 declare interface SlugValidationContext extends ValidationContext {
-  parent: SlugParent
-  type: SlugSchemaType
-  defaultIsUnique: SlugIsUniqueValidator
+  parent: SlugParent;
+  type: SlugSchemaType;
+  defaultIsUnique: SlugIsUniqueValidator;
 }
 
 /** @public */
 declare interface SlugValue {
-  _type: 'slug'
-  current?: string
+  _type: "slug";
+  current?: string;
 }
 
 /** @beta */
 declare type SortOrdering = {
-  title: string
-  i18n?: I18nTextRecord<'title'>
-  name: string
-  by: SortOrderingItem[]
-}
+  title: string;
+  i18n?: I18nTextRecord<"title">;
+  name: string;
+  by: SortOrderingItem[];
+};
 
 /** @beta */
 declare interface SortOrderingItem {
-  field: string
-  direction: 'asc' | 'desc'
+  field: string;
+  direction: "asc" | "desc";
+  /**
+   * Controls whether null/undefined values appear first or last in the sort order.
+   *
+   * Defaults match PostgreSQL behavior:
+   * - `'desc'` direction → nulls first
+   * - `'asc'` direction → nulls last
+   *
+   * Only specify this to override the default (e.g. `nulls: 'last'` with `direction: 'desc'`).
+   *
+   * ### ❗This is an experimental feature.
+   * Overriding the default may have performance implications for document types
+   * with hundreds of documents.
+   * @alpha
+   */
+  nulls?: "first" | "last";
 }
 
 /** @public */
 declare interface StringDefinition extends BaseSchemaDefinition {
-  type: 'string'
-  options?: StringOptions
-  placeholder?: string
-  validation?: ValidationBuilder<StringRule, string>
-  initialValue?: InitialValueProperty<any, string>
+  type: "string";
+  options?: StringOptions;
+  placeholder?: string;
+  validation?: ValidationBuilder<StringRule, string>;
+  initialValue?: InitialValueProperty<any, string>;
 }
 
 /** @public */
@@ -2591,29 +2888,29 @@ declare interface StringOptions
 
 /** @public */
 declare interface StringRule extends RuleDef<StringRule, string> {
-  min: (minNumber: number | FieldReference) => StringRule
-  max: (maxNumber: number | FieldReference) => StringRule
-  length: (exactLength: number | FieldReference) => StringRule
-  uppercase: () => StringRule
-  lowercase: () => StringRule
+  min: (minNumber: number | FieldReference) => StringRule;
+  max: (maxNumber: number | FieldReference) => StringRule;
+  length: (exactLength: number | FieldReference) => StringRule;
+  uppercase: () => StringRule;
+  lowercase: () => StringRule;
   regex(
     pattern: RegExp,
     name: string,
     options: {
-      name?: string
-      invert?: boolean
+      name?: string;
+      invert?: boolean;
     },
-  ): StringRule
+  ): StringRule;
   regex(
     pattern: RegExp,
     options: {
-      name?: string
-      invert?: boolean
+      name?: string;
+      invert?: boolean;
     },
-  ): StringRule
-  regex(pattern: RegExp, name: string): StringRule
-  regex(pattern: RegExp): StringRule
-  email(): StringRule
+  ): StringRule;
+  regex(pattern: RegExp, name: string): StringRule;
+  regex(pattern: RegExp): StringRule;
+  email(): StringRule;
 }
 
 /**
@@ -2623,19 +2920,19 @@ declare interface StringRule extends RuleDef<StringRule, string> {
  * @public
  */
 declare interface StringSchemaType extends BaseSchemaType {
-  jsonType: 'string'
-  options?: StringOptions & TextOptions & DateOptions & DatetimeOptions
-  initialValue?: InitialValueProperty<any, string>
+  jsonType: "string";
+  options?: StringOptions & TextOptions & DateOptions & DatetimeOptions;
+  initialValue?: InitialValueProperty<any, string>;
 }
 
 /** @public */
 declare interface TextDefinition extends BaseSchemaDefinition {
-  type: 'text'
-  rows?: number
-  options?: TextOptions
-  placeholder?: string
-  validation?: ValidationBuilder<TextRule, string>
-  initialValue?: InitialValueProperty<any, string>
+  type: "text";
+  rows?: number;
+  options?: TextOptions;
+  placeholder?: string;
+  validation?: ValidationBuilder<TextRule, string>;
+  initialValue?: InitialValueProperty<any, string>;
 }
 
 /** @public */
@@ -2646,9 +2943,9 @@ declare interface TextRule extends StringRule {}
 
 /** @public */
 declare interface TitledListValue<V = unknown> {
-  _key?: string
-  title: string
-  value?: V
+  _key?: string;
+  title: string;
+  value?: V;
 }
 
 /**
@@ -2663,21 +2960,23 @@ declare interface TypeAliasDefinition<
   TType extends string,
   TAlias extends IntrinsicTypeName | undefined,
 > extends BaseSchemaDefinition {
-  type: TType
-  options?: TAlias extends IntrinsicTypeName ? IntrinsicDefinitions[TAlias]['options'] : unknown
-  validation?: SchemaValidationValue
-  initialValue?: InitialValueProperty<any, any>
-  preview?: PreviewConfig
+  type: TType;
+  options?: TAlias extends IntrinsicTypeName
+    ? IntrinsicDefinitions[TAlias]["options"]
+    : unknown;
+  validation?: SchemaValidationValue;
+  initialValue?: InitialValueProperty<any, any>;
+  preview?: PreviewConfig;
   components?: {
-    annotation?: ComponentType<any>
-    block?: ComponentType<any>
-    inlineBlock?: ComponentType<any>
-    diff?: ComponentType<any>
-    field?: ComponentType<any>
-    input?: ComponentType<any>
-    item?: ComponentType<any>
-    preview?: ComponentType<any>
-  }
+    annotation?: ComponentType<any>;
+    block?: ComponentType<any>;
+    inlineBlock?: ComponentType<any>;
+    diff?: ComponentType<any>;
+    field?: ComponentType<any>;
+    input?: ComponentType<any>;
+    item?: ComponentType<any>;
+    preview?: ComponentType<any>;
+  };
 }
 
 /**
@@ -2686,46 +2985,44 @@ declare interface TypeAliasDefinition<
  * @public
  */
 declare interface TypeReference {
-  type: string
-  name?: string
-  icon?: ComponentType | ReactNode
+  type: string;
+  name?: string;
+  icon?: ComponentType | ReactNode;
   options?: {
-    [key: string]: unknown
-  }
+    [key: string]: unknown;
+  };
 }
 
 export declare type UploadSession = {
-  _id: string
-  _type: 'sanity.asset.upload-session'
-  _createdAt: string
-  _updatedAt: string
-  _rev: string
-  title: string
-  assets?: Array<{
-    _ref: string
-    _type: 'reference'
-    _weak?: boolean
-    _key: string
-    [internalGroqTypeReferenceTo]?: 'sanity.asset'
-  }>
-  _system?: SanitySystem
-}
+  _id: string;
+  _type: "sanity.asset.upload-session";
+  _createdAt: string;
+  _updatedAt: string;
+  _rev: string;
+  title: string;
+  assets?: Array<
+    {
+      _key: string;
+    } & SanityAssetReference
+  >;
+  _system?: SanitySystem;
+};
 
 /** @public */
 declare interface UriValidationOptions {
-  scheme?: (string | RegExp) | Array<string | RegExp>
-  allowRelative?: boolean
-  relativeOnly?: boolean
-  allowCredentials?: boolean
+  scheme?: (string | RegExp) | Array<string | RegExp>;
+  allowRelative?: boolean;
+  relativeOnly?: boolean;
+  allowCredentials?: boolean;
 }
 
 /** @public */
 declare interface UrlDefinition extends BaseSchemaDefinition {
-  type: 'url'
-  options?: UrlOptions
-  placeholder?: string
-  validation?: ValidationBuilder<UrlRule, string>
-  initialValue?: InitialValueProperty<any, string>
+  type: "url";
+  options?: UrlOptions;
+  placeholder?: string;
+  validation?: ValidationBuilder<UrlRule, string>;
+  initialValue?: InitialValueProperty<any, string>;
 }
 
 /** @public */
@@ -2733,13 +3030,14 @@ declare interface UrlOptions extends BaseSchemaTypeOptions {}
 
 /** @public */
 declare interface UrlRule extends RuleDef<UrlRule, string> {
-  uri(options: UriValidationOptions): UrlRule
+  uri(options: UriValidationOptions): UrlRule;
 }
 
 /** @public */
-declare type ValidationBuilder<T extends RuleDef<T, FieldValue>, FieldValue = unknown> = (
-  rule: T,
-) => RuleBuilder<T, FieldValue>
+declare type ValidationBuilder<
+  T extends RuleDef<T, FieldValue>,
+  FieldValue = unknown,
+> = (rule: T, context?: ValidationContext) => RuleBuilder<T, FieldValue>;
 
 /**
  * A context object passed around during validation. This includes the
@@ -2756,14 +3054,18 @@ declare type ValidationBuilder<T extends RuleDef<T, FieldValue>, FieldValue = un
  * @public
  */
 declare interface ValidationContext {
-  getClient: (options: {apiVersion: string}) => SanityClient
-  schema: Schema
-  parent?: unknown
-  type?: SchemaType
-  document?: SanityDocument
-  path?: Path
-  getDocumentExists?: (options: {id: string}) => Promise<boolean>
-  environment: 'cli' | 'studio'
+  getClient: (options: { apiVersion: string }) => SanityClient;
+  schema: Schema;
+  parent?: unknown;
+  type?: SchemaType;
+  document?: SanityDocument;
+  path?: Path;
+  getDocumentExists?: (options: { id: string }) => Promise<boolean>;
+  environment: "cli" | "studio";
+  /**
+   * Whether this field is hidden for any reason (either itself or any of its ancestors).
+   */
+  hidden?: boolean;
 }
 
 /**
@@ -2779,7 +3081,7 @@ declare interface ValidationError {
    * The message describing why the value is not valid. This message will be
    * included in the validation markers after validation has finished running.
    */
-  message: string
+  message: string;
   /**
    * If writing a custom validator, you can return validation messages to
    * specific path inside of the current value (object or array) by populating
@@ -2788,14 +3090,14 @@ declare interface ValidationError {
    * NOTE: This path is relative to the current value and _not_ relative to
    * the document.
    */
-  path?: Path
+  path?: Path;
   /**
    * Extra metadata for the validation error. Currently used by the Media Library asset source to ignore
    * certain validation markers when validating asset source media library assets.
    *
    * @internal
    */
-  __internal_metadata?: unknown
+  __internal_metadata?: unknown;
   /**
    * Same as `path` but allows more than one value. If provided, the same
    * message will create two markers from each path with the same message
@@ -2803,32 +3105,32 @@ declare interface ValidationError {
    *
    * @deprecated prefer `path`
    */
-  paths?: Path[]
+  paths?: Path[];
   /**
    * @deprecated Unused. Was used to store the results from `.either()` /`.all()`
    */
-  children?: ValidationMarker[]
+  children?: ValidationMarker[];
   /**
    * @deprecated Unused. Was used to signal if this error came from an `.either()`/`.all()`.
    */
-  operation?: 'AND' | 'OR'
+  operation?: "AND" | "OR";
   /**
    * @deprecated Unused. Was relevant when validation error was used as a class.
    */
-  cloneWithMessage?(message: string): ValidationError
+  cloneWithMessage?(message: string): ValidationError;
 }
 
 /** @public */
 declare interface ValidationMarker {
-  level: 'error' | 'warning' | 'info'
+  level: "error" | "warning" | "info";
   /**
    * The validation message for this marker. E.g. "Must be greater than 0"
    */
-  message: string
+  message: string;
   /**
    * @deprecated use `message` instead
    */
-  item?: ValidationError
+  item?: ValidationError;
   /**
    * The sanity path _relative to the root of the current document_ to this
    * marker.
@@ -2836,14 +3138,14 @@ declare interface ValidationMarker {
    * NOTE: Sanity paths may contain keyed segments (i.e. `{_key: string}`) that
    * are not compatible with deep getters like lodash/get
    */
-  path: Path
+  path: Path;
   /**
    * Extra metadata for the validation marker. Currently used by the Media Library asset source to ignore
    * certain validation markers when validating asset source media library assets.
    *
    * @internal
    */
-  __internal_metadata?: unknown
+  __internal_metadata?: unknown;
 }
 
-export {}
+export {};