@sanity/types 5.8.0 → 5.8.1-next.1

package/lib/index.d.ts

@@ -1,11 +1,11 @@
-import {Asset as Asset_2} from '@sanity/media-library-types'
-import {AssetInstanceDocument} 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_2 } from "@sanity/media-library-types";
+import { AssetInstanceDocument } 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,157 +15,161 @@ export 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 */
 export 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 */
-export declare type ArrayOfEntry<T> = Omit<T, 'name' | 'hidden'> & {
-  name?: string
-}
+export declare type ArrayOfEntry<T> = Omit<T, "name" | "hidden"> & {
+  name?: string;
+};
 
 /** @public */
 export declare type ArrayOfType<
   TType extends IntrinsicTypeName = IntrinsicTypeName,
   TAlias extends IntrinsicTypeName | undefined = undefined,
-> = IntrinsicArrayOfDefinition[TType] | ArrayOfEntry<TypeAliasDefinition<string, TAlias>>
+> =
+  | IntrinsicArrayOfDefinition[TType]
+  | ArrayOfEntry<TypeAliasDefinition<string, TAlias>>;
 
 /** @public */
 export declare interface ArrayOptions<V = unknown>
   extends SearchConfiguration, BaseSchemaTypeOptions {
-  list?: TitledListValue<V>[] | V[]
-  layout?: 'list' | 'tags' | 'grid'
+  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 */
-export 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>
+export 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>;
 }
 
 /** @public */
 export 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";
+  };
 }
 
 /** @internal */
-export declare type ArraySchemaTypeOf<TSchemaType extends ArraySchemaType['of'][number]> = Omit<
-  ArraySchemaType,
-  'of'
-> & {
-  of: TSchemaType[]
-}
+export declare type ArraySchemaTypeOf<
+  TSchemaType extends ArraySchemaType["of"][number],
+> = Omit<ArraySchemaType, "of"> & {
+  of: TSchemaType[];
+};
 
 /** @public */
 export declare interface Asset 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;
 }
 
 /** @public */
 export 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;
+  };
+};
 
 /** @public */
 export declare type AssetMetadataType =
-  | 'location'
-  | 'exif'
-  | 'image'
-  | 'palette'
-  | 'lqip'
-  | 'blurhash'
-  | 'thumbhash'
-  | 'none'
+  | "location"
+  | "exif"
+  | "image"
+  | "palette"
+  | "lqip"
+  | "blurhash"
+  | "thumbhash"
+  | "none";
 
 /** @public */
 export declare interface AssetSchemaTypeOptions {
-  accept?: string
-  storeOriginalFilename?: boolean
+  accept?: string;
+  storeOriginalFilename?: boolean;
 }
 
 /** @public */
 export declare interface AssetSource {
-  name: string
+  name: string;
   /** @deprecated provide `i18nKey` instead */
-  title?: string
-  i18nKey?: string
-  component: ComponentType<AssetSourceComponentProps>
-  icon?: ComponentType
+  title?: string;
+  i18nKey?: string;
+  component: ComponentType<AssetSourceComponentProps>;
+  icon?: ComponentType;
   /** @beta */
-  Uploader?: AssetSourceUploaderClass
+  Uploader?: AssetSourceUploaderClass;
   /**
    * Resolve how to open an asset in its original source.
    *
@@ -180,32 +184,35 @@ export declare interface AssetSource {
    *
    * @beta
    */
-  openInSource?: (asset: Asset) => AssetSourceOpenInSourceResult
+  openInSource?: (asset: Asset) => AssetSourceOpenInSourceResult;
 }
 
 /** @public */
-export declare type AssetSourceComponentAction = 'select' | 'upload' | 'openInSource'
+export declare type AssetSourceComponentAction =
+  | "select"
+  | "upload"
+  | "openInSource";
 
 /** @public */
 export declare interface AssetSourceComponentProps {
-  action?: AssetSourceComponentAction
-  assetSource: AssetSource
-  assetType?: 'file' | 'image' | 'sanity.video'
-  accept: string
-  selectionType: 'single'
-  dialogHeaderTitle?: React.ReactNode
-  selectedAssets: Asset[]
-  onClose: () => void
-  onSelect: (assetFromSource: AssetFromSource[]) => void
-  onChangeAction?: (action: AssetSourceComponentAction) => void
-  schemaType?: ImageSchemaType | FileSchemaType
+  action?: AssetSourceComponentAction;
+  assetSource: AssetSource;
+  assetType?: "file" | "image" | "sanity.video";
+  accept: string;
+  selectionType: "single";
+  dialogHeaderTitle?: React.ReactNode;
+  selectedAssets: Asset[];
+  onClose: () => void;
+  onSelect: (assetFromSource: AssetFromSource[]) => void;
+  onChangeAction?: (action: AssetSourceComponentAction) => void;
+  schemaType?: ImageSchemaType | FileSchemaType;
   /** @beta */
-  uploader?: AssetSourceUploader
+  uploader?: AssetSourceUploader;
   /**
    * The asset to open in source. Only provided when action is 'openInSource'.
    * @beta
    */
-  assetToOpen?: Asset
+  assetToOpen?: Asset;
 }
 
 /**
@@ -214,21 +221,21 @@ export declare interface AssetSourceComponentProps {
  */
 export declare type AssetSourceOpenInSourceResult =
   | {
-      type: 'url'
-      url: string
-      target?: '_blank' | '_self'
+      type: "url";
+      url: string;
+      target?: "_blank" | "_self";
     }
   | {
-      type: 'component'
+      type: "component";
     }
   | false
-  | undefined
+  | undefined;
 
 /** @public */
 export declare interface AssetSourceSpec {
-  id: string
-  name: string
-  url?: string
+  id: string;
+  name: string;
+  url?: string;
 }
 
 /** @beta */
@@ -240,45 +247,47 @@ export 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 */
-export declare type AssetSourceUploaderClass = new (...args: any[]) => AssetSourceUploader
+export declare type AssetSourceUploaderClass = new (
+  ...args: any[]
+) => AssetSourceUploader;
 
 /** @beta */
 export declare type AssetSourceUploadEvent =
@@ -286,68 +295,76 @@ export declare type AssetSourceUploadEvent =
   | AssetSourceUploadEventStatus
   | AssetSourceUploadEventAllComplete
   | AssetSourceUploadEventError
-  | AssetSourceUploadEventAbort
+  | AssetSourceUploadEventAbort;
 
 /**
  * Emitted when all files are done, either successfully, aborted or with errors
  * @beta */
 export 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 */
 export 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 */
 export declare type AssetSourceUploadEventError = {
-  type: 'error'
+  type: "error";
   /**
    * Files errored
    */
-  files: AssetSourceUploadFile[]
-}
+  files: AssetSourceUploadFile[];
+};
 
 /**
  * Emitted when a file upload is progressing
  * @beta */
 export declare type AssetSourceUploadEventProgress = {
-  type: 'progress'
-  file: AssetSourceUploadFile
-  progress: number
-}
+  type: "progress";
+  file: AssetSourceUploadFile;
+  progress: number;
+};
 
 /**
  * Emitted when a file upload is changing status
  * @beta */
 export declare type AssetSourceUploadEventStatus = {
-  type: 'status'
-  file: AssetSourceUploadFile
-  status: AssetSourceUploadFile['status']
-}
+  type: "status";
+  file: AssetSourceUploadFile;
+  status: AssetSourceUploadFile["status"];
+};
 
 /** @beta */
 export 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;
 }
 
 /** @beta */
-export declare type AssetSourceUploadSubscriber = (event: AssetSourceUploadEvent) => void
+export declare type AssetSourceUploadSubscriber = (
+  event: AssetSourceUploadEvent,
+) => void;
 
 /**
  * Enhances VSCode autocomplete by using a distinct type for strings.
@@ -361,52 +378,52 @@ export declare type AssetSourceUploadSubscriber = (event: AssetSourceUploadEvent
  *
  * @beta
  */
-export declare type AutocompleteString = string & {}
+export declare type AutocompleteString = string & {};
 
 /** @public */
 export 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 */
 export 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;
 }
 
 /**
@@ -417,8 +434,8 @@ export declare interface BaseSchemaType extends Partial<DeprecationConfiguration
  *  @public
  *  */
 export declare interface BaseSchemaTypeOptions {
-  sanityCreate?: SanityCreateOptions
-  canvasApp?: CanvasAppOptions
+  sanityCreate?: SanityCreateOptions;
+  canvasApp?: CanvasAppOptions;
 }
 
 /**
@@ -454,7 +471,7 @@ export declare interface BaseSchemaTypeOptions {
  * ```
  */
 export declare interface BlockAnnotationDefinition extends ObjectDefinition {
-  icon?: ReactNode | ComponentType
+  icon?: ReactNode | ComponentType;
 }
 
 /**
@@ -464,8 +481,8 @@ export declare interface BlockAnnotationDefinition extends ObjectDefinition {
  * @internal
  */
 export declare type BlockChildrenObjectField = {
-  name: 'children'
-} & ObjectField<ArraySchemaType>
+  name: "children";
+} & ObjectField<ArraySchemaType>;
 
 /**
  * Schema definition for text block decorators.
@@ -495,10 +512,10 @@ export declare type BlockChildrenObjectField = {
  * ```
  */
 export declare interface BlockDecoratorDefinition {
-  title: string
-  i18nTitleKey?: string
-  value: string
-  icon?: ReactNode | ComponentType
+  title: string;
+  i18nTitleKey?: string;
+  value: string;
+  icon?: ReactNode | ComponentType;
 }
 
 /**
@@ -555,14 +572,14 @@ export declare interface BlockDecoratorDefinition {
  * ```
  */
 export 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[]>;
 }
 
 /**
@@ -588,10 +605,10 @@ export declare interface BlockDefinition extends BaseSchemaDefinition {
  * ```
  */
 export declare interface BlockListDefinition {
-  title: string
-  i18nTitleKey?: string
-  value: string
-  icon?: ReactNode | ComponentType
+  title: string;
+  i18nTitleKey?: string;
+  value: string;
+  icon?: ReactNode | ComponentType;
 }
 
 /**
@@ -601,16 +618,16 @@ export declare interface BlockListDefinition {
  * @internal
  */
 export declare type BlockListObjectField = {
-  name: 'list'
-} & ObjectField<StringSchemaType>
+  name: "list";
+} & ObjectField<StringSchemaType>;
 
 /**
  * Schema definition for text block marks (decorators and annotations).
  *
  * @public */
 export declare interface BlockMarksDefinition {
-  decorators?: BlockDecoratorDefinition[]
-  annotations?: ArrayOfType<'object' | 'reference'>[]
+  decorators?: BlockDecoratorDefinition[];
+  annotations?: ArrayOfType<"object" | "reference">[];
 }
 
 /**
@@ -620,8 +637,8 @@ export 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
@@ -631,7 +648,7 @@ export declare interface BlockOptions extends BaseSchemaTypeOptions {
    *
    * @defaultValue false
    */
-  oneLine?: boolean
+  oneLine?: boolean;
 }
 
 /** @public */
@@ -645,8 +662,13 @@ export declare interface BlockRule extends RuleDef<BlockRule, any[]> {}
  * @internal
  */
 export declare interface BlockSchemaType extends ObjectSchemaType {
-  fields: [BlockChildrenObjectField, BlockStyleObjectField, BlockListObjectField, ...ObjectField[]]
-  options?: BlockOptions
+  fields: [
+    BlockChildrenObjectField,
+    BlockStyleObjectField,
+    BlockListObjectField,
+    ...ObjectField[],
+  ];
+  options?: BlockOptions;
 }
 
 /**
@@ -704,10 +726,10 @@ export declare interface BlockSchemaType extends ObjectSchemaType {
  * ```
  */
 export declare interface BlockStyleDefinition {
-  title: string
-  value: string
-  i18nTitleKey?: string
-  icon?: ReactNode | ComponentType
+  title: string;
+  value: string;
+  i18nTitleKey?: string;
+  icon?: ReactNode | ComponentType;
 }
 
 /**
@@ -717,20 +739,20 @@ export declare interface BlockStyleDefinition {
  * @internal
  */
 export declare type BlockStyleObjectField = {
-  name: 'style'
-} & ObjectField<StringSchemaType>
+  name: "style";
+} & ObjectField<StringSchemaType>;
 
 /** @public */
 export 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 */
 export declare interface BooleanOptions extends BaseSchemaTypeOptions {
-  layout?: 'switch' | 'checkbox'
+  layout?: "switch" | "checkbox";
 }
 
 /** @public */
@@ -738,9 +760,9 @@ export declare interface BooleanRule extends RuleDef<BooleanRule, boolean> {}
 
 /** @public */
 export declare interface BooleanSchemaType extends BaseSchemaType {
-  jsonType: 'boolean'
-  options?: BooleanOptions
-  initialValue?: InitialValueProperty<any, boolean>
+  jsonType: "boolean";
+  options?: BooleanOptions;
+  initialValue?: InitialValueProperty<any, boolean>;
 }
 
 /**
@@ -750,12 +772,12 @@ export declare interface BooleanSchemaType extends BaseSchemaType {
  */
 export 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;
 }
 
 /**
@@ -763,21 +785,21 @@ export declare interface CanvasAppOptions {
  * Payload that will be passed by canvas to our notifications system to display the notification in canvas.
  * */
 export declare interface CanvasNotificationPayload extends DashboardNotificationPayload {
-  applicationType: 'canvas'
+  applicationType: "canvas";
   link: {
-    type: 'dashboard'
-    path: string
-  }
+    type: "dashboard";
+    path: string;
+  };
 }
 
 /** @public */
 export declare interface CollapseOptions {
-  collapsed?: boolean
-  collapsible?: boolean
+  collapsed?: boolean;
+  collapsible?: boolean;
   /**
    * @deprecated Use `collapsible` instead
    */
-  collapsable?: boolean
+  collapsable?: boolean;
 }
 
 /**
@@ -786,50 +808,55 @@ export declare interface CollapseOptions {
  *
  * @internal
  */
-export declare type ConditionalIndexAccess<T, U> = U extends keyof T ? T[U] : undefined
+export declare type ConditionalIndexAccess<T, U> = U extends keyof T
+  ? T[U]
+  : undefined;
 
 /** @public */
-export declare type ConditionalProperty = boolean | ConditionalPropertyCallback | undefined
+export declare type ConditionalProperty =
+  | boolean
+  | ConditionalPropertyCallback
+  | undefined;
 
 /** @public */
 export declare type ConditionalPropertyCallback = (
   context: ConditionalPropertyCallbackContext,
-) => boolean
+) => boolean;
 
 /** @public */
 export declare interface ConditionalPropertyCallbackContext {
-  document: SanityDocument | undefined
-  parent: any
-  value: any
-  currentUser: Omit<CurrentUser, 'role'> | null
-  path: Path
+  document: SanityDocument | undefined;
+  parent: any;
+  value: any;
+  currentUser: Omit<CurrentUser, "role"> | null;
+  path: Path;
 }
 
 /** @internal */
 export declare interface CreateIfNotExistsMutation {
   createIfNotExists: {
-    _id: string
-    _type: string
-    [key: string]: unknown
-  }
+    _id: string;
+    _type: string;
+    [key: string]: unknown;
+  };
 }
 
 /** @internal */
 export declare interface CreateMutation {
   create: {
-    _id?: string
-    _type: string
-    [key: string]: unknown
-  }
+    _id?: string;
+    _type: string;
+    [key: string]: unknown;
+  };
 }
 
 /** @internal */
 export declare interface CreateOrReplaceMutation {
   createOrReplace: {
-    _id: string
-    _type: string
-    [key: string]: unknown
-  }
+    _id: string;
+    _type: string;
+    [key: string]: unknown;
+  };
 }
 
 /**
@@ -844,114 +871,122 @@ export declare interface CreateSquashedMutation {
     /**
      * The user IDs of all the users who contributed to the document prior to the squashing
      */
-    authors: string[]
+    authors: string[];
     /**
      * User ID of the person who initially created the document
      */
-    createdBy: string
+    createdBy: string;
     /**
      * ISO-formatted timestamp (zulu-time) of when the document as initially created
      */
-    createdAt: string
+    createdAt: string;
     /**
      * The document as it exists after squashing has occurred
      */
     document: {
-      _id: string
-      _type: string
-      [key: string]: unknown
-    }
-  }
+      _id: string;
+      _type: string;
+      [key: string]: unknown;
+    };
+  };
 }
 
 /** @public */
 export 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;
 }
 
 /** @beta */
 export declare type CrossDatasetReferenceFilterResolver = (options: {
-  document: SanityDocument
-  parent?: Record<string, unknown> | Record<string, unknown>[]
-  parentPath: Path
-}) => CrossDatasetReferenceFilterSearchOptions | Promise<CrossDatasetReferenceFilterSearchOptions>
+  document: SanityDocument;
+  parent?: Record<string, unknown> | Record<string, unknown>[];
+  parentPath: Path;
+}) =>
+  | CrossDatasetReferenceFilterSearchOptions
+  | Promise<CrossDatasetReferenceFilterSearchOptions>;
 
 /** @beta */
 export declare type CrossDatasetReferenceFilterSearchOptions = {
-  filter?: string
-  params?: Record<string, unknown>
-  tag?: string
-}
+  filter?: string;
+  params?: Record<string, unknown>;
+  tag?: string;
+};
 
 /** @beta */
-export declare interface CrossDatasetReferenceSchemaType extends Omit<ObjectSchemaType, 'options'> {
-  jsonType: 'object'
-  to: CrossDatasetType[]
-  dataset: string
-  studioUrl?: (document: {id: string; type?: string}) => string | null
-  weak?: boolean
-  options?: ReferenceFilterOptions
+export declare interface CrossDatasetReferenceSchemaType extends Omit<
+  ObjectSchemaType,
+  "options"
+> {
+  jsonType: "object";
+  to: CrossDatasetType[];
+  dataset: string;
+  studioUrl?: (document: { id: string; type?: string }) => string | null;
+  weak?: boolean;
+  options?: ReferenceFilterOptions;
 }
 
 /** @beta */
 export declare interface CrossDatasetReferenceValue {
-  _type: string
-  _dataset: string
-  _projectId: string
-  _ref: string
-  _key?: string
-  _weak?: boolean
+  _type: string;
+  _dataset: string;
+  _projectId: string;
+  _ref: string;
+  _key?: string;
+  _weak?: boolean;
 }
 
 /** @beta */
 export declare interface CrossDatasetType {
-  type: string
-  title?: string
-  icon: ComponentType
-  preview: PreviewConfig
+  type: string;
+  title?: string;
+  icon: ComponentType;
+  preview: PreviewConfig;
   /** @deprecated Unused. Configuring search is no longer supported for cross-dataset references. */
-  __experimental_search?: ObjectSchemaType['__experimental_search']
+  __experimental_search?: ObjectSchemaType["__experimental_search"];
 }
 
 /** @public */
 export 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 */
 export declare interface CustomValidator<T = unknown> {
-  (value: T, context: ValidationContext): CustomValidatorResult | Promise<CustomValidatorResult>
-  bypassConcurrencyLimit?: boolean
+  (
+    value: T,
+    context: ValidationContext,
+  ): CustomValidatorResult | Promise<CustomValidatorResult>;
+  bypassConcurrencyLimit?: boolean;
 }
 
 /** @public */
@@ -960,48 +995,48 @@ export declare type CustomValidatorResult =
   | string
   | ValidationError
   | ValidationError[]
-  | LocalizedValidationMessages
+  | LocalizedValidationMessages;
 
 /**
  * @internal
  * Payload notifications have to provide to the notification system in order to display correctly in dashboard
  */
 export declare interface DashboardNotificationPayload {
-  version: '1.0.0'
-  applicationType: string
-  createdAt: string
+  version: "1.0.0";
+  applicationType: string;
+  createdAt: string;
   /**
    * The user who took the action which triggered the notification.
    */
-  actor: User
-  title: PortableTextBlock[]
-  body: PortableTextBlock[] | undefined
-  organizationId: string
-  applicationId?: string
-  workspaceName?: string
+  actor: User;
+  title: PortableTextBlock[];
+  body: PortableTextBlock[] | undefined;
+  organizationId: string;
+  applicationId?: string;
+  workspaceName?: string;
   link:
     | {
-        type: 'url'
-        url: string
+        type: "url";
+        url: string;
       }
     | {
-        type: 'dashboard'
-        path: string
-      }
+        type: "dashboard";
+        path: string;
+      };
 }
 
 /** @public */
 export 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 */
 export declare interface DateOptions extends BaseSchemaTypeOptions {
-  dateFormat?: string
+  dateFormat?: string;
 }
 
 /** @public */
@@ -1009,29 +1044,29 @@ export 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 */
 export 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 */
 export 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 */
@@ -1039,11 +1074,11 @@ export 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;
 }
 
 /**
@@ -1075,19 +1110,19 @@ export declare function defineArrayMember<
   TStrict extends StrictDefinition,
 >(
   arrayOfSchema: {
-    type: TType
+    type: TType;
     /**
      * When provided, `name` is used as `_type` for the array item when stored.
      *
      * Necessary when an array contains multiple entries with the same `type`, each with
      * different configuration (title and initialValue for instance).
      */
-    name?: TName
+    name?: TName;
   } & DefineArrayMemberBase<TType, TAlias> &
     NarrowPreview<TType, TAlias, TSelect, TPrepareValue> &
     MaybeAllowUnknownProps<TStrict>,
   defineOptions?: DefineSchemaOptions<TStrict, TAlias>,
-): typeof arrayOfSchema & WidenValidation & WidenInitialValue
+): typeof arrayOfSchema & WidenValidation & WidenInitialValue;
 
 /** @beta */
 export declare type DefineArrayMemberBase<
@@ -1095,7 +1130,7 @@ export declare type DefineArrayMemberBase<
   TAlias extends IntrinsicTypeName | undefined,
 > = TType extends IntrinsicTypeName
   ? IntrinsicArrayOfBase[TType]
-  : ArrayOfEntry<TypeAliasDefinition<string, TAlias>>
+  : ArrayOfEntry<TypeAliasDefinition<string, TAlias>>;
 
 /**
  * Define a Media Library asset aspect.
@@ -1107,7 +1142,7 @@ export declare type DefineArrayMemberBase<
  */
 export declare function defineAssetAspect(
   definition: MediaLibraryAssetAspectDefinition,
-): MediaLibraryAssetAspectDocument
+): MediaLibraryAssetAspectDocument;
 
 /**
  * Define a field within a document, object, image or file definition `fields` array.
@@ -1138,20 +1173,22 @@ export declare function defineField<
   TStrict extends StrictDefinition,
 >(
   schemaField: {
-    type: TType
-    name: TName
+    type: TType;
+    name: TName;
   } & DefineSchemaBase<TType, TAlias> &
     NarrowPreview<TType, TAlias, TSelect, TPrepareValue> &
     MaybeAllowUnknownProps<TStrict> &
     FieldDefinitionBase,
   defineOptions?: DefineSchemaOptions<TStrict, TAlias>,
-): typeof schemaField & WidenValidation & WidenInitialValue
+): typeof schemaField & WidenValidation & WidenInitialValue;
 
 /** @beta */
 export declare type DefineSchemaBase<
   TType extends string,
   TAlias extends IntrinsicTypeName | undefined,
-> = TType extends IntrinsicTypeName ? IntrinsicBase[TType] : TypeAliasDefinition<TType, TAlias>
+> = TType extends IntrinsicTypeName
+  ? IntrinsicBase[TType]
+  : TypeAliasDefinition<TType, TAlias>;
 
 /** @beta */
 export declare interface DefineSchemaOptions<
@@ -1169,9 +1206,9 @@ export declare interface DefineSchemaOptions<
    *
    * @see defineType
    */
-  strict?: TStrict
+  strict?: TStrict;
   /** Should be provided when type is a non-intrinsic type, ie type is a type alias */
-  aliasFor?: TAlias extends IntrinsicTypeName ? TAlias : never
+  aliasFor?: TAlias extends IntrinsicTypeName ? TAlias : never;
 }
 
 /** @beta */
@@ -1180,7 +1217,7 @@ export declare type DefineSchemaType<
   TAlias extends IntrinsicTypeName | undefined,
 > = TType extends IntrinsicTypeName
   ? IntrinsicDefinitions[TType]
-  : TypeAliasDefinition<TType, TAlias>
+  : TypeAliasDefinition<TType, TAlias>;
 
 /**
  * Helper function for defining a Sanity type definition. This function does not do anything on its own;
@@ -1350,57 +1387,61 @@ export declare function defineType<
   TStrict extends StrictDefinition,
 >(
   schemaDefinition: {
-    type: TType
-    name: TName
+    type: TType;
+    name: TName;
   } & DefineSchemaBase<TType, TAlias> &
     NarrowPreview<TType, TAlias, TSelect, TPrepareValue> &
     MaybeAllowUnknownProps<TStrict>,
   defineOptions?: DefineSchemaOptions<TStrict, TAlias>,
-): typeof schemaDefinition
+): typeof schemaDefinition;
 
 /** @internal */
 export declare interface DeleteMutation {
-  delete: MutationSelection
+  delete: MutationSelection;
 }
 
 /** @public */
 export declare interface DeprecatedProperty {
-  reason: string
+  reason: string;
 }
 
 /** @public */
-export declare type DeprecatedSchemaType<TSchemaType extends BaseSchemaType = BaseSchemaType> =
-  TSchemaType & DeprecationConfiguration
+export declare type DeprecatedSchemaType<
+  TSchemaType extends BaseSchemaType = BaseSchemaType,
+> = TSchemaType & DeprecationConfiguration;
 
 /**
  * @public
  */
 export declare interface DeprecationConfiguration {
-  deprecated: DeprecatedProperty
+  deprecated: DeprecatedProperty;
 }
 
 /** @public */
-export declare interface DocumentDefinition extends Omit<ObjectDefinition, 'type'> {
-  type: 'document'
-  liveEdit?: boolean
+export 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;
 }
 
 /**
@@ -1411,15 +1452,18 @@ export declare interface DocumentDefinition extends Omit<ObjectDefinition, 'type
 export declare interface DocumentOptions extends BaseSchemaTypeOptions {}
 
 /** @public */
-export declare interface DocumentRule extends RuleDef<DocumentRule, SanityDocument> {}
+export declare interface DocumentRule extends RuleDef<
+  DocumentRule,
+  SanityDocument
+> {}
 
 /** @public */
 export 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 */
@@ -1433,9 +1477,9 @@ export declare interface EmptyProps {}
 
 /** @public */
 export 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";
 }
 
 /**
@@ -1453,35 +1497,36 @@ export declare interface EnumListProps<V = unknown> {
 export declare type FieldDefinition<
   TType extends IntrinsicTypeName = IntrinsicTypeName,
   TAlias extends IntrinsicTypeName | undefined = undefined,
-> = (InlineFieldDefinition[TType] | TypeAliasDefinition<string, TAlias>) & FieldDefinitionBase
+> = (InlineFieldDefinition[TType] | TypeAliasDefinition<string, TAlias>) &
+  FieldDefinitionBase;
 
 /** @public */
 export declare interface FieldDefinitionBase {
-  fieldset?: string
-  group?: string | string[]
+  fieldset?: string;
+  group?: string | string[];
 }
 
 /** @public */
 export 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 */
 export 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
@@ -1490,65 +1535,65 @@ export declare type FieldGroupDefinition = {
  * @public
  */
 export declare interface FieldReference {
-  type: symbol
-  path: string | string[]
+  type: symbol;
+  path: string | string[];
 }
 
 /** @public */
 export declare type FieldRules = {
-  [fieldKey: string]: SchemaValidationValue
-}
+  [fieldKey: string]: SchemaValidationValue;
+};
 
 /** @public */
-export declare type Fieldset = SingleFieldSet | MultiFieldSet
+export declare type Fieldset = SingleFieldSet | MultiFieldSet;
 
 /** @public */
 export declare interface FieldsetDefinition {
-  name: string
-  title?: string
-  description?: string
-  group?: string
-  hidden?: ConditionalProperty
-  readOnly?: ConditionalProperty
-  options?: ObjectOptions
+  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;
 }
-export {File_2 as File}
+export { File_2 as File };
 
 /** @public */
 export declare interface FileAsset extends Asset {
-  _type: 'sanity.fileAsset'
-  metadata: Record<string, unknown>
+  _type: "sanity.fileAsset";
+  metadata: Record<string, unknown>;
 }
 
 /** @public */
 export 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 */
 export 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
+  disableNew?: boolean;
 }
 
 /** @public */
@@ -1566,40 +1611,46 @@ export declare interface FileRule extends RuleDef<FileRule, FileValue> {
    * })
    * ```
    */
-  assetRequired(): FileRule
+  assetRequired(): FileRule;
 }
 
 /** @public */
-export declare interface FileSchemaType extends Omit<ObjectSchemaType, 'options'> {
-  options?: FileOptions
+export declare interface FileSchemaType extends Omit<
+  ObjectSchemaType,
+  "options"
+> {
+  options?: FileOptions;
 }
 
 /** @public */
 export declare interface FileValue {
-  asset?: Reference
-  [index: string]: unknown
+  asset?: Reference;
+  [index: string]: unknown;
 }
 
 /** @public */
 export declare interface FormNodeValidation {
-  level: 'error' | 'warning' | 'info'
-  message: string
-  path: Path
+  level: "error" | "warning" | "info";
+  message: string;
+  path: Path;
 }
 
 /** @public */
 export 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 */
 export declare interface GeopointOptions extends BaseSchemaTypeOptions {}
 
 /** @public */
-export declare interface GeopointRule extends RuleDef<GeopointRule, GeopointValue> {}
+export declare interface GeopointRule extends RuleDef<
+  GeopointRule,
+  GeopointValue
+> {}
 
 /**
  * Geographical point representing a pair of latitude and longitude coordinates,
@@ -1612,209 +1663,213 @@ export 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 */
 export 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);
 }
 
 /** @beta */
 export declare type GlobalDocumentReferenceFilterResolver = (options: {
-  document: SanityDocument
-  parent?: Record<string, unknown> | Record<string, unknown>[]
-  parentPath: Path
+  document: SanityDocument;
+  parent?: Record<string, unknown> | Record<string, unknown>[];
+  parentPath: Path;
 }) =>
   | GlobalDocumentReferenceFilterSearchOptions
-  | Promise<GlobalDocumentReferenceFilterSearchOptions>
+  | Promise<GlobalDocumentReferenceFilterSearchOptions>;
 
 /** @beta */
 export declare type GlobalDocumentReferenceFilterSearchOptions = {
-  filter?: string
-  params?: Record<string, unknown>
-  tag?: string
-}
+  filter?: string;
+  params?: Record<string, unknown>;
+  tag?: string;
+};
 
 /** @beta */
 export declare interface GlobalDocumentReferenceSchemaType extends Omit<
   ObjectSchemaType,
-  'options'
+  "options"
 > {
-  jsonType: 'object'
-  to: GlobalDocumentReferenceType[]
-  resourceType: string
-  resourceId: string
-  studioUrl?: string | ((document: {id: string; type?: string}) => string | null)
-  weak?: boolean
-  options?: ReferenceFilterOptions
+  jsonType: "object";
+  to: GlobalDocumentReferenceType[];
+  resourceType: string;
+  resourceId: string;
+  studioUrl?:
+    | string
+    | ((document: { id: string; type?: string }) => string | null);
+  weak?: boolean;
+  options?: ReferenceFilterOptions;
 }
 
 /** @beta */
 export declare interface GlobalDocumentReferenceType {
-  type: string
-  title?: string
-  icon: ComponentType
-  preview: PreviewConfig
+  type: string;
+  title?: string;
+  icon: ComponentType;
+  preview: PreviewConfig;
   /** @deprecated Unused. It's only here for the type to be compatible with createSearchQuery.ts */
-  __experimental_search: never
+  __experimental_search: never;
 }
 
 /** @beta */
 export declare interface GlobalDocumentReferenceValue {
-  _type: string
+  _type: string;
   /** The reference to the document. This is a string of the form `a:b:c`,
    * where:
    * - `a` is the resource type, for example `dataset` or `media-library`
    * - `b` is the resource ID, for example data set name or media library ID
    * - `c` is the document ID */
-  _ref: `${string}:${string}:${string}`
-  _key?: string
-  _weak?: boolean
+  _ref: `${string}:${string}:${string}`;
+  _key?: string;
+  _weak?: boolean;
 }
 
 /** @public */
 export declare interface HotspotOptions {
-  previews?: HotspotPreview[]
+  previews?: HotspotPreview[];
 }
 
 /** @public */
 export declare interface HotspotPreview {
-  title: string
-  aspectRatio: number
+  title: string;
+  aspectRatio: number;
 }
 
 /** @public */
 export declare type I18nTextRecord<K extends string> = {
   [P in K]?: {
-    key: string
-    ns: string
-  }
-}
+    key: string;
+    ns: string;
+  };
+};
 
 /** @public */
 export declare interface I18nTitledListValue<V = unknown> {
-  _key?: string
-  title: string
-  i18nTitleKey?: string
-  value?: V
+  _key?: string;
+  title: string;
+  i18nTitleKey?: string;
+  value?: V;
 }
 
 /** @public */
 declare interface Image_2 {
-  [key: string]: unknown
-  asset?: Reference
-  crop?: ImageCrop
-  hotspot?: ImageHotspot
+  [key: string]: unknown;
+  asset?: Reference;
+  crop?: ImageCrop;
+  hotspot?: ImageHotspot;
 }
-export {Image_2 as Image}
+export { Image_2 as Image };
 
 /** @public */
 export declare interface ImageAsset extends Asset {
-  _type: 'sanity.imageAsset'
-  metadata: ImageMetadata
+  _type: "sanity.imageAsset";
+  metadata: ImageMetadata;
 }
 
 /** @public */
 export 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 */
 export 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 */
 export declare interface ImageDimensions {
-  _type: 'sanity.imageDimensions'
-  height: number
-  width: number
-  aspectRatio: number
+  _type: "sanity.imageDimensions";
+  height: number;
+  width: number;
+  aspectRatio: number;
 }
 
 /** @public */
 export 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 */
 export declare interface ImageMetadata {
-  [key: string]: unknown
-  _type: 'sanity.imageMetadata'
-  dimensions: ImageDimensions
-  palette?: ImagePalette
-  lqip?: string
-  blurHash?: string
-  thumbHash?: 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 */
 export declare type ImageMetadataType =
-  | 'blurhash'
-  | 'thumbhash'
-  | 'lqip'
-  | 'palette'
-  | 'exif'
-  | 'image'
-  | 'location'
+  | "blurhash"
+  | "thumbhash"
+  | "lqip"
+  | "palette"
+  | "exif"
+  | "image"
+  | "location";
 
 /** @public */
 export declare interface ImageOptions extends FileOptions {
-  metadata?: ImageMetadataType[]
-  hotspot?: boolean | HotspotOptions
+  metadata?: ImageMetadataType[];
+  hotspot?: boolean | HotspotOptions;
 }
 
 /** @public */
 export 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 */
@@ -1832,44 +1887,54 @@ export declare interface ImageRule extends RuleDef<ImageRule, ImageValue> {
    * })
    * ```
    */
-  assetRequired(): ImageRule
+  assetRequired(): ImageRule;
 }
 
 /** @public */
-export declare interface ImageSchemaType extends Omit<ObjectSchemaType, 'options'> {
-  options?: ImageOptions
+export declare interface ImageSchemaType extends Omit<
+  ObjectSchemaType,
+  "options"
+> {
+  options?: ImageOptions;
 }
 
 /** @public */
 export 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;
 }
 
 /** @internal */
-export declare type ImageUrlAutoMode = 'format'
+export declare type ImageUrlAutoMode = "format";
 
 /** @internal */
 export declare type ImageUrlCropMode =
-  | 'top'
-  | 'bottom'
-  | 'left'
-  | 'right'
-  | 'center'
-  | 'focalpoint'
-  | 'entropy'
+  | "top"
+  | "bottom"
+  | "left"
+  | "right"
+  | "center"
+  | "focalpoint"
+  | "entropy";
 
 /** @internal */
-export declare type ImageUrlFitMode = 'clip' | 'crop' | 'fill' | 'fillmax' | 'max' | 'scale' | 'min'
+export declare type ImageUrlFitMode =
+  | "clip"
+  | "crop"
+  | "fill"
+  | "fillmax"
+  | "max"
+  | "scale"
+  | "min";
 
 /** @internal */
-export declare type ImageUrlFormat = 'jpg' | 'pjpg' | 'png' | 'webp'
+export declare type ImageUrlFormat = "jpg" | "pjpg" | "png" | "webp";
 
 /** @internal */
-export declare type ImageUrlOrientation = '0' | '90' | '180' | '270'
+export declare type ImageUrlOrientation = "0" | "90" | "180" | "270";
 
 /**
  * NOTE: These are query parameters, so they will eventually be encoded as strings.
@@ -1880,77 +1945,77 @@ export declare type ImageUrlOrientation = '0' | '90' | '180' | '270'
  * @internal
  */
 export declare interface ImageUrlParams {
-  'bg'?: string
-  'dpr'?: number | string
-  'w'?: number | string
-  'h'?: number | string
-  'q'?: number | string
-  'dl'?: string
-  'dlRaw'?: string
-  'fp-x'?: number | string
-  'fp-y'?: number | string
-  'max-w'?: number | string
-  'max-h'?: number | string
-  'min-w'?: number | string
-  'min-h'?: number | string
-  'blur'?: number | string
-  'sharp'?: number | string
-  'rect'?: string
-  'fm'?: ImageUrlFormat
-  'or'?: ImageUrlOrientation
-  'fit'?: ImageUrlFitMode
-  'crop'?: ImageUrlCropMode
-  'auto'?: ImageUrlAutoMode
-  'invert'?: 'true' | 'false'
-  'quality'?: number | string
-  'flip'?: 'h' | 'v' | 'hv'
-  'sat'?: number | string
-  'pad'?: number | string
-  'colorquant'?: number | string
-  'border'?: string
+  bg?: string;
+  dpr?: number | string;
+  w?: number | string;
+  h?: number | string;
+  q?: number | string;
+  dl?: string;
+  dlRaw?: string;
+  "fp-x"?: number | string;
+  "fp-y"?: number | string;
+  "max-w"?: number | string;
+  "max-h"?: number | string;
+  "min-w"?: number | string;
+  "min-h"?: number | string;
+  blur?: number | string;
+  sharp?: number | string;
+  rect?: string;
+  fm?: ImageUrlFormat;
+  or?: ImageUrlOrientation;
+  fit?: ImageUrlFitMode;
+  crop?: ImageUrlCropMode;
+  auto?: ImageUrlAutoMode;
+  invert?: "true" | "false";
+  quality?: number | string;
+  flip?: "h" | "v" | "hv";
+  sat?: number | string;
+  pad?: number | string;
+  colorquant?: number | string;
+  border?: string;
 }
 
 /** @public */
 export declare interface ImageValue extends FileValue {
-  crop?: ImageCrop
-  hotspot?: ImageHotspot
-  [index: string]: unknown
+  crop?: ImageCrop;
+  hotspot?: ImageHotspot;
+  [index: string]: unknown;
 }
 
 /** @public */
-export declare type IndexTuple = [number | '', number | '']
+export declare type IndexTuple = [number | "", number | ""];
 
 /** @public */
 export declare type InitialValueProperty<Params, Value> =
   | Value
   | InitialValueResolver<Params, Value>
-  | undefined
+  | undefined;
 
 /** @public */
 export declare type InitialValueResolver<Params, Value> = (
   params: Params | undefined,
   context: InitialValueResolverContext,
-) => Promise<Value> | Value
+) => Promise<Value> | Value;
 
 /** @public */
 export 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 */
 export 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 */
 export declare interface InsertMenuOptions {
@@ -1959,65 +2024,68 @@ export 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;
 }
 
 /** @internal */
 export declare type InsertPatch =
   | {
-      before: string
-      items: unknown[]
+      before: string;
+      items: unknown[];
     }
   | {
-      after: string
-      items: unknown[]
+      after: string;
+      items: unknown[];
     }
   | {
-      replace: string
-      items: unknown[]
-    }
+      replace: string;
+      items: unknown[];
+    };
 
 /** @beta */
 export declare type IntrinsicArrayOfBase = {
-  [K in keyof IntrinsicDefinitions]: Omit<ArrayOfEntry<IntrinsicDefinitions[K]>, 'preview'>
-}
+  [K in keyof IntrinsicDefinitions]: Omit<
+    ArrayOfEntry<IntrinsicDefinitions[K]>,
+    "preview"
+  >;
+};
 
 /** @public */
 export 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>;
+  };
+};
 
 /** @beta */
 export declare type IntrinsicBase = {
-  [K in keyof IntrinsicDefinitions]: Omit<IntrinsicDefinitions[K], 'preview'>
-}
+  [K in keyof IntrinsicDefinitions]: Omit<IntrinsicDefinitions[K], "preview">;
+};
 
 /**
  * `IntrinsicDefinitions` is a lookup map for "predefined" schema definitions.
@@ -2035,25 +2103,25 @@ export declare type IntrinsicBase = {
  * @public
  */
 export 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;
 }
 
 /**
@@ -2063,23 +2131,28 @@ export declare interface IntrinsicDefinitions {
  *
  * @public
  */
-export declare type IntrinsicTypeName = IntrinsicDefinitions[keyof IntrinsicDefinitions]['type']
+export declare type IntrinsicTypeName =
+  IntrinsicDefinitions[keyof IntrinsicDefinitions]["type"];
 
 /** @internal */
 export declare function isArrayOfBlocksSchemaType(
   type: unknown,
-): type is ArraySchemaType<ObjectSchemaType>
+): type is ArraySchemaType<ObjectSchemaType>;
 
 /** @internal */
 export declare function isArrayOfObjectsSchemaType(
   type: unknown,
-): type is ArraySchemaType<ObjectSchemaType>
+): type is ArraySchemaType<ObjectSchemaType>;
 
 /** @internal */
-export declare function isArrayOfPrimitivesSchemaType(type: unknown): type is ArraySchemaType
+export declare function isArrayOfPrimitivesSchemaType(
+  type: unknown,
+): type is ArraySchemaType;
 
 /** @internal */
-export declare function isArraySchemaType(type: unknown): type is ArraySchemaType
+export declare function isArraySchemaType(
+  type: unknown,
+): type is ArraySchemaType;
 
 /**
  * Check whether the provided value resembles a Media Library asset aspect document.
@@ -2092,70 +2165,82 @@ export declare function isArraySchemaType(type: unknown): type is ArraySchemaTyp
  */
 export declare function isAssetAspect(
   maybeAssetAspect: unknown,
-): maybeAssetAspect is MediaLibraryAssetAspectDocument
+): maybeAssetAspect is MediaLibraryAssetAspectDocument;
 
 /** @internal */
 export declare function isBlockChildrenObjectField(
   field: unknown,
-): field is BlockChildrenObjectField
+): field is BlockChildrenObjectField;
 
 /** @internal */
-export declare function isBlockListObjectField(field: unknown): field is BlockListObjectField
+export declare function isBlockListObjectField(
+  field: unknown,
+): field is BlockListObjectField;
 
 /** @internal */
-export declare function isBlockSchemaType(type: unknown): type is BlockSchemaType
+export declare function isBlockSchemaType(
+  type: unknown,
+): type is BlockSchemaType;
 
 /** @internal */
-export declare function isBlockStyleObjectField(field: unknown): field is BlockStyleObjectField
+export declare function isBlockStyleObjectField(
+  field: unknown,
+): field is BlockStyleObjectField;
 
 /** @internal */
-export declare function isBooleanSchemaType(type: unknown): type is BooleanSchemaType
+export declare function isBooleanSchemaType(
+  type: unknown,
+): type is BooleanSchemaType;
 
 /** @internal */
 export declare function isCreateIfNotExistsMutation(
   mutation: Mutation | TransactionLogMutation,
-): mutation is CreateIfNotExistsMutation
+): mutation is CreateIfNotExistsMutation;
 
 /** @internal */
 export declare function isCreateMutation(
   mutation: Mutation | TransactionLogMutation,
-): mutation is CreateMutation
+): mutation is CreateMutation;
 
 /** @internal */
 export declare function isCreateOrReplaceMutation(
   mutation: Mutation | TransactionLogMutation,
-): mutation is CreateOrReplaceMutation
+): mutation is CreateOrReplaceMutation;
 
 /** @internal */
 export declare function isCreateSquashedMutation(
   mutation: Mutation | TransactionLogMutation,
-): mutation is CreateSquashedMutation
+): mutation is CreateSquashedMutation;
 
 /** @beta */
 export declare function isCrossDatasetReference(
   reference: unknown,
-): reference is CrossDatasetReferenceValue
+): reference is CrossDatasetReferenceValue;
 
 /** @internal */
 export declare function isCrossDatasetReferenceSchemaType(
   type: unknown,
-): type is CrossDatasetReferenceSchemaType
+): type is CrossDatasetReferenceSchemaType;
 
 /** @internal */
-export declare function isDateTimeSchemaType(type: unknown): type is StringSchemaType
+export declare function isDateTimeSchemaType(
+  type: unknown,
+): type is StringSchemaType;
 
 /** @internal */
 export declare function isDeleteMutation(
   mutation: Mutation | TransactionLogMutation,
-): mutation is DeleteMutation
+): mutation is DeleteMutation;
 
 /** @internal */
-export declare function isDeprecatedSchemaType<TSchemaType extends BaseSchemaType>(
-  type: TSchemaType,
-): type is DeprecatedSchemaType<TSchemaType>
+export declare function isDeprecatedSchemaType<
+  TSchemaType extends BaseSchemaType,
+>(type: TSchemaType): type is DeprecatedSchemaType<TSchemaType>;
 
 /** @internal */
-export declare function isDeprecationConfiguration(type: unknown): type is DeprecationConfiguration
+export declare function isDeprecationConfiguration(
+  type: unknown,
+): type is DeprecationConfiguration;
 
 /**
  * Returns wether or not the given type is a document type
@@ -2166,44 +2251,56 @@ export declare function isDeprecationConfiguration(type: unknown): type is Depre
  *
  * @public
  */
-export declare function isDocumentSchemaType(type: unknown): type is ObjectSchemaType
+export declare function isDocumentSchemaType(
+  type: unknown,
+): type is ObjectSchemaType;
 
 /** @internal */
-export declare function isFileSchemaType(type: unknown): type is FileSchemaType
+export declare function isFileSchemaType(type: unknown): type is FileSchemaType;
 
 /** @beta */
 export declare function isGlobalDocumentReference(
   reference: unknown,
-): reference is GlobalDocumentReferenceValue
+): reference is GlobalDocumentReferenceValue;
 
 /** @public */
-export declare function isImage(value: unknown): value is Image_2
+export declare function isImage(value: unknown): value is Image_2;
 
 /** @internal */
-export declare function isImageSchemaType(type: unknown): type is ImageSchemaType
+export declare function isImageSchemaType(
+  type: unknown,
+): type is ImageSchemaType;
 
 /** @internal */
-export declare function isIndexSegment(segment: PathSegment): segment is number
+export declare function isIndexSegment(segment: PathSegment): segment is number;
 
 /** @internal */
-export declare function isIndexTuple(segment: PathSegment): segment is IndexTuple
+export declare function isIndexTuple(
+  segment: PathSegment,
+): segment is IndexTuple;
 
 /** @public */
-export declare function isKeyedObject(obj: unknown): obj is KeyedObject
+export declare function isKeyedObject(obj: unknown): obj is KeyedObject;
 
 /** @internal */
-export declare function isKeySegment(segment: PathSegment): segment is KeyedSegment
+export declare function isKeySegment(
+  segment: PathSegment,
+): segment is KeyedSegment;
 
 /** @internal */
-export declare function isNumberSchemaType(type: unknown): type is NumberSchemaType
+export declare function isNumberSchemaType(
+  type: unknown,
+): type is NumberSchemaType;
 
 /** @internal */
-export declare function isObjectSchemaType(type: unknown): type is ObjectSchemaType
+export declare function isObjectSchemaType(
+  type: unknown,
+): type is ObjectSchemaType;
 
 /** @internal */
 export declare function isPatchMutation(
   mutation: Mutation | TransactionLogMutation,
-): mutation is PatchMutation
+): mutation is PatchMutation;
 
 /**
  * Assert that a given object is a portable-text list-text-block-type object
@@ -2215,9 +2312,9 @@ export declare function isPatchMutation(
  *
  * @alpha
  */
-export declare function isPortableTextListBlock<T = PortableTextSpan | PortableTextObject>(
-  value: unknown,
-): value is PortableTextTextBlock<T>
+export declare function isPortableTextListBlock<
+  T = PortableTextSpan | PortableTextObject,
+>(value: unknown): value is PortableTextTextBlock<T>;
 
 /**
  * Assert that a given object is a portable-text span-type object
@@ -2227,7 +2324,9 @@ export declare function isPortableTextListBlock<T = PortableTextSpan | PortableT
  *
  * @alpha
  */
-export declare function isPortableTextSpan(value: unknown): value is PortableTextSpan
+export declare function isPortableTextSpan(
+  value: unknown,
+): value is PortableTextSpan;
 
 /**
  * Assert that a given object is a portable-text text-block type object
@@ -2238,30 +2337,34 @@ export declare function isPortableTextSpan(value: unknown): value is PortableTex
  *
  * @alpha
  */
-export declare function isPortableTextTextBlock<T = PortableTextSpan | PortableTextObject>(
-  value: unknown,
-): value is PortableTextTextBlock<T>
+export declare function isPortableTextTextBlock<
+  T = PortableTextSpan | PortableTextObject,
+>(value: unknown): value is PortableTextTextBlock<T>;
 
 /** @internal */
 export declare function isPrimitiveSchemaType(
   type: unknown,
-): type is BooleanSchemaType | StringSchemaType | NumberSchemaType
+): type is BooleanSchemaType | StringSchemaType | NumberSchemaType;
 
 /** @internal */
-export declare function isReference(reference: unknown): reference is Reference
+export declare function isReference(reference: unknown): reference is Reference;
 
 /** @internal */
-export declare function isReferenceSchemaType(type: unknown): type is ReferenceSchemaType
+export declare function isReferenceSchemaType(
+  type: unknown,
+): type is ReferenceSchemaType;
 
 /** @public */
-export declare function isSanityDocument(document: unknown): document is SanityDocument
+export declare function isSanityDocument(
+  document: unknown,
+): document is SanityDocument;
 
 /**
  * @internal
  */
 export declare function isSearchStrategy(
   maybeSearchStrategy: unknown,
-): maybeSearchStrategy is SearchStrategy
+): maybeSearchStrategy is SearchStrategy;
 
 /**
  * Checks whether the given `thing` is a slug, eg an object with a `current` string property.
@@ -2270,68 +2373,76 @@ export declare function isSearchStrategy(
  * @returns True if slug, false otherwise
  * @public
  */
-export declare function isSlug(thing: unknown): thing is Slug
+export declare function isSlug(thing: unknown): thing is Slug;
 
 /** @internal */
-export declare function isSpanSchemaType(type: unknown): type is SpanSchemaType
+export declare function isSpanSchemaType(type: unknown): type is SpanSchemaType;
 
 /** @internal */
-export declare function isStringSchemaType(type: unknown): type is StringSchemaType
+export declare function isStringSchemaType(
+  type: unknown,
+): type is StringSchemaType;
 
 /** @internal */
-export declare function isTitledListValue(item: unknown): item is TitledListValue
+export declare function isTitledListValue(
+  item: unknown,
+): item is TitledListValue;
 
 /** @public */
-export declare function isTypedObject(obj: unknown): obj is TypedObject
+export declare function isTypedObject(obj: unknown): obj is TypedObject;
 
 /** @internal */
-export declare function isValidationError(node: FormNodeValidation): node is FormNodeValidation & {
-  level: 'error'
-}
+export declare function isValidationError(
+  node: FormNodeValidation,
+): node is FormNodeValidation & {
+  level: "error";
+};
 
 /** @internal */
 export declare function isValidationErrorMarker(
   marker: ValidationMarker,
 ): marker is ValidationMarker & {
-  level: 'error'
-}
+  level: "error";
+};
 
 /** @internal */
-export declare function isValidationInfo(node: FormNodeValidation): node is FormNodeValidation & {
-  level: 'info'
-}
+export declare function isValidationInfo(
+  node: FormNodeValidation,
+): node is FormNodeValidation & {
+  level: "info";
+};
 
 /** @internal */
 export declare function isValidationInfoMarker(
   marker: ValidationMarker,
 ): marker is ValidationMarker & {
-  level: 'info'
-}
+  level: "info";
+};
 
 /** @internal */
 export declare function isValidationWarning(
   node: FormNodeValidation,
 ): node is FormNodeValidation & {
-  level: 'warning'
-}
+  level: "warning";
+};
 
 /** @internal */
 export declare function isValidationWarningMarker(
   marker: ValidationMarker,
 ): marker is ValidationMarker & {
-  level: 'warning'
-}
+  level: "warning";
+};
 
 /** @public */
 export declare interface KeyedObject {
-  [key: string]: unknown
-  _key: string
+  [key: string]: unknown;
+  _key: string;
 }
 
 /** @public */
 export declare type KeyedSegment = {
-  _key: string
-}
+  _key: string;
+};
 
 /**
  * Holds localized validation messages for a given field.
@@ -2346,18 +2457,19 @@ export declare type KeyedSegment = {
  * @public
  */
 export declare interface LocalizedValidationMessages {
-  [locale: string]: string
+  [locale: string]: string;
 }
 
 /** @beta */
-export declare type MaybeAllowUnknownProps<TStrict extends StrictDefinition> = TStrict extends false
-  ? {
-      options?: {
-        [index: string]: any
+export declare type MaybeAllowUnknownProps<TStrict extends StrictDefinition> =
+  TStrict extends false
+    ? {
+        options?: {
+          [index: string]: any;
+        };
+        [index: string]: any;
       }
-      [index: string]: any
-    }
-  : unknown
+    : unknown;
 
 /** @beta */
 export declare type MaybePreview<
@@ -2368,24 +2480,25 @@ export declare type MaybePreview<
     ? PrepareValue extends Record<keyof Select, any>
       ? PreviewConfig<Select, PrepareValue>
       : never
-    : never
+    : never;
 
 /**
  * @public
  */
-export declare const MEDIA_LIBRARY_ASSET_ASPECT_TYPE_NAME = 'sanity.asset.aspect'
+export declare const MEDIA_LIBRARY_ASSET_ASPECT_TYPE_NAME =
+  "sanity.asset.aspect";
 
 /** @public */
-export declare type MediaAssetTypes = AssetInstanceDocument['_type']
+export declare type MediaAssetTypes = AssetInstanceDocument["_type"];
 
 /**
  * @public
  */
 export declare type MediaLibraryAssetAspectDefinition =
   MediaLibraryAssetAspectSupportedFieldDefinitions & {
-    assetType?: MediaLibraryAssetType | MediaLibraryAssetType[]
-    public?: boolean
-  }
+    assetType?: MediaLibraryAssetType | MediaLibraryAssetType[];
+    public?: boolean;
+  };
 
 /**
  * A document representing a Media Library asset aspect.
@@ -2395,47 +2508,56 @@ export declare type MediaLibraryAssetAspectDefinition =
  * @public
  */
 export declare interface MediaLibraryAssetAspectDocument extends SanityDocumentLike {
-  _type: MediaLibraryAssetAspectTypeName
+  _type: MediaLibraryAssetAspectTypeName;
   /**
    * Asset types the aspect can be assigned to.
    *
    * If no `assetType` is defined, the aspect may be assigned to any asset type.
    */
-  assetType?: MediaLibraryAssetType[]
-  definition: FieldDefinition
-  public?: boolean
+  assetType?: MediaLibraryAssetType[];
+  definition: FieldDefinition;
+  public?: boolean;
 }
 
 /**
  * @public
  */
-export declare type MediaLibraryAssetAspectSupportedFieldDefinitions = FieldDefinition<
-  Exclude<IntrinsicTypeName, 'document' | 'image' | 'file' | 'reference' | 'crossDatasetReference'>
->
+export declare type MediaLibraryAssetAspectSupportedFieldDefinitions =
+  FieldDefinition<
+    Exclude<
+      IntrinsicTypeName,
+      "document" | "image" | "file" | "reference" | "crossDatasetReference"
+    >
+  >;
 
 /**
  * @public
  */
-export declare type MediaLibraryAssetAspectTypeName = typeof MEDIA_LIBRARY_ASSET_ASPECT_TYPE_NAME
+export declare type MediaLibraryAssetAspectTypeName =
+  typeof MEDIA_LIBRARY_ASSET_ASPECT_TYPE_NAME;
 
 /**
  * @public
  */
-export declare type MediaLibraryAssetType = ImageAsset['_type'] | FileAsset['_type']
+export declare type MediaLibraryAssetType =
+  | ImageAsset["_type"]
+  | FileAsset["_type"];
 
 /** @public */
 export declare interface MediaLibraryFilter {
-  name: string
-  query: string
+  name: string;
+  query: string;
 }
 
 /** @public */
 export declare interface MediaLibraryOptions {
-  filters?: MediaLibraryFilter[]
+  filters?: MediaLibraryFilter[];
 }
 
 /** @public */
-export declare interface MediaValidationValue<T extends MediaAssetTypes = MediaAssetTypes> {
+export declare interface MediaValidationValue<
+  T extends MediaAssetTypes = MediaAssetTypes,
+> {
   /**
    * Media information
    */
@@ -2447,23 +2569,25 @@ export declare interface MediaValidationValue<T extends MediaAssetTypes = MediaA
       currentVersion: Extract<
         AssetInstanceDocument,
         {
-          _type: T
+          _type: T;
         }
-      >
-    }
-  }
+      >;
+    };
+  };
   /**
    * The field value which the media is used in.
    */
-  value: unknown
+  value: unknown;
 }
 
 /** @public */
-export declare interface MediaValidator<T extends MediaAssetTypes = MediaAssetTypes> {
+export declare interface MediaValidator<
+  T extends MediaAssetTypes = MediaAssetTypes,
+> {
   (
     value: MediaValidationValue<T>,
     context: ValidationContext,
-  ): CustomValidatorResult | Promise<CustomValidatorResult>
+  ): CustomValidatorResult | Promise<CustomValidatorResult>;
 }
 
 /**
@@ -2474,8 +2598,8 @@ export declare interface MediaValidator<T extends MediaAssetTypes = MediaAssetTy
  * @internal
  */
 export declare interface MendozaEffectPair {
-  apply: MendozaPatch
-  revert: MendozaPatch
+  apply: MendozaPatch;
+  revert: MendozaPatch;
 }
 
 /**
@@ -2485,30 +2609,30 @@ export declare interface MendozaEffectPair {
  *
  * @internal
  */
-export declare type MendozaPatch = unknown[]
+export declare type MendozaPatch = unknown[];
 
 /** @public */
 export 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;
 }
 
 /** @internal */
 export declare interface MultipleMutationResult {
-  transactionId: string
-  documentIds: string[]
+  transactionId: string;
+  documentIds: string[];
   results: {
-    id: string
-  }[]
+    id: string;
+  }[];
 }
 
 /** @internal */
@@ -2517,25 +2641,25 @@ export declare type Mutation =
   | CreateOrReplaceMutation
   | CreateIfNotExistsMutation
   | DeleteMutation
-  | PatchMutation
+  | PatchMutation;
 
 /** @internal */
 export declare type MutationOperationName =
-  | 'create'
-  | 'createOrReplace'
-  | 'createIfNotExists'
-  | 'delete'
-  | 'patch'
+  | "create"
+  | "createOrReplace"
+  | "createIfNotExists"
+  | "delete"
+  | "patch";
 
 /** @internal */
 export declare type MutationSelection =
   | {
-      query: string
-      params?: Record<string, unknown>
+      query: string;
+      params?: Record<string, unknown>;
     }
   | {
-      id: string
-    }
+      id: string;
+    };
 
 /** @beta */
 export declare type NarrowPreview<
@@ -2545,128 +2669,136 @@ export declare type NarrowPreview<
   TPrepareValue extends Record<keyof TSelect, any> | undefined,
 > =
   DefineSchemaType<TType, TAlias> extends {
-    preview?: Record<string, any>
+    preview?: Record<string, any>;
   }
     ? {
-        preview?: MaybePreview<TSelect, TPrepareValue>
+        preview?: MaybePreview<TSelect, TPrepareValue>;
       }
-    : unknown
+    : unknown;
 
 /** @public */
 export 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 */
-export declare interface NumberOptions extends EnumListProps<number>, BaseSchemaTypeOptions {}
+export declare interface NumberOptions
+  extends EnumListProps<number>, BaseSchemaTypeOptions {}
 
 /** @public */
 export 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 */
 export declare interface NumberSchemaType extends BaseSchemaType {
-  jsonType: 'number'
-  options?: NumberOptions
-  initialValue?: InitialValueProperty<any, number>
+  jsonType: "number";
+  options?: NumberOptions;
+  initialValue?: InitialValueProperty<any, number>;
 }
 
 /** @public */
 export 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 */
 export 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 */
 export declare type ObjectFieldType<T extends SchemaType = SchemaType> = T & {
-  hidden?: ConditionalProperty
-  readOnly?: ConditionalProperty
-}
+  hidden?: ConditionalProperty;
+  readOnly?: ConditionalProperty;
+};
 
 /** @public */
 export 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 */
-export declare interface ObjectRule extends RuleDef<ObjectRule, Record<string, unknown>> {}
+export declare interface ObjectRule extends RuleDef<
+  ObjectRule,
+  Record<string, unknown>
+> {}
 
 /** @public */
 export 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;
 }
 
 /** @internal */
-export declare interface ObjectSchemaTypeWithOptions extends Omit<ObjectSchemaType, 'options'> {
+export declare interface ObjectSchemaTypeWithOptions extends Omit<
+  ObjectSchemaType,
+  "options"
+> {
   options?: CollapseOptions & {
-    columns?: number
-  }
+    columns?: number;
+  };
 }
 
 /** @internal */
 export declare interface PatchMutation {
-  patch: PatchMutationOperation
+  patch: PatchMutationOperation;
 }
 
 /** @internal */
-export declare type PatchMutationOperation = PatchOperations & MutationSelection
+export declare type PatchMutationOperation = PatchOperations &
+  MutationSelection;
 
 /**
  * NOTE: this is actually incorrect/invalid, but implemented as-is for backwards compatibility
@@ -2675,76 +2807,80 @@ export declare type PatchMutationOperation = PatchOperations & MutationSelection
  */
 export declare interface PatchOperations {
   set?: {
-    [key: string]: unknown
-  }
+    [key: string]: unknown;
+  };
   setIfMissing?: {
-    [key: string]: unknown
-  }
+    [key: string]: unknown;
+  };
   merge?: {
-    [key: string]: unknown
-  }
+    [key: string]: unknown;
+  };
   diffMatchPatch?: {
-    [key: string]: string
-  }
-  unset?: string[]
+    [key: string]: string;
+  };
+  unset?: string[];
   inc?: {
-    [key: string]: number
-  }
+    [key: string]: number;
+  };
   dec?: {
-    [key: string]: number
-  }
-  insert?: InsertPatch
-  ifRevisionID?: string
+    [key: string]: number;
+  };
+  insert?: InsertPatch;
+  ifRevisionID?: string;
 }
 
 /** @public */
-export declare type Path = PathSegment[]
+export declare type Path = PathSegment[];
 
 /** @public */
-export declare type PathSegment = string | number | KeyedSegment | IndexTuple
+export declare type PathSegment = string | number | KeyedSegment | IndexTuple;
 
 /** @alpha */
-export declare type PortableTextBlock = PortableTextTextBlock | PortableTextObject
+export declare type PortableTextBlock =
+  | PortableTextTextBlock
+  | PortableTextObject;
 
 /** @alpha */
-export declare type PortableTextChild = PortableTextObject | PortableTextSpan
+export declare type PortableTextChild = PortableTextObject | PortableTextSpan;
 
 /** @alpha */
 export declare interface PortableTextListBlock extends PortableTextTextBlock {
-  listItem: string
-  level: number
+  listItem: string;
+  level: number;
 }
 
 /** @alpha */
 export declare interface PortableTextObject {
-  _type: string
-  _key: string
-  [other: string]: unknown
+  _type: string;
+  _key: string;
+  [other: string]: unknown;
 }
 
 /** @alpha */
 export declare interface PortableTextSpan {
-  _key: string
-  _type: 'span'
-  text: string
-  marks?: string[]
+  _key: string;
+  _type: "span";
+  text: string;
+  marks?: string[];
 }
 
 /** @alpha */
-export declare interface PortableTextTextBlock<TChild = PortableTextSpan | PortableTextObject> {
-  _type: string
-  _key: string
-  children: TChild[]
-  markDefs?: PortableTextObject[]
-  listItem?: string
-  style?: string
-  level?: number
+export declare interface PortableTextTextBlock<
+  TChild = PortableTextSpan | PortableTextObject,
+> {
+  _type: string;
+  _key: string;
+  children: TChild[];
+  markDefs?: PortableTextObject[];
+  listItem?: string;
+  style?: string;
+  level?: number;
 }
 
 /** @public */
 export declare interface PrepareViewOptions {
   /** @beta */
-  ordering?: SortOrdering
+  ordering?: SortOrdering;
 }
 
 /** @public */
@@ -2752,93 +2888,96 @@ export 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 */
 export 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 */
 export 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 */
 export declare interface ReferenceBaseOptions extends BaseSchemaTypeOptions {
-  disableNew?: boolean
+  disableNew?: boolean;
 }
 
 /** @public */
 export 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 */
 export declare type ReferenceFilterOptions =
   | ReferenceFilterResolverOptions
-  | ReferenceFilterQueryOptions
+  | ReferenceFilterQueryOptions;
 
 /** @public */
 export declare interface ReferenceFilterQueryOptions {
-  filter: string
-  filterParams?: Record<string, unknown>
+  filter: string;
+  filterParams?: Record<string, unknown>;
 }
 
 /** @public */
 export declare type ReferenceFilterResolver = (
   context: ReferenceFilterResolverContext,
-) => ReferenceFilterSearchOptions | Promise<ReferenceFilterSearchOptions>
+) => ReferenceFilterSearchOptions | Promise<ReferenceFilterSearchOptions>;
 
 /** @public */
 export 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 */
 export declare interface ReferenceFilterResolverOptions {
-  filter?: ReferenceFilterResolver
-  filterParams?: never
+  filter?: ReferenceFilterResolver;
+  filterParams?: never;
 }
 
 /** @public */
 export 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,
@@ -2850,33 +2989,40 @@ export declare type ReferenceFilterSearchOptions = {
  *
  * @public
  */
-export declare type ReferenceOptions = ReferenceBaseOptions & ReferenceFilterOptions
+export declare type ReferenceOptions = ReferenceBaseOptions &
+  ReferenceFilterOptions;
 
 /** @public */
-export declare interface ReferenceRule extends RuleDef<ReferenceRule, ReferenceValue> {}
+export declare interface ReferenceRule extends RuleDef<
+  ReferenceRule,
+  ReferenceValue
+> {}
 
 /** @public */
-export declare interface ReferenceSchemaType extends Omit<ObjectSchemaType, 'options'> {
-  jsonType: 'object'
-  to: ObjectSchemaType[]
-  weak?: boolean
-  options?: ReferenceOptions
+export declare interface ReferenceSchemaType extends Omit<
+  ObjectSchemaType,
+  "options"
+> {
+  jsonType: "object";
+  to: ObjectSchemaType[];
+  weak?: boolean;
+  options?: ReferenceOptions;
 }
 
 /** @public */
 export declare type ReferenceTo =
   | SchemaTypeDefinition
   | TypeReference
-  | Array<SchemaTypeDefinition | TypeReference>
+  | Array<SchemaTypeDefinition | TypeReference>;
 
 /** @public */
-export declare type ReferenceValue = Reference
+export declare type ReferenceValue = Reference;
 
 /** @public */
 export declare interface Role {
-  name: string
-  title: string
-  description?: string
+  name: string;
+  title: string;
+  description?: string;
 }
 
 /** @public */
@@ -2885,37 +3031,37 @@ export 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.
    *
@@ -2938,62 +3084,64 @@ export 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;
   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 & {
@@ -3003,16 +3151,19 @@ export declare interface Rule {
        */
       __internal?: {
         customValidationConcurrencyLimiter?: {
-          ready: () => Promise<void>
-          release: () => void
-        }
-      }
+          ready: () => Promise<void>;
+          release: () => void;
+        };
+      };
     },
-  ): Promise<ValidationMarker[]>
+  ): Promise<ValidationMarker[]>;
 }
 
 /** @public */
-export declare type RuleBuilder<T extends RuleDef<T, FieldValue>, FieldValue = unknown> = T | T[]
+export declare type RuleBuilder<
+  T extends RuleDef<T, FieldValue>,
+  FieldValue = unknown,
+> = T | T[];
 
 /**
  * Note: `RuleClass` and `Rule` are split to fit the current `@sanity/types`
@@ -3031,144 +3182,145 @@ export declare type RuleBuilder<T extends RuleDef<T, FieldValue>, FieldValue = u
  * @internal
  */
 export declare interface RuleClass {
-  FIELD_REF: symbol
-  array: (def?: SchemaType) => Rule
-  object: (def?: SchemaType) => Rule
-  string: (def?: SchemaType) => Rule
-  number: (def?: SchemaType) => Rule
-  boolean: (def?: SchemaType) => Rule
-  dateTime: (def?: SchemaType) => Rule
-  valueOfField: Rule['valueOfField']
-  new (typeDef?: SchemaType): Rule
+  FIELD_REF: symbol;
+  array: (def?: SchemaType) => Rule;
+  object: (def?: SchemaType) => Rule;
+  string: (def?: SchemaType) => Rule;
+  number: (def?: SchemaType) => Rule;
+  boolean: (def?: SchemaType) => Rule;
+  dateTime: (def?: SchemaType) => Rule;
+  valueOfField: Rule["valueOfField"];
+  new (typeDef?: SchemaType): Rule;
 }
 
 /** @public */
 export declare interface RuleDef<T, FieldValue = unknown> {
-  required: () => T
+  required: () => 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 */
 export 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
-        }
-      }
-    }
+          scheme: RegExp[];
+          allowRelative: boolean;
+          relativeOnly: boolean;
+          allowCredentials: boolean;
+        };
+      };
+    };
 
 /** @internal */
-export declare type RuleSpecConstraint<T extends RuleSpec['flag']> = ConditionalIndexAccess<
-  Extract<
-    RuleSpec,
-    {
-      flag: T
-    }
-  >,
-  'constraint'
->
+export declare type RuleSpecConstraint<T extends RuleSpec["flag"]> =
+  ConditionalIndexAccess<
+    Extract<
+      RuleSpec,
+      {
+        flag: T;
+      }
+    >,
+    "constraint"
+  >;
 
 /** @public */
 export declare type RuleTypeConstraint =
-  | 'Array'
-  | 'Boolean'
-  | 'Date'
-  | 'Number'
-  | 'Object'
-  | 'String'
+  | "Array"
+  | "Boolean"
+  | "Date"
+  | "Number"
+  | "Object"
+  | "String";
 
 /**
  * Options for configuring how Sanity Create interfaces with the type or field.
@@ -3177,22 +3329,22 @@ export declare type RuleTypeConstraint =
  */
 export 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;
 }
 
 /** @public */
 export 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;
 }
 
 /**
@@ -3203,43 +3355,43 @@ export declare interface SanityDocument {
  * @public
  */
 export declare interface SanityDocumentLike {
-  _id: string
-  _type: string
-  _createdAt?: string
-  _updatedAt?: string
-  _rev?: string
+  _id: string;
+  _type: string;
+  _createdAt?: string;
+  _updatedAt?: string;
+  _rev?: string;
   _system?: {
-    delete?: boolean
-  }
-  [key: string]: unknown
+    delete?: boolean;
+  };
+  [key: string]: unknown;
 }
 
 /** @public */
 export 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;
 }
 
 /**
@@ -3255,7 +3407,7 @@ export declare type SchemaType =
   | NumberSchemaType
   | ObjectSchemaType
   | StringSchemaType
-  | ReferenceSchemaType
+  | ReferenceSchemaType;
 
 /**
  * Represents a Sanity schema type definition with an optional type parameter.
@@ -3267,38 +3419,42 @@ export declare type SchemaType =
  *
  * @public
  */
-export declare type SchemaTypeDefinition<TType extends IntrinsicTypeName = IntrinsicTypeName> =
+export declare type SchemaTypeDefinition<
+  TType extends IntrinsicTypeName = IntrinsicTypeName,
+> =
   | IntrinsicDefinitions[IntrinsicTypeName]
-  | TypeAliasDefinition<string, TType>
+  | TypeAliasDefinition<string, TType>;
 
 /** @public */
 export declare interface SchemaValidationError {
-  helpId?: string
-  message: string
-  severity: 'error'
+  helpId?: string;
+  message: string;
+  severity: "error";
 }
 
 /** @internal */
-export declare type SchemaValidationProblem = SchemaValidationError | SchemaValidationWarning
+export declare type SchemaValidationProblem =
+  | SchemaValidationError
+  | SchemaValidationWarning;
 
 /** @internal */
 export declare interface SchemaValidationProblemGroup {
-  path: SchemaValidationProblemPath
-  problems: SchemaValidationProblem[]
+  path: SchemaValidationProblemPath;
+  problems: SchemaValidationProblem[];
 }
 
 /** @internal */
 export 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.
@@ -3330,13 +3486,13 @@ export declare type SchemaValidationValue =
   | undefined
   | Rule
   | SchemaValidationValue[]
-  | ((rule: Rule) => SchemaValidationValue)
+  | ((rule: Rule) => SchemaValidationValue);
 
 /** @internal */
 export declare interface SchemaValidationWarning {
-  helpId?: string
-  message: string
-  severity: 'warning'
+  helpId?: string;
+  message: string;
+  severity: "warning";
 }
 
 /** @public */
@@ -3356,36 +3512,36 @@ export 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
  */
-export declare const searchStrategies: readonly ['groqLegacy', 'groq2024']
+export declare const searchStrategies: readonly ["groqLegacy", "groq2024"];
 
 /**
  * @public
  */
-export declare type SearchStrategy = (typeof searchStrategies)[number]
+export declare type SearchStrategy = (typeof searchStrategies)[number];
 
 /** @public */
 export 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[];
 }
 
 /** @internal */
 export declare interface SingleMutationResult {
-  transactionId: string
-  documentId: string
+  transactionId: string;
+  documentId: string;
   results: {
-    id: string
-  }[]
+    id: string;
+  }[];
 }
 
 /**
@@ -3396,16 +3552,16 @@ export declare interface SingleMutationResult {
  * @public
  */
 export declare interface Slug {
-  _type: 'slug'
-  current: string
+  _type: "slug";
+  current: string;
 }
 
 /** @public */
 export 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 */
@@ -3413,77 +3569,80 @@ export declare type SlugifierFn = (
   source: string,
   schemaType: SlugSchemaType,
   context: SlugSourceContext,
-) => string | Promise<string>
+) => string | Promise<string>;
 
 /** @public */
 export declare type SlugIsUniqueValidator = (
   slug: string,
   context: SlugValidationContext,
-) => boolean | Promise<boolean>
+) => boolean | Promise<boolean>;
 
 /** @public */
-export declare interface SlugOptions extends SearchConfiguration, BaseSchemaTypeOptions {
-  source?: string | Path | SlugSourceFn
-  maxLength?: number
-  slugify?: SlugifierFn
-  isUnique?: SlugIsUniqueValidator
-  disableArrayWarning?: boolean
+export declare interface SlugOptions
+  extends SearchConfiguration, BaseSchemaTypeOptions {
+  source?: string | Path | SlugSourceFn;
+  maxLength?: number;
+  slugify?: SlugifierFn;
+  isUnique?: SlugIsUniqueValidator;
+  disableArrayWarning?: boolean;
 }
 
 /** @public */
-export declare type SlugParent = Record<string, unknown> | Record<string, unknown>[]
+export declare type SlugParent =
+  | Record<string, unknown>
+  | Record<string, unknown>[];
 
 /** @public */
 export declare interface SlugRule extends RuleDef<SlugRule, SlugValue> {}
 
 /** @public */
 export declare interface SlugSchemaType extends ObjectSchemaType {
-  jsonType: 'object'
-  options?: SlugOptions
+  jsonType: "object";
+  options?: SlugOptions;
 }
 
 /** @public */
 export 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 */
 export declare type SlugSourceFn = (
   document: SanityDocument,
   context: SlugSourceContext,
-) => string | Promise<string>
+) => string | Promise<string>;
 
 /** @public */
 export declare interface SlugValidationContext extends ValidationContext {
-  parent: SlugParent
-  type: SlugSchemaType
-  defaultIsUnique: SlugIsUniqueValidator
+  parent: SlugParent;
+  type: SlugSchemaType;
+  defaultIsUnique: SlugIsUniqueValidator;
 }
 
 /** @public */
 export declare interface SlugValue {
-  _type: 'slug'
-  current?: string
+  _type: "slug";
+  current?: string;
 }
 
 /** @beta */
 export declare type SortOrdering = {
-  title: string
-  i18n?: I18nTextRecord<'title'>
-  name: string
-  by: SortOrderingItem[]
-}
+  title: string;
+  i18n?: I18nTextRecord<"title">;
+  name: string;
+  by: SortOrderingItem[];
+};
 
 /** @beta */
 export declare interface SortOrderingItem {
-  field: string
-  direction: 'asc' | 'desc'
+  field: string;
+  direction: "asc" | "desc";
 }
 
 /**
@@ -3493,8 +3652,8 @@ export declare interface SortOrderingItem {
  * @internal
  */
 export declare type SpanMarksObjectField = {
-  name: 'marks'
-} & ObjectField<ArraySchemaTypeOf<StringSchemaType>>
+  name: "marks";
+} & ObjectField<ArraySchemaTypeOf<StringSchemaType>>;
 
 /**
  * Represents the compiled schema shape for `span`s for portable text.
@@ -3503,15 +3662,18 @@ export declare type SpanMarksObjectField = {
  *
  * @internal
  */
-export declare interface SpanSchemaType extends Omit<ObjectSchemaType, 'fields'> {
+export declare interface SpanSchemaType extends Omit<
+  ObjectSchemaType,
+  "fields"
+> {
   annotations: (ObjectSchemaType & {
-    icon?: string | ComponentType
+    icon?: string | ComponentType;
     components?: {
-      item?: ComponentType
-    }
-  })[]
-  decorators: BlockDecoratorDefinition[]
-  fields: [SpanMarksObjectField, SpanTextObjectField]
+      item?: ComponentType;
+    };
+  })[];
+  decorators: BlockDecoratorDefinition[];
+  fields: [SpanMarksObjectField, SpanTextObjectField];
 }
 
 /**
@@ -3521,11 +3683,11 @@ export declare interface SpanSchemaType extends Omit<ObjectSchemaType, 'fields'>
  * @internal
  */
 export declare type SpanTextObjectField = {
-  name: 'text'
-} & ObjectField<TextSchemaType>
+  name: "text";
+} & ObjectField<TextSchemaType>;
 
 /** @beta */
-export declare type StrictDefinition = boolean | undefined
+export declare type StrictDefinition = boolean | undefined;
 
 /**
  * @internal
@@ -3547,16 +3709,16 @@ export declare interface StrictVersionLayeringOptions {
    * **Cross-version layering is only effective for scheduled versions, with all other
    * versions being layered directly onto the published version (if it exists).**
    */
-  strict?: boolean
+  strict?: boolean;
 }
 
 /** @public */
 export 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 */
@@ -3565,29 +3727,29 @@ export declare interface StringOptions
 
 /** @public */
 export 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;
 }
 
 /**
@@ -3597,9 +3759,9 @@ export declare interface StringRule extends RuleDef<StringRule, string> {
  * @public
  */
 export 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>;
 }
 
 /**
@@ -3607,33 +3769,33 @@ export declare interface StringSchemaType extends BaseSchemaType {
  * Payload that will be passed by the comments backend to our notifications system to display the notification in dashboard.
  * */
 export declare interface StudioNotificationPayload extends DashboardNotificationPayload {
-  applicationType: 'studio'
-  applicationId: string | undefined
-  workspaceName: string | undefined
+  applicationType: "studio";
+  applicationId: string | undefined;
+  workspaceName: string | undefined;
   link: {
-    type: 'url'
-    url: string
-  }
+    type: "url";
+    url: string;
+  };
 }
 
 /** @public */
 export declare type SwatchName =
-  | 'darkMuted'
-  | 'darkVibrant'
-  | 'dominant'
-  | 'lightMuted'
-  | 'lightVibrant'
-  | 'muted'
-  | 'vibrant'
+  | "darkMuted"
+  | "darkVibrant"
+  | "dominant"
+  | "lightMuted"
+  | "lightVibrant"
+  | "muted"
+  | "vibrant";
 
 /** @public */
 export 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 */
@@ -3644,14 +3806,14 @@ export declare interface TextRule extends StringRule {}
 
 /** @public */
 export declare interface TextSchemaType extends StringSchemaType {
-  rows?: number
+  rows?: number;
 }
 
 /** @public */
 export declare interface TitledListValue<V = unknown> {
-  _key?: string
-  title: string
-  value?: V
+  _key?: string;
+  title: string;
+  value?: V;
 }
 
 /**
@@ -3663,19 +3825,19 @@ export declare interface TransactionLogEvent {
   /**
    * ID of transaction
    */
-  id: string
+  id: string;
   /**
    * ISO-formatted timestamp (zulu-time) of when the transaction happened
    */
-  timestamp: string
+  timestamp: string;
   /**
    * User ID of the user who performed the transaction
    */
-  author: string
+  author: string;
   /**
    * Document IDs involved in this transaction
    */
-  documentIDs: string[]
+  documentIDs: string[];
 }
 
 /**
@@ -3690,7 +3852,7 @@ export declare interface TransactionLogEventWithEffects extends TransactionLogEv
    * Object of effects, where the key is the document ID affected and the value
    * is the effect pair, eg `{apply: MendozaPatch, revert: MendozaPatch}`
    */
-  effects: Record<string, MendozaEffectPair | undefined>
+  effects: Record<string, MendozaEffectPair | undefined>;
 }
 
 /**
@@ -3706,7 +3868,7 @@ export declare interface TransactionLogEventWithMutations extends TransactionLog
    * log has an additional mutation type not typically seen in other APIs;
    * `createSquashed` ({@link CreateSquashedMutation}).
    */
-  mutations: TransactionLogMutation[]
+  mutations: TransactionLogMutation[];
 }
 
 /**
@@ -3715,7 +3877,7 @@ export declare interface TransactionLogEventWithMutations extends TransactionLog
  *
  * @internal
  */
-export declare type TransactionLogMutation = Mutation | CreateSquashedMutation
+export declare type TransactionLogMutation = Mutation | CreateSquashedMutation;
 
 /**
  * Represents a type definition that is an alias/extension of an existing type
@@ -3729,21 +3891,23 @@ export 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>;
+  };
 }
 
 /**
@@ -3771,12 +3935,12 @@ export declare interface TypeAliasDefinition<
  *
  * @internal
  */
-export declare function typed<T>(input: T): T
+export declare function typed<T>(input: T): T;
 
 /** @public */
 export declare interface TypedObject {
-  [key: string]: unknown
-  _type: string
+  [key: string]: unknown;
+  _type: string;
 }
 
 /**
@@ -3785,45 +3949,45 @@ export declare interface TypedObject {
  * @public
  */
 export declare interface TypeReference {
-  type: string
-  name?: string
-  icon?: ComponentType | ReactNode
+  type: string;
+  name?: string;
+  icon?: ComponentType | ReactNode;
   options?: {
-    [key: string]: unknown
-  }
+    [key: string]: unknown;
+  };
 }
 
 /** @internal */
 export declare interface UploadState {
-  progress: number
+  progress: number;
   /** @deprecated use createdAt instead */
-  initiated?: string
+  initiated?: string;
   /** @deprecated use updatedAt instead */
-  updated?: string
-  createdAt: string
-  updatedAt: string
+  updated?: string;
+  createdAt: string;
+  updatedAt: string;
   file: {
-    name: string
-    type: string
-  }
-  previewImage?: string
+    name: string;
+    type: string;
+  };
+  previewImage?: string;
 }
 
 /** @public */
 export 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 */
 export 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 */
@@ -3831,21 +3995,22 @@ export declare interface UrlOptions extends BaseSchemaTypeOptions {}
 
 /** @public */
 export declare interface UrlRule extends RuleDef<UrlRule, string> {
-  uri(options: UriValidationOptions): UrlRule
+  uri(options: UriValidationOptions): UrlRule;
 }
 
 /** @public */
 export declare interface User {
-  id: string
-  displayName?: string
-  imageUrl?: string
-  email?: string
+  id: string;
+  displayName?: string;
+  imageUrl?: string;
+  email?: string;
 }
 
 /** @public */
-export declare type ValidationBuilder<T extends RuleDef<T, FieldValue>, FieldValue = unknown> = (
-  rule: T,
-) => RuleBuilder<T, FieldValue>
+export declare type ValidationBuilder<
+  T extends RuleDef<T, FieldValue>,
+  FieldValue = unknown,
+> = (rule: T) => RuleBuilder<T, FieldValue>;
 
 /**
  * A context object passed around during validation. This includes the
@@ -3862,14 +4027,14 @@ export declare type ValidationBuilder<T extends RuleDef<T, FieldValue>, FieldVal
  * @public
  */
 export 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";
 }
 
 /**
@@ -3885,7 +4050,7 @@ export 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
@@ -3894,14 +4059,14 @@ export 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
@@ -3909,19 +4074,19 @@ export 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;
 }
 
 /**
@@ -3933,27 +4098,27 @@ export declare interface ValidationError {
  * @internal
  */
 export declare interface ValidationErrorClass {
-  new (message: string, options?: ValidationErrorOptions): ValidationError
+  new (message: string, options?: ValidationErrorOptions): ValidationError;
 }
 
 /** @internal */
 export declare interface ValidationErrorOptions {
-  paths?: Path[]
-  children?: ValidationMarker[]
-  operation?: 'AND' | 'OR'
+  paths?: Path[];
+  children?: ValidationMarker[];
+  operation?: "AND" | "OR";
 }
 
 /** @public */
 export 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.
@@ -3961,14 +4126,14 @@ export 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;
 }
 
 /**
@@ -3990,7 +4155,7 @@ export declare type Validator<T = any, Value = any> = (
   | ValidationError
   | string
   | true
-  | Promise<ValidationError[] | ValidationError | string | true>
+  | Promise<ValidationError[] | ValidationError | string | true>;
 
 /**
  * A type helper used to define a group of validators. The type of the
@@ -4012,45 +4177,45 @@ export declare type Validator<T = any, Value = any> = (
  * @internal
  */
 export declare type Validators = Partial<{
-  [P in RuleSpec['flag']]: Validator<
+  [P in RuleSpec["flag"]]: Validator<
     Exclude<
       ConditionalIndexAccess<
         Extract<
           RuleSpec,
           {
-            flag: P
+            flag: P;
           }
         >,
-        'constraint'
+        "constraint"
       >,
       FieldReference
     >
-  >
-}>
+  >;
+}>;
 
 /** @beta */
 export declare interface WeakCrossDatasetReferenceValue extends CrossDatasetReferenceValue {
-  _weak: true
+  _weak: true;
 }
 
 /** @beta */
 export declare interface WeakGlobalDocumentReferenceValue extends GlobalDocumentReferenceValue {
-  _weak: true
+  _weak: true;
 }
 
 /** @internal */
 export declare interface WeakReference extends Reference {
-  _weak: true
+  _weak: true;
 }
 
 /** @beta */
 export declare interface WidenInitialValue {
-  initialValue?: InitialValueProperty<any, any>
+  initialValue?: InitialValueProperty<any, any>;
 }
 
 /** @beta */
 export declare interface WidenValidation {
-  validation?: SchemaValidationValue
+  validation?: SchemaValidationValue;
 }
 
-export {}
+export {};