@portabletext/editor 1.48.7 → 1.48.8

package/lib/utils/index.d.cts

@@ -1,21 +1,10 @@
 import type {Patch} from '@portabletext/patches'
-import type {
-  ArraySchemaType,
-  BlockDecoratorDefinition,
-  BlockListDefinition,
-  BlockStyleDefinition,
-  ObjectSchemaType,
-  Path,
-  PortableTextChild,
-  PortableTextListBlock,
-  PortableTextTextBlock,
-} from '@sanity/types'
+import {ClientPerspective, SanityClient} from '@sanity/client'
 import {
-  KeyedSegment,
-  PortableTextBlock,
-  PortableTextObject,
-  PortableTextSpan,
+  PortableTextObject as PortableTextObject_2,
+  PortableTextSpan as PortableTextSpan_2,
 } from '@sanity/types'
+import {ComponentType, ElementType, ReactNode} from 'react'
 import type {
   FocusEvent as FocusEvent_2,
   KeyboardEvent as KeyboardEvent_2,
@@ -216,6 +205,277 @@ declare const abstractBehaviorEventTypes: readonly [
   'style.toggle',
 ]
 
+/**
+ * Types of array actions that can be performed
+ * @beta
+ */
+declare type ArrayActionName =
+  /**
+   * Add any item to the array at any position
+   */
+  | 'add'
+  /**
+   * Add item after an existing item
+   */
+  | 'addBefore'
+  /**
+   * Add item after an existing item
+   */
+  | 'addAfter'
+  /**
+   * Remove any item
+   */
+  | 'remove'
+  /**
+   * Duplicate item
+   */
+  | 'duplicate'
+  /**
+   * Copy item
+   */
+  | 'copy'
+
+/** @public */
+declare interface ArrayDefinition extends BaseSchemaDefinition {
+  type: 'array'
+  of: ArrayOfType[]
+  initialValue?: InitialValueProperty<any, unknown[]>
+  validation?: ValidationBuilder<ArrayRule<unknown[]>, unknown[]>
+  options?: ArrayOptions
+}
+
+/** @public */
+declare type ArrayOfEntry<T> = Omit<T, 'name' | 'hidden'> & {
+  name?: string
+}
+
+/** @public */
+declare type ArrayOfType<
+  TType extends IntrinsicTypeName = IntrinsicTypeName,
+  TAlias extends IntrinsicTypeName | undefined = undefined,
+> =
+  | IntrinsicArrayOfDefinition[TType]
+  | ArrayOfEntry<TypeAliasDefinition<string, TAlias>>
+
+/** @public */
+declare interface ArrayOptions<V = unknown>
+  extends SearchConfiguration,
+    BaseSchemaTypeOptions {
+  list?: TitledListValue<V>[] | V[]
+  layout?: 'list' | 'tags' | 'grid'
+  /** @deprecated This option does not have any effect anymore */
+  direction?: 'horizontal' | 'vertical'
+  sortable?: boolean
+  modal?: {
+    type?: 'dialog' | 'popover'
+    width?: number | 'auto'
+  }
+  /** @alpha This API may change */
+  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
+  /**
+   * A list of array actions to disable
+   * Possible options are defined by {@link ArrayActionName}
+   * @beta
+   */
+  disableActions?: ArrayActionName[]
+}
+
+/** @public */
+declare interface ArrayRule<Value> extends RuleDef<ArrayRule<Value>, Value> {
+  min: (length: number | FieldReference) => ArrayRule<Value>
+  max: (length: number | FieldReference) => ArrayRule<Value>
+  length: (length: number | FieldReference) => ArrayRule<Value>
+  unique: () => ArrayRule<Value>
+}
+
+/** @public */
+declare interface ArraySchemaType<V = unknown> extends BaseSchemaType {
+  jsonType: 'array'
+  of: (Exclude<SchemaType, ArraySchemaType> | ReferenceSchemaType)[]
+  options?: ArrayOptions<V> & {
+    layout?: V extends string ? 'tag' : 'grid'
+  }
+}
+
+/** @public */
+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
+}
+
+/** @public */
+declare type AssetFromSource = {
+  kind: 'assetDocumentId' | 'file' | 'base64' | 'url'
+  value: string | File_2
+  assetDocumentProps?: ImageAsset
+  mediaLibraryProps?: {
+    mediaLibraryId: string
+    assetId: string
+    assetInstanceId: string
+  }
+}
+
+/** @public */
+declare interface AssetSource {
+  name: string
+  /** @deprecated provide `i18nKey` instead */
+  title?: string
+  i18nKey?: string
+  component: ComponentType<AssetSourceComponentProps>
+  icon?: ComponentType<EmptyProps>
+  /** @beta */
+  uploader?: AssetSourceUploader
+}
+
+/** @public */
+declare interface AssetSourceComponentProps {
+  action?: 'select' | 'upload'
+  assetSource: AssetSource
+  assetType?: 'file' | 'image'
+  accept: string
+  selectionType: 'single'
+  dialogHeaderTitle?: React.ReactNode
+  selectedAssets: Asset[]
+  onClose: () => void
+  onSelect: (assetFromSource: AssetFromSource[]) => void
+}
+
+/** @public */
+declare interface AssetSourceSpec {
+  id: string
+  name: string
+  url?: string
+}
+
+/** @beta */
+declare interface AssetSourceUploader {
+  upload(
+    files: globalThis.File[],
+    options?: {
+      /**
+       * 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
+      /**
+       * 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
+    },
+  ): AssetSourceUploadFile[]
+  /**
+   * Abort the upload of a file
+   */
+  abort(file?: AssetSourceUploadFile): void
+  /**
+   * Get the files that are currently being uploaded
+   */
+  getFiles(): AssetSourceUploadFile[]
+  /**
+   * Subscribe to upload events from the uploader
+   */
+  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
+    },
+  ): void
+  /**
+   * Reset the uploader (clear files). Should be called by the uploader when all files are done.
+   */
+  reset(): void
+}
+
+/** @beta */
+declare type AssetSourceUploadEvent =
+  | AssetSourceUploadEventProgress
+  | AssetSourceUploadEventStatus
+  | AssetSourceUploadEventAllComplete
+  | AssetSourceUploadEventError
+  | AssetSourceUploadEventAbort
+
+/**
+ * Emitted when all files are done, either successfully, aborted or with errors
+ * @beta */
+declare type AssetSourceUploadEventAbort = {
+  type: 'abort'
+  /**
+   * Files aborted
+   */
+  files: AssetSourceUploadFile[]
+}
+
+/**
+ * Emitted when all files are done, either successfully, aborted or with errors
+ * @beta */
+declare type AssetSourceUploadEventAllComplete = {
+  type: 'all-complete'
+  files: AssetSourceUploadFile[]
+}
+
+/**
+ * Emitted when all files are done, either successfully, aborted or with errors
+ * @beta */
+declare type AssetSourceUploadEventError = {
+  type: 'error'
+  /**
+   * Files errored
+   */
+  files: AssetSourceUploadFile[]
+}
+
+/**
+ * Emitted when a file upload is progressing
+ * @beta */
+declare type AssetSourceUploadEventProgress = {
+  type: 'progress'
+  file: AssetSourceUploadFile
+  progress: number
+}
+
+/**
+ * Emitted when a file upload is changing status
+ * @beta */
+declare type AssetSourceUploadEventStatus = {
+  type: 'status'
+  file: AssetSourceUploadFile
+  status: AssetSourceUploadFile['status']
+}
+
+/** @beta */
+declare interface AssetSourceUploadFile {
+  id: string
+  file: globalThis.File
+  progress: number
+  status: 'pending' | 'uploading' | 'complete' | 'error' | 'aborted'
+  error?: Error
+  result?: unknown
+}
+
 /**
  * @public
  */
@@ -224,6 +484,60 @@ declare type BaseDefinition = {
   title?: string
 }
 
+/** @public */
+declare interface BaseSchemaDefinition {
+  name: string
+  title?: string
+  description?: string | React.JSX.Element
+  hidden?: ConditionalProperty
+  readOnly?: ConditionalProperty
+  icon?: ComponentType | ReactNode
+  validation?: unknown
+  initialValue?: unknown
+  deprecated?: DeprecatedProperty
+}
+
+/** @public */
+declare interface BaseSchemaType extends Partial<DeprecationConfiguration> {
+  name: string
+  title?: string
+  description?: string
+  type?: SchemaType
+  liveEdit?: boolean
+  readOnly?: ConditionalProperty
+  hidden?: ConditionalProperty
+  icon?: ComponentType
+  initialValue?: InitialValueProperty<any, any>
+  validation?: SchemaValidationValue
+  preview?: PreviewConfig
+  /** @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>
+  }
+  /**
+   * @deprecated This will be removed.
+   */
+  placeholder?: string
+}
+
+/**
+ * `BaseOptions` applies to all type options.
+ *
+ *  It can be extended by interface declaration merging in plugins to provide generic options to all types and fields.
+ *
+ *  @public
+ *  */
+declare interface BaseSchemaTypeOptions {
+  sanityCreate?: SanityCreateOptions
+}
+
 /**
  * @beta
  */
@@ -309,6 +623,142 @@ declare type BehaviorGuard<TBehaviorEvent, TGuardResponse> = (payload: {
   event: TBehaviorEvent
 }) => TGuardResponse | false
 
+/**
+ * Schema definition for text block decorators.
+ *
+ * @public
+ * @example The default set of decorators
+ * ```ts
+ * {
+ *   name: 'blockContent',
+ *   title: 'Content',
+ *   type: 'array',
+ *   of: [
+ *     {
+ *       type: 'block',
+ *       marks: {
+ *         decorators: [
+ *           {title: 'Strong', value: 'strong'},
+ *           {title: 'Emphasis', value: 'em'},
+ *           {title: 'Underline', value: 'underline'},
+ *           {title: 'Strike', value: 'strike'},
+ *           {title: 'Code', value: 'code'},
+ *         ]
+ *       }
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+declare interface BlockDecoratorDefinition {
+  title: string
+  i18nTitleKey?: string
+  value: string
+  icon?: ReactNode | ComponentType
+}
+
+/**
+ * Schema definition for text blocks.
+ *
+ * @public
+ * @example the default block definition
+ * ```ts
+ * {
+ *   name: 'blockContent',
+ *   title: 'Content',
+ *   type: 'array',
+ *   of: [
+ *     {
+ *       type: 'block',
+ *       marks: {
+ *         decorators: [
+ *           {title: 'Strong', value: 'strong'},
+ *           {title: 'Emphasis', value: 'em'},
+ *           {title: 'Underline', value: 'underline'},
+ *           {title: 'Strike', value: 'strike'},
+ *           {title: 'Code', value: 'code'},
+ *         ],
+ *         annotations: [
+ *           {
+ *             type: 'object',
+ *             name: 'link',
+ *             fields: [
+ *               {
+ *                 type: 'string',
+ *                 name: 'href',
+ *               },
+ *             ],
+ *           },
+ *         ]
+ *       },
+ *       styles: [
+ *         {title: 'Normal', value: 'normal'},
+ *         {title: 'H1', value: 'h1'},
+ *         {title: 'H2', value: 'h2'},
+ *         {title: 'H3', value: 'h3'},
+ *         {title: 'H4', value: 'h4'},
+ *         {title: 'H5', value: 'h5'},
+ *         {title: 'H6', value: 'h6'},
+ *         {title: 'Quote', value: 'blockquote'}
+ *       ],
+ *       lists: [
+ *         {title: 'Bullet', value: 'bullet'},
+ *         {title: 'Number', value: 'number'},
+ *       ],
+ *     },
+ *   ]
+ * }
+ * ```
+ */
+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[]>
+}
+
+/**
+ * Schema definition for a text block list style.
+ *
+ * @public
+ * @example The defaults lists
+ * ```ts
+ * {
+ *   name: 'blockContent',
+ *   title: 'Content',
+ *   type: 'array',
+ *   of: [
+ *     {
+ *       type: 'block',
+ *       lists: [
+ *         {title: 'Bullet', value: 'bullet'},
+ *         {title: 'Number', value: 'number'},
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ */
+declare interface BlockListDefinition {
+  title: string
+  i18nTitleKey?: string
+  value: string
+  icon?: ReactNode | ComponentType
+}
+
+/**
+ * Schema definition for text block marks (decorators and annotations).
+ *
+ * @public */
+declare interface BlockMarksDefinition {
+  decorators?: BlockDecoratorDefinition[]
+  annotations?: ArrayOfType<'object' | 'reference'>[]
+}
+
 /**
  * @beta
  */
@@ -321,11 +771,11 @@ declare type BlockOffset = {
  * @public
  */
 export declare function blockOffsetsToSelection({
-  value,
+  context,
   offsets,
   backward,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   offsets: {
     anchor: BlockOffset
     focus: BlockOffset
@@ -337,10 +787,10 @@ export declare function blockOffsetsToSelection({
  * @public
  */
 export declare function blockOffsetToBlockSelectionPoint({
-  value,
+  context,
   blockOffset,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'value'>
   blockOffset: BlockOffset
 }): EditorSelectionPoint | undefined
 
@@ -348,11 +798,11 @@ export declare function blockOffsetToBlockSelectionPoint({
  * @public
  */
 export declare function blockOffsetToSelectionPoint({
-  value,
+  context,
   blockOffset,
   direction,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   blockOffset: BlockOffset
   direction: 'forward' | 'backward'
 }): EditorSelectionPoint | undefined
@@ -361,11 +811,11 @@ export declare function blockOffsetToSelectionPoint({
  * @public
  */
 export declare function blockOffsetToSpanSelectionPoint({
-  value,
+  context,
   blockOffset,
   direction,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   blockOffset: BlockOffset
   direction: 'forward' | 'backward'
 }):
@@ -375,18 +825,116 @@ export declare function blockOffsetToSpanSelectionPoint({
     }
   | undefined
 
+/**
+ * Schema options for a Block schema definition
+ * @public */
+declare interface BlockOptions extends BaseSchemaTypeOptions {
+  /**
+   * Turn on or off the builtin browser spellchecking. Default is on.
+   */
+  spellCheck?: boolean
+  unstable_whitespaceOnPasteMode?: 'preserve' | 'normalize' | 'remove'
+}
+
+/** @public */
+declare interface BlockRule extends RuleDef<BlockRule, any[]> {}
+
+/**
+ * Schema definition for a text block style.
+ * A text block may have a block style like 'header', 'normal', 'lead'
+ * attached to it, which is stored on the `.style` property for that block.
+ *
+ * @public
+ * @remarks The first defined style will become the default style.´´
+ * @example The default set of styles
+ * ```ts
+ * {
+ *   name: 'blockContent',
+ *   title: 'Content',
+ *   type: 'array',
+ *   of: [
+ *     {
+ *       type: 'block',
+ *       styles: [
+ *         {title: 'Normal', value: 'normal'},
+ *         {title: 'H1', value: 'h1'},
+ *         {title: 'H2', value: 'h2'},
+ *         {title: 'H3', value: 'h3'},
+ *         {title: 'H4', value: 'h4'},
+ *         {title: 'H5', value: 'h5'},
+ *         {title: 'H6', value: 'h6'},
+ *         {title: 'Quote', value: 'blockquote'}
+ *       ]
+ *     }
+ *   ]
+ * }
+ * ```
+ * @example Example of defining a block type with custom styles and render components.
+ * ```ts
+ * defineArrayMember({
+ *   type: 'block',
+ *   styles: [
+ *     {
+ *       title: 'Paragraph',
+ *       value: 'paragraph',
+ *       component: ParagraphStyle,
+ *     },
+ *     {
+ *       title: 'Lead',
+ *       value: 'lead',
+ *       component: LeadStyle,
+ *     },
+ *     {
+ *       title: 'Heading',
+ *       value: 'heading',
+ *       component: HeadingStyle,
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+declare interface BlockStyleDefinition {
+  title: string
+  value: string
+  i18nTitleKey?: string
+  icon?: ReactNode | ComponentType
+}
+
 declare type BlockWithOptionalKey =
   | TextBlockWithOptionalKey
   | ObjectBlockWithOptionalKey
 
+/** @public */
+declare interface BooleanDefinition extends BaseSchemaDefinition {
+  type: 'boolean'
+  options?: BooleanOptions
+  initialValue?: InitialValueProperty<any, boolean>
+  validation?: ValidationBuilder<BooleanRule, boolean>
+}
+
+/** @public */
+declare interface BooleanOptions extends BaseSchemaTypeOptions {
+  layout?: 'switch' | 'checkbox'
+}
+
+/** @public */
+declare interface BooleanRule extends RuleDef<BooleanRule, boolean> {}
+
+/** @public */
+declare interface BooleanSchemaType extends BaseSchemaType {
+  jsonType: 'boolean'
+  options?: BooleanOptions
+  initialValue?: InitialValueProperty<any, boolean>
+}
+
 /**
  * @public
  */
 export declare function childSelectionPointToBlockOffset({
-  value,
+  context,
   selectionPoint,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   selectionPoint: EditorSelectionPoint
 }): BlockOffset | undefined
 
@@ -413,6 +961,35 @@ declare type ClipboardBehaviorEvent =
       position: Pick<EventPosition, 'selection'>
     }
 
+/** @public */
+declare interface CollapseOptions {
+  collapsed?: boolean
+  collapsible?: boolean
+  /**
+   * @deprecated Use `collapsible` instead
+   */
+  collapsable?: boolean
+}
+
+/** @public */
+declare type ConditionalProperty =
+  | boolean
+  | ConditionalPropertyCallback
+  | undefined
+
+/** @public */
+declare type ConditionalPropertyCallback = (
+  context: ConditionalPropertyCallbackContext,
+) => boolean
+
+/** @public */
+declare interface ConditionalPropertyCallbackContext {
+  document: SanityDocument | undefined
+  parent: any
+  value: any
+  currentUser: Omit<CurrentUser, 'role'> | null
+}
+
 declare type Converter<TMIMEType extends MIMEType = MIMEType> = {
   mimeType: TMIMEType
   serialize: Serializer<TMIMEType>
@@ -451,6 +1028,46 @@ declare type ConverterEvent<TMIMEType extends MIMEType = MIMEType> =
       mimeType: TMIMEType
     }
 
+/** @public */
+declare interface CrossDatasetReferenceDefinition extends BaseSchemaDefinition {
+  type: 'crossDatasetReference'
+  weak?: boolean
+  to: {
+    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
+  /**
+   * @deprecated Cross-project references are no longer supported, only cross-dataset
+   */
+  projectId?: string
+}
+
+/** @public */
+declare interface CurrentUser {
+  id: string
+  name: string
+  email: string
+  profileImage?: string
+  provider?: string
+  /** @deprecated use `roles` instead */
+  role: string
+  roles: Role[]
+}
+
 /**
  * @beta
  */
@@ -475,6 +1092,89 @@ declare type CustomBehaviorEventType<
   TType extends string = '',
 > = TType extends '' ? `${TNamespace}` : `${TNamespace}.${TType}`
 
+/** @public */
+declare interface CustomValidator<T = unknown> {
+  (
+    value: T,
+    context: ValidationContext,
+  ): CustomValidatorResult | Promise<CustomValidatorResult>
+  bypassConcurrencyLimit?: boolean
+}
+
+/** @public */
+declare type CustomValidatorResult =
+  | true
+  | string
+  | ValidationError
+  | ValidationError[]
+  | LocalizedValidationMessages
+
+/** @public */
+declare interface DateDefinition extends BaseSchemaDefinition {
+  type: 'date'
+  options?: DateOptions
+  placeholder?: string
+  validation?: ValidationBuilder<DateRule, string>
+  initialValue?: InitialValueProperty<any, string>
+}
+
+/** @public */
+declare interface DateOptions extends BaseSchemaTypeOptions {
+  dateFormat?: string
+}
+
+/** @public */
+declare interface DateRule extends RuleDef<DateRule, string> {
+  /**
+   * @param minDate - Minimum date (inclusive). minDate should be in ISO 8601 format.
+   */
+  min: (minDate: string | FieldReference) => DateRule
+  /**
+   * @param maxDate - Maximum date (inclusive). maxDate should be in ISO 8601 format.
+   */
+  max: (maxDate: string | FieldReference) => DateRule
+}
+
+/** @public */
+declare interface DatetimeDefinition extends BaseSchemaDefinition {
+  type: 'datetime'
+  options?: DatetimeOptions
+  placeholder?: string
+  validation?: ValidationBuilder<DatetimeRule, string>
+  initialValue?: InitialValueProperty<any, string>
+}
+
+/** @public */
+declare interface DatetimeOptions extends BaseSchemaTypeOptions {
+  dateFormat?: string
+  timeFormat?: string
+  timeStep?: number
+}
+
+/** @public */
+declare interface DatetimeRule extends RuleDef<DatetimeRule, string> {
+  /**
+   * @param minDate - Minimum date (inclusive). minDate should be in ISO 8601 format.
+   */
+  min: (minDate: string | FieldReference) => DatetimeRule
+  /**
+   * @param maxDate - Maximum date (inclusive). maxDate should be in ISO 8601 format.
+   */
+  max: (maxDate: string | FieldReference) => DatetimeRule
+}
+
+/** @public */
+declare interface DeprecatedProperty {
+  reason: string
+}
+
+/**
+ * @public
+ */
+declare interface DeprecationConfiguration {
+  deprecated: DeprecatedProperty
+}
+
 declare type Deserializer<TMIMEType extends MIMEType> = ({
   snapshot,
   event,
@@ -487,6 +1187,40 @@ declare type Deserializer<TMIMEType extends MIMEType> = ({
   'deserialization.success' | 'deserialization.failure'
 >
 
+/** @public */
+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>>
+  /** @deprecated Unused. Use the new field-level search config. */
+  __experimental_search?: {
+    path: string
+    weight: number
+    mapWith?: string
+  }[]
+  /** @alpha */
+  __experimental_omnisearch_visibility?: boolean
+  /**
+   * Determines whether the large preview title is displayed in the document pane form
+   * @alpha
+   * */
+  __experimental_formPreviewTitle?: boolean
+}
+
+/**
+ * This exists only to allow for extensions using declaration-merging.
+ *
+ * @public
+ */
+declare interface DocumentOptions extends BaseSchemaTypeOptions {}
+
+/** @public */
+declare interface DocumentRule extends RuleDef<DocumentRule, SanityDocument> {}
+
 declare type DragBehaviorEvent =
   | {
       type: StrictExtract<NativeBehaviorEventType, 'drag.dragstart'>
@@ -5198,6 +5932,31 @@ declare type EditorSnapshot = {
   }
 }
 
+/** @public */
+declare interface EmailDefinition extends BaseSchemaDefinition {
+  type: 'email'
+  options?: EmailOptions
+  placeholder?: string
+  validation?: ValidationBuilder<EmailRule, string>
+  initialValue?: InitialValueProperty<any, string>
+}
+
+/** @public */
+declare interface EmailOptions extends BaseSchemaTypeOptions {}
+
+/** @public */
+declare interface EmailRule extends RuleDef<EmailRule, string> {}
+
+/** @public */
+declare interface EmptyProps {}
+
+/** @public */
+declare interface EnumListProps<V = unknown> {
+  list?: Array<TitledListValue<V> | V>
+  layout?: 'radio' | 'dropdown'
+  direction?: 'horizontal' | 'vertical'
+}
+
 declare type EventPosition = {
   block: 'start' | 'end'
   /**
@@ -5210,26 +5969,203 @@ declare type EventPosition = {
 declare type ExtractNamespace<TType extends string> =
   TType extends `${infer Namespace}.${string}` ? Namespace : TType
 
+/**
+ * The shape of a field definition. Note, it's recommended to use the
+ * `defineField` function instead of using this type directly.
+ *
+ * Where `defineField` infers the exact field type,
+ * FieldDefinition is a compromise union of all types a field can have.
+ *
+ * A field definition can be a reference to another registered top-level type
+ * or a inline type definition.
+ *
+ * @public
+ */
+declare type FieldDefinition<
+  TType extends IntrinsicTypeName = IntrinsicTypeName,
+  TAlias extends IntrinsicTypeName | undefined = undefined,
+> = (InlineFieldDefinition[TType] | TypeAliasDefinition<string, TAlias>) &
+  FieldDefinitionBase
+
+/** @public */
+declare interface FieldDefinitionBase {
+  fieldset?: string
+  group?: string | string[]
+}
+
+/** @public */
+declare interface FieldGroup {
+  name: string
+  icon?: ComponentType
+  title?: string
+  description?: string
+  i18n?: I18nTextRecord<'title'>
+  hidden?: ConditionalProperty
+  default?: boolean
+  fields?: ObjectField[]
+}
+
+/** @public */
+declare type FieldGroupDefinition = {
+  name: string
+  title?: string
+  hidden?: ConditionalProperty
+  icon?: ComponentType
+  default?: boolean
+  i18n?: I18nTextRecord<'title'>
+}
+
+/**
+ * Holds a reference to a different field
+ * NOTE: Only use this through {@link Rule.valueOfField}
+ *
+ * @public
+ */
+declare interface FieldReference {
+  type: symbol
+  path: string | string[]
+}
+
+/** @public */
+declare type FieldRules = {
+  [fieldKey: string]: SchemaValidationValue
+}
+
+/** @public */
+declare type Fieldset = SingleFieldSet | MultiFieldSet
+
+/** @public */
+declare type FieldsetDefinition = {
+  name: string
+  title?: string
+  description?: string
+  group?: string
+  hidden?: ConditionalProperty
+  readOnly?: ConditionalProperty
+  options?: ObjectOptions
+}
+
+/** @public */
+declare interface File_2 {
+  [key: string]: unknown
+  asset?: Reference
+}
+
+/** @public */
+declare interface FileDefinition
+  extends Omit<
+    ObjectDefinition,
+    'type' | 'fields' | 'options' | 'groups' | 'validation'
+  > {
+  type: 'file'
+  fields?: ObjectDefinition['fields']
+  options?: FileOptions
+  validation?: ValidationBuilder<FileRule, FileValue>
+  initialValue?: InitialValueProperty<any, FileValue>
+}
+
+/** @public */
+declare interface FileOptions extends ObjectOptions {
+  storeOriginalFilename?: boolean
+  accept?: string
+  sources?: AssetSource[]
+}
+
+/** @public */
+declare interface FileRule extends RuleDef<FileRule, FileValue> {
+  /**
+   * Require a file field has an asset.
+   *
+   * @example
+   * ```ts
+   * defineField({
+   *  name: 'file',
+   *  title: 'File',
+   *  type: 'file',
+   *  validation: (Rule) => Rule.required().assetRequired(),
+   * })
+   * ```
+   */
+  assetRequired(): FileRule
+}
+
+/** @public */
+declare interface FileSchemaType extends Omit<ObjectSchemaType, 'options'> {
+  options?: FileOptions
+}
+
+/** @public */
+declare interface FileValue {
+  asset?: Reference
+  [index: string]: unknown
+}
+
+/** @public */
+declare interface GeopointDefinition extends BaseSchemaDefinition {
+  type: 'geopoint'
+  options?: GeopointOptions
+  validation?: ValidationBuilder<GeopointRule, GeopointValue>
+  initialValue?: InitialValueProperty<any, Omit<GeopointValue, '_type'>>
+}
+
+/** @public */
+declare interface GeopointOptions extends BaseSchemaTypeOptions {}
+
+/** @public */
+declare interface GeopointRule extends RuleDef<GeopointRule, GeopointValue> {}
+
+/**
+ * Geographical point representing a pair of latitude and longitude coordinates,
+ * stored as degrees, in the World Geodetic System 1984 (WGS 84) format. Also
+ * includes an optional `alt` property representing the altitude in meters.
+ *
+ * @public
+ */
+declare interface GeopointValue {
+  /**
+   * Type of the object. Must be `geopoint`.
+   */
+  _type: 'geopoint'
+  /**
+   * Latitude in degrees
+   */
+  lat: number
+  /**
+   * Longitude in degrees
+   */
+  lng: number
+  /**
+   * Altitude in meters
+   */
+  alt?: number
+}
+
 /**
  * @public
  */
 export declare function getBlockEndPoint({
-  node,
-  path,
+  context,
+  block,
 }: {
-  node: PortableTextBlock
-  path: [KeyedSegment]
+  context: Pick<EditorContext, 'schema'>
+  block: {
+    node: PortableTextBlock
+    path: [KeyedSegment]
+  }
 }): EditorSelectionPoint
 
 /**
  * @public
  */
 export declare function getBlockStartPoint({
-  node,
-  path,
+  context,
+  block,
 }: {
-  node: PortableTextBlock
-  path: [KeyedSegment]
+  context: Pick<EditorContext, 'schema'>
+  block: {
+    node: PortableTextBlock
+    path: [KeyedSegment]
+  }
 }): EditorSelectionPoint
 
 /**
@@ -5259,6 +6195,23 @@ export declare function getSelectionStartPoint<
  */
 export declare function getTextBlockText(block: PortableTextTextBlock): string
 
+/** @public */
+declare interface GlobalDocumentReferenceDefinition
+  extends BaseSchemaDefinition {
+  type: 'globalDocumentReference'
+  weak?: boolean
+  to: {
+    type: string
+    title?: string
+    icon?: ComponentType
+    preview?: PreviewConfig
+  }[]
+  resourceType: string
+  resourceId: string
+  options?: ReferenceOptions
+  studioUrl?: (document: {id: string; type?: string}) => string | null
+}
+
 declare type HasTag = ReturnType<EditorActor['getSnapshot']>['hasTag']
 
 declare interface History_2 {
@@ -5271,6 +6224,178 @@ declare type HistoryItem = {
   timestamp: Date
 }
 
+/** @public */
+declare interface HotspotOptions {
+  previews?: HotspotPreview[]
+}
+
+/** @public */
+declare interface HotspotPreview {
+  title: string
+  aspectRatio: number
+}
+
+/** @public */
+declare type I18nTextRecord<K extends string> = {
+  [P in K]?: {
+    key: string
+    ns: string
+  }
+}
+
+/** @public */
+declare interface ImageAsset extends Asset {
+  _type: 'sanity.imageAsset'
+  metadata: ImageMetadata
+}
+
+/** @public */
+declare interface ImageCrop {
+  _type?: 'sanity.imageCrop'
+  left: number
+  bottom: number
+  right: number
+  top: number
+}
+
+/** @public */
+declare interface ImageDefinition
+  extends Omit<
+    ObjectDefinition,
+    'type' | 'fields' | 'options' | 'groups' | 'validation'
+  > {
+  type: 'image'
+  fields?: FieldDefinition[]
+  options?: ImageOptions
+  validation?: ValidationBuilder<ImageRule, ImageValue>
+  initialValue?: InitialValueProperty<any, ImageValue>
+}
+
+/** @public */
+declare interface ImageDimensions {
+  _type: 'sanity.imageDimensions'
+  height: number
+  width: number
+  aspectRatio: number
+}
+
+/** @public */
+declare interface ImageHotspot {
+  _type?: 'sanity.imageHotspot'
+  width: number
+  height: number
+  x: number
+  y: number
+}
+
+/** @public */
+declare interface ImageMetadata {
+  [key: string]: unknown
+  _type: 'sanity.imageMetadata'
+  dimensions: ImageDimensions
+  palette?: ImagePalette
+  lqip?: string
+  blurHash?: string
+  hasAlpha: boolean
+  isOpaque: boolean
+}
+
+/** @public */
+declare type ImageMetadataType =
+  | 'blurhash'
+  | 'lqip'
+  | 'palette'
+  | 'exif'
+  | 'image'
+  | 'location'
+
+/** @public */
+declare interface ImageOptions extends FileOptions {
+  metadata?: ImageMetadataType[]
+  hotspot?: boolean | HotspotOptions
+}
+
+/** @public */
+declare interface ImagePalette {
+  _type: 'sanity.imagePalette'
+  darkMuted?: ImageSwatch
+  darkVibrant?: ImageSwatch
+  dominant?: ImageSwatch
+  lightMuted?: ImageSwatch
+  lightVibrant?: ImageSwatch
+  muted?: ImageSwatch
+  vibrant?: ImageSwatch
+}
+
+/** @public */
+declare interface ImageRule extends RuleDef<ImageRule, ImageValue> {
+  /**
+   * Require an image field has an asset.
+   *
+   * @example
+   * ```ts
+   * defineField({
+   *  name: 'image',
+   *  title: 'Image',
+   *  type: 'image',
+   *  validation: (Rule) => Rule.required().assetRequired(),
+   * })
+   * ```
+   */
+  assetRequired(): ImageRule
+}
+
+/** @public */
+declare interface ImageSwatch {
+  _type: 'sanity.imagePaletteSwatch'
+  background: string
+  foreground: string
+  population: number
+  title?: string
+}
+
+/** @public */
+declare interface ImageValue extends FileValue {
+  crop?: ImageCrop
+  hotspot?: ImageHotspot
+  [index: string]: unknown
+}
+
+/** @public */
+declare type IndexTuple = [number | '', number | '']
+
+/** @public */
+declare type InitialValueProperty<Params, Value> =
+  | Value
+  | InitialValueResolver<Params, Value>
+  | undefined
+
+/** @public */
+declare type InitialValueResolver<Params, Value> = (
+  params: Params | undefined,
+  context: InitialValueResolverContext,
+) => Promise<Value> | Value
+
+/** @public */
+declare interface InitialValueResolverContext {
+  projectId: string
+  dataset: string
+  schema: Schema
+  currentUser: CurrentUser | null
+  getClient: (options: {apiVersion: string}) => SanityClient
+}
+
+/** @public */
+declare type InlineFieldDefinition = {
+  [K in keyof IntrinsicDefinitions]: Omit<
+    IntrinsicDefinitions[K],
+    'initialValue' | 'validation'
+  > & {
+    validation?: SchemaValidationValue
+    initialValue?: InitialValueProperty<any, any>
+  }
+}
+
 /**
  * Used to represent native InputEvents that hold a DataTransfer object.
  *
@@ -5289,6 +6414,33 @@ declare type InputBehaviorEvent = {
   }
 }
 
+/** @alpha This API may change */
+declare interface InsertMenuOptions {
+  /**
+   * @defaultValue `'auto'`
+   * `filter: 'auto'` automatically turns on filtering if there are more than 5
+   * schema types added to the menu.
+   */
+  filter?: 'auto' | boolean
+  groups?: Array<{
+    name: string
+    title?: string
+    of?: Array<string>
+  }>
+  /** defaultValue `true` */
+  showIcons?: boolean
+  /** @defaultValue `[{name: 'list'}]` */
+  views?: Array<
+    | {
+        name: 'list'
+      }
+    | {
+        name: 'grid'
+        previewImageUrl?: (schemaTypeName: string) => string | undefined
+      }
+  >
+}
+
 declare type InsertPlacement = 'auto' | 'after' | 'before'
 
 declare type InternalPatchEvent = NamespaceEvent<PatchEvent, 'internal'> & {
@@ -5296,6 +6448,64 @@ declare type InternalPatchEvent = NamespaceEvent<PatchEvent, 'internal'> & {
   value: Array<PortableTextBlock>
 }
 
+/** @public */
+declare type IntrinsicArrayOfDefinition = {
+  [K in keyof IntrinsicDefinitions]: Omit<
+    ArrayOfEntry<IntrinsicDefinitions[K]>,
+    'validation' | 'initialValue'
+  > & {
+    validation?: SchemaValidationValue
+    initialValue?: InitialValueProperty<any, any>
+  }
+}
+
+/**
+ * `IntrinsicDefinitions` is a lookup map for "predefined" schema definitions.
+ * Schema types in `IntrinsicDefinitions` will have good type-completion and type-safety in {@link defineType},
+ * {@link defineField} and {@link defineArrayMember} once the `type` property is provided.
+ *
+ * By default, `IntrinsicDefinitions` contains all standard Sanity schema types (`array`, `string`, `number` ect),
+ * but it is an interface and as such, open for extension.
+ *
+ * This type can be extended using declaration merging; this way new entries can be added.
+ * See {@link defineType} for examples on how this can be accomplished.
+ *
+ * @see defineType
+ *
+ * @public
+ */
+declare interface IntrinsicDefinitions {
+  array: ArrayDefinition
+  block: BlockDefinition
+  boolean: BooleanDefinition
+  date: DateDefinition
+  datetime: DatetimeDefinition
+  document: DocumentDefinition
+  file: FileDefinition
+  geopoint: GeopointDefinition
+  image: ImageDefinition
+  number: NumberDefinition
+  object: ObjectDefinition
+  reference: ReferenceDefinition
+  crossDatasetReference: CrossDatasetReferenceDefinition
+  globalDocumentReference: GlobalDocumentReferenceDefinition
+  slug: SlugDefinition
+  string: StringDefinition
+  text: TextDefinition
+  url: UrlDefinition
+  email: EmailDefinition
+}
+
+/**
+ * A union of all intrinsic types allowed natively in the schema.
+ *
+ * @see IntrinsicDefinitions
+ *
+ * @public
+ */
+declare type IntrinsicTypeName =
+  IntrinsicDefinitions[keyof IntrinsicDefinitions]['type']
+
 /**
  * The editor has invalid data in the value that can be resolved by the user
  * @beta */
@@ -5322,7 +6532,10 @@ declare type InvalidValueResolution = {
 /**
  * @public
  */
-export declare function isEmptyTextBlock(block: PortableTextBlock): boolean
+export declare function isEmptyTextBlock(
+  context: Pick<EditorContext, 'schema'>,
+  block: PortableTextBlock,
+): boolean
 
 /**
  * @public
@@ -5386,6 +6599,27 @@ declare type KeyboardBehaviorEvent =
       >
     }
 
+/** @public */
+declare type KeyedSegment = {
+  _key: string
+}
+
+/**
+ * Holds localized validation messages for a given field.
+ *
+ * @example Custom message for English (US) and Norwegian (Bokmål):
+ * ```
+ * {
+ *   'en-US': 'Needs to start with a capital letter',
+ *   'no-NB': 'Må starte med stor bokstav',
+ * }
+ * ```
+ * @public
+ */
+declare interface LocalizedValidationMessages {
+  [locale: string]: string
+}
+
 /**
  * @beta
  */
@@ -5397,7 +6631,7 @@ export declare function mergeTextBlocks({
   context: Pick<EditorContext, 'keyGenerator' | 'schema'>
   targetBlock: PortableTextTextBlock
   incomingBlock: PortableTextTextBlock
-}): PortableTextTextBlock<PortableTextObject | PortableTextSpan>
+}): PortableTextTextBlock<PortableTextObject_2 | PortableTextSpan_2>
 
 declare type MIMEType = `${string}/${string}`
 
@@ -5406,6 +6640,21 @@ declare type MouseBehaviorEvent = {
   position: EventPosition
 }
 
+/** @public */
+declare interface MultiFieldSet {
+  name: string
+  title?: string
+  description?: string
+  single?: false
+  group?: string | string[]
+  options?: CollapseOptions & {
+    columns?: number
+  }
+  fields: ObjectField[]
+  hidden?: ConditionalProperty
+  readOnly?: ConditionalProperty
+}
+
 /**
  * @public
  */
@@ -5473,10 +6722,114 @@ declare const nativeBehaviorEventTypes: readonly [
   'mouse.click',
 ]
 
+/** @public */
+declare interface NumberDefinition extends BaseSchemaDefinition {
+  type: 'number'
+  options?: NumberOptions
+  placeholder?: string
+  validation?: ValidationBuilder<NumberRule, number>
+  initialValue?: InitialValueProperty<any, number>
+}
+
+/** @public */
+declare interface NumberOptions
+  extends EnumListProps<number>,
+    BaseSchemaTypeOptions {}
+
+/** @public */
+declare interface NumberRule extends RuleDef<NumberRule, number> {
+  min: (minNumber: number | FieldReference) => NumberRule
+  max: (maxNumber: number | FieldReference) => NumberRule
+  lessThan: (limit: number | FieldReference) => NumberRule
+  greaterThan: (limit: number | FieldReference) => NumberRule
+  integer: () => NumberRule
+  precision: (limit: number | FieldReference) => NumberRule
+  positive: () => NumberRule
+  negative: () => NumberRule
+}
+
+/** @public */
+declare interface NumberSchemaType extends BaseSchemaType {
+  jsonType: 'number'
+  options?: NumberOptions
+  initialValue?: InitialValueProperty<any, number>
+}
+
 declare type ObjectBlockWithOptionalKey = Omit<PortableTextObject, '_key'> & {
   _key?: PortableTextObject['_key']
 }
 
+/** @public */
+declare interface ObjectDefinition extends BaseSchemaDefinition {
+  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>>
+}
+
+/** @public */
+declare interface ObjectField<T extends SchemaType = SchemaType> {
+  name: string
+  fieldset?: string
+  group?: string | string[]
+  type: ObjectFieldType<T>
+}
+
+/** @public */
+declare type ObjectFieldType<T extends SchemaType = SchemaType> = T & {
+  hidden?: ConditionalProperty
+  readOnly?: ConditionalProperty
+}
+
+/** @public */
+declare interface ObjectOptions extends BaseSchemaTypeOptions {
+  collapsible?: boolean
+  collapsed?: boolean
+  columns?: number
+  modal?: {
+    type?: 'dialog' | 'popover'
+    width?: number | number[] | 'auto'
+  }
+}
+
+/** @public */
+declare interface ObjectRule
+  extends RuleDef<ObjectRule, Record<string, unknown>> {}
+
+/** @public */
+declare interface ObjectSchemaType extends BaseSchemaType {
+  jsonType: 'object'
+  fields: ObjectField[]
+  groups?: FieldGroup[]
+  fieldsets?: Fieldset[]
+  initialValue?: InitialValueProperty<any, Record<string, unknown>>
+  weak?: boolean
+  /** @deprecated Unused. Use the new field-level search config. */
+  __experimental_search?: {
+    path: (string | number)[]
+    weight: number
+    mapWith?: string
+  }[]
+  /** @alpha */
+  __experimental_omnisearch_visibility?: boolean
+  /** @alpha */
+  __experimental_actions?: string[]
+  /** @alpha */
+  __experimental_formPreviewTitle?: boolean
+  /**
+   * @beta
+   */
+  orderings?: SortOrdering[]
+  options?: any
+}
+
 /**
  * @public
  */
@@ -5491,6 +6844,12 @@ declare type PatchEvent = {
   patch: Patch
 }
 
+/** @public */
+declare type Path = PathSegment[]
+
+/** @public */
+declare type PathSegment = string | number | KeyedSegment | IndexTuple
+
 /**
  * @internal
  */
@@ -5500,9 +6859,21 @@ declare type PickFromUnion<
   TPickedTags extends TUnion[TTagKey],
 > = TUnion extends Record<TTagKey, TPickedTags> ? TUnion : never
 
-/** @beta */
-declare type PortableTextMemberSchemaTypes = {
-  annotations: (ObjectSchemaType & {
+/** @alpha */
+declare type PortableTextBlock = PortableTextTextBlock | PortableTextObject
+
+/** @alpha */
+declare type PortableTextChild = PortableTextObject | PortableTextSpan
+
+/** @alpha */
+declare interface PortableTextListBlock extends PortableTextTextBlock {
+  listItem: string
+  level: number
+}
+
+/** @beta */
+declare type PortableTextMemberSchemaTypes = {
+  annotations: (ObjectSchemaType & {
     i18nTitleKey?: string
   })[]
   block: ObjectSchemaType
@@ -5515,6 +6886,13 @@ declare type PortableTextMemberSchemaTypes = {
   lists: BlockListDefinition[]
 }
 
+/** @alpha */
+declare interface PortableTextObject {
+  _type: string
+  _key: string
+  [other: string]: unknown
+}
+
 declare interface PortableTextSlateEditor extends ReactEditor {
   _key: 'editor'
   _type: 'editor'
@@ -5548,6 +6926,162 @@ declare interface PortableTextSlateEditor extends ReactEditor {
   redo: () => void
 }
 
+/** @alpha */
+declare interface PortableTextSpan {
+  _key: string
+  _type: 'span'
+  text: string
+  marks?: string[]
+}
+
+/** @alpha */
+declare interface PortableTextTextBlock<
+  TChild = PortableTextSpan | PortableTextObject,
+> {
+  _type: string
+  _key: string
+  children: TChild[]
+  markDefs?: PortableTextObject[]
+  listItem?: string
+  style?: string
+  level?: number
+}
+
+/** @public */
+declare interface PrepareViewOptions {
+  /** @beta */
+  ordering?: SortOrdering
+}
+
+/** @public */
+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
+}
+
+/** @public */
+declare interface PreviewValue {
+  _id?: string
+  _createdAt?: string
+  _updatedAt?: string
+  title?: string
+  subtitle?: string
+  description?: string
+  media?: ReactNode | ElementType
+  imageUrl?: string
+}
+
+/** @public */
+declare interface Reference {
+  _type: string
+  _ref: string
+  _key?: string
+  _weak?: boolean
+  _strengthenOnPublish?: {
+    type: string
+    weak?: boolean
+    template?: {
+      id: string
+      params: Record<string, string | number | boolean>
+    }
+  }
+}
+
+/** @public */
+declare interface ReferenceBaseOptions extends BaseSchemaTypeOptions {
+  disableNew?: boolean
+}
+
+/** @public */
+declare interface ReferenceDefinition extends BaseSchemaDefinition {
+  type: 'reference'
+  to: ReferenceTo
+  weak?: boolean
+  options?: ReferenceOptions
+  validation?: ValidationBuilder<ReferenceRule, ReferenceValue>
+  initialValue?: InitialValueProperty<any, Omit<ReferenceValue, '_type'>>
+}
+
+/** @public */
+declare type ReferenceFilterOptions =
+  | ReferenceFilterResolverOptions
+  | ReferenceFilterQueryOptions
+
+/** @public */
+declare interface ReferenceFilterQueryOptions {
+  filter: string
+  filterParams?: Record<string, unknown>
+}
+
+/** @public */
+declare type ReferenceFilterResolver = (
+  context: ReferenceFilterResolverContext,
+) => ReferenceFilterSearchOptions | Promise<ReferenceFilterSearchOptions>
+
+/** @public */
+declare interface ReferenceFilterResolverContext {
+  document: SanityDocument
+  parent?: Record<string, unknown> | Record<string, unknown>[]
+  parentPath: Path
+  getClient: (options: {apiVersion: string}) => SanityClient
+}
+
+/** @public */
+declare interface ReferenceFilterResolverOptions {
+  filter?: ReferenceFilterResolver
+  filterParams?: never
+}
+
+/** @public */
+declare type ReferenceFilterSearchOptions = {
+  filter?: string
+  params?: Record<string, unknown>
+  tag?: string
+  maxFieldDepth?: number
+  strategy?: SearchStrategy
+  perspective?: ClientPerspective
+}
+
+/**
+ * Types are closed for extension. To add properties via declaration merging to this type,
+ * redeclare and add the properties to the interfaces that make up ReferenceOptions type.
+ *
+ * @see ReferenceFilterOptions
+ * @see ReferenceFilterResolverOptions
+ * @see ReferenceBaseOptions
+ *
+ * @public
+ */
+declare type ReferenceOptions = ReferenceBaseOptions & ReferenceFilterOptions
+
+/** @public */
+declare interface ReferenceRule
+  extends RuleDef<ReferenceRule, ReferenceValue> {}
+
+/** @public */
+declare interface ReferenceSchemaType
+  extends Omit<ObjectSchemaType, 'options'> {
+  jsonType: 'object'
+  to: ObjectSchemaType[]
+  weak?: boolean
+  options?: ReferenceOptions
+}
+
+/** @public */
+declare type ReferenceTo =
+  | SchemaTypeDefinition
+  | TypeReference
+  | Array<SchemaTypeDefinition | TypeReference>
+
+/** @public */
+declare type ReferenceValue = Reference
+
 /**************************************
  * Resolve behavior event
  **************************************/
@@ -5580,14 +7114,445 @@ export declare function reverseSelection<
   TEditorSelection extends NonNullable<EditorSelection> | null,
 >(selection: TEditorSelection): TEditorSelection
 
+/** @public */
+declare interface Role {
+  name: string
+  title: string
+  description?: string
+}
+
+/** @public */
+declare interface Rule {
+  /**
+   * @internal
+   * @deprecated internal use only
+   */
+  _type: RuleTypeConstraint | undefined
+  /**
+   * @internal
+   * @deprecated internal use only
+   */
+  _level: 'error' | 'warning' | 'info' | undefined
+  /**
+   * @internal
+   * @deprecated internal use only
+   */
+  _required: 'required' | 'optional' | undefined
+  /**
+   * @internal
+   * @deprecated internal use only
+   */
+  _typeDef: SchemaType | undefined
+  /**
+   * @internal
+   * @deprecated internal use only
+   */
+  _message: string | LocalizedValidationMessages | undefined
+  /**
+   * @internal
+   * @deprecated internal use only
+   */
+  _rules: RuleSpec[]
+  /**
+   * @internal
+   * @deprecated internal use only
+   */
+  _fieldRules: FieldRules | undefined
+  /**
+   * Takes in a path and returns an object with a symbol.
+   *
+   * When the validation lib sees this symbol, it will use the provided path to
+   * get a value from the current field's parent and use that value as the input
+   * to the Rule.
+   *
+   * The path that's given is forwarded to `lodash/get`
+   *
+   * ```js
+   * fields: [
+   * // ...
+   *   {
+   *     // ...
+   *     name: 'highestTemperature',
+   *     type: 'number',
+   *     validation: (Rule) => Rule.positive().min(Rule.valueOfField('lowestTemperature')),
+   *     // ...
+   *   },
+   * ]
+   * ```
+   */
+  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
+    },
+  ): 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
+    },
+  ): Rule
+  regex(
+    pattern: RegExp,
+    options: {
+      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
+  validate(
+    value: unknown,
+    options: ValidationContext & {
+      /**
+       * @deprecated Internal use only
+       * @internal
+       */
+      __internal?: {
+        customValidationConcurrencyLimiter?: {
+          ready: () => Promise<void>
+          release: () => void
+        }
+      }
+    },
+  ): Promise<ValidationMarker[]>
+}
+
+/** @public */
+declare type RuleBuilder<
+  T extends RuleDef<T, FieldValue>,
+  FieldValue = unknown,
+> = T | T[]
+
+/** @public */
+declare interface RuleDef<T, FieldValue = unknown> {
+  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
+}
+
+/** @public */
+declare type RuleSpec =
+  | {
+      flag: 'integer'
+    }
+  | {
+      flag: 'email'
+    }
+  | {
+      flag: 'unique'
+    }
+  | {
+      flag: 'reference'
+    }
+  | {
+      flag: 'type'
+      constraint: RuleTypeConstraint
+    }
+  | {
+      flag: 'all'
+      constraint: Rule[]
+    }
+  | {
+      flag: 'either'
+      constraint: Rule[]
+    }
+  | {
+      flag: 'presence'
+      constraint: 'optional' | 'required'
+    }
+  | {
+      flag: 'custom'
+      constraint: CustomValidator
+    }
+  | {
+      flag: 'min'
+      constraint: number | string
+    }
+  | {
+      flag: 'max'
+      constraint: number | string
+    }
+  | {
+      flag: 'length'
+      constraint: number
+    }
+  | {
+      flag: 'valid'
+      constraint: unknown[]
+    }
+  | {
+      flag: 'precision'
+      constraint: number
+    }
+  | {
+      flag: 'lessThan'
+      constraint: number
+    }
+  | {
+      flag: 'greaterThan'
+      constraint: number
+    }
+  | {
+      flag: 'stringCasing'
+      constraint: 'uppercase' | 'lowercase'
+    }
+  | {
+      flag: 'assetRequired'
+      constraint: {
+        assetType: 'asset' | 'image' | 'file'
+      }
+    }
+  | {
+      flag: 'regex'
+      constraint: {
+        pattern: RegExp
+        name?: string
+        invert: boolean
+      }
+    }
+  | {
+      flag: 'uri'
+      constraint: {
+        options: {
+          scheme: RegExp[]
+          allowRelative: boolean
+          relativeOnly: boolean
+          allowCredentials: boolean
+        }
+      }
+    }
+
+/** @public */
+declare type RuleTypeConstraint =
+  | 'Array'
+  | 'Boolean'
+  | 'Date'
+  | 'Number'
+  | 'Object'
+  | 'String'
+
+/**
+ * Options for configuring how Sanity Create interfaces with the type or field.
+ *
+ * @public
+ */
+declare interface SanityCreateOptions {
+  /** Set to true to exclude a type or field from appearing in Sanity Create */
+  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
+}
+
+/** @public */
+declare interface SanityDocument {
+  _id: string
+  _type: string
+  _createdAt: string
+  _updatedAt: string
+  _rev: string
+  [key: string]: unknown
+}
+
+/** @public */
+declare interface Schema {
+  /** @internal */
+  _original?: {
+    name: string
+    types: SchemaTypeDefinition[]
+  }
+  /** @internal */
+  _registry: {
+    [typeName: string]: any
+  }
+  /** @internal */
+  _validation?: SchemaValidationProblemGroup[]
+  name: string
+  get: (name: string) => SchemaType | undefined
+  has: (name: string) => boolean
+  getTypeNames: () => string[]
+}
+
+/**
+ * Note: you probably want `SchemaTypeDefinition` instead
+ * @see SchemaTypeDefinition
+ *
+ * @public
+ */
+declare type SchemaType =
+  | ArraySchemaType
+  | BooleanSchemaType
+  | FileSchemaType
+  | NumberSchemaType
+  | ObjectSchemaType
+  | StringSchemaType
+  | ReferenceSchemaType
+
+/**
+ * Represents a Sanity schema type definition with an optional type parameter.
+ *
+ * It's recommend to use the `defineType` helper instead of this type by
+ * itself.
+ *
+ * @see defineType
+ *
+ * @public
+ */
+declare type SchemaTypeDefinition<
+  TType extends IntrinsicTypeName = IntrinsicTypeName,
+> = IntrinsicDefinitions[IntrinsicTypeName] | TypeAliasDefinition<string, TType>
+
+/** @public */
+declare interface SchemaValidationError {
+  helpId?: string
+  message: string
+  severity: 'error'
+}
+
+/** @internal */
+declare type SchemaValidationProblem =
+  | SchemaValidationError
+  | SchemaValidationWarning
+
+/** @internal */
+declare interface SchemaValidationProblemGroup {
+  path: SchemaValidationProblemPath
+  problems: SchemaValidationProblem[]
+}
+
+/** @internal */
+declare type SchemaValidationProblemPath = Array<
+  | {
+      kind: 'type'
+      type: string
+      name?: string
+    }
+  | {
+      kind: 'property'
+      name: string
+    }
+>
+
+/**
+ * Represents the possible values of a schema type's `validation` field.
+ *
+ * If the schema has not been run through `inferFromSchema` from
+ * `sanity/validation` then value could be a function.
+ *
+ * `inferFromSchema` mutates the schema converts this value to an array of
+ * `Rule` instances.
+ *
+ * @privateRemarks
+ *
+ * Usage of the schema inside the studio will almost always be from the compiled
+ * `createSchema` function. In this case, you can cast the value or throw to
+ * narrow the type. E.g.:
+ *
+ * ```ts
+ * if (typeof type.validation === 'function') {
+ *   throw new Error(
+ *     `Schema type "${type.name}"'s \`validation\` was not run though \`inferFromSchema\``
+ *   )
+ * }
+ * ```
+ *
+ * @public
+ */
+declare type SchemaValidationValue =
+  | false
+  | undefined
+  | Rule
+  | SchemaValidationValue[]
+  | ((rule: Rule) => SchemaValidationValue)
+
+/** @internal */
+declare interface SchemaValidationWarning {
+  helpId?: string
+  message: string
+  severity: 'warning'
+}
+
+/** @public */
+declare interface SearchConfiguration {
+  search?: {
+    /**
+     * Defines a search weight for this field to prioritize its importance
+     * during search operations in the Studio. This setting allows the specified
+     * field to be ranked higher in search results compared to other fields.
+     *
+     * By default, all fields are assigned a weight of 1. However, if a field is
+     * chosen as the `title` in the preview configuration's `select` option, it
+     * will automatically receive a default weight of 10. Similarly, if selected
+     * as the `subtitle`, the default weight is 5. Fields marked as
+     * `hidden: true` (no function) are assigned a weight of 0 by default.
+     *
+     * Note: Search weight configuration is currently supported only for fields
+     * of type string or portable text arrays.
+     */
+    weight?: number
+  }
+}
+
+/**
+ * @public
+ */
+declare const searchStrategies: readonly ['groqLegacy', 'groq2024']
+
+/**
+ * @public
+ */
+declare type SearchStrategy = (typeof searchStrategies)[number]
+
 /**
  * @public
  */
 export declare function selectionPointToBlockOffset({
-  value,
+  context,
   selectionPoint,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   selectionPoint: EditorSelectionPoint
 }): BlockOffset | undefined
 
@@ -5603,25 +7568,122 @@ declare type Serializer<TMIMEType extends MIMEType> = ({
   'serialization.success' | 'serialization.failure'
 >
 
+/** @public */
+declare interface SingleFieldSet {
+  single: true
+  field: ObjectField
+  hidden?: ConditionalProperty
+  readOnly?: ConditionalProperty
+  group?: string | string[]
+}
+
 /**
  * @public
  */
 export declare function sliceBlocks({
+  context,
   blocks,
-  selection,
 }: {
+  context: Pick<EditorContext, 'schema' | 'selection'>
   blocks: Array<PortableTextBlock>
-  selection: EditorSelection
 }): Array<PortableTextBlock>
 
+/** @public */
+declare interface SlugDefinition extends BaseSchemaDefinition {
+  type: 'slug'
+  options?: SlugOptions
+  validation?: ValidationBuilder<SlugRule, SlugValue>
+  initialValue?: InitialValueProperty<any, Omit<SlugValue, '_type'>>
+}
+
+/** @public */
+declare type SlugifierFn = (
+  source: string,
+  schemaType: SlugSchemaType,
+  context: SlugSourceContext,
+) => string | Promise<string>
+
+/** @public */
+declare type SlugIsUniqueValidator = (
+  slug: string,
+  context: SlugValidationContext,
+) => boolean | Promise<boolean>
+
+/** @public */
+declare interface SlugOptions
+  extends SearchConfiguration,
+    BaseSchemaTypeOptions {
+  source?: string | Path | SlugSourceFn
+  maxLength?: number
+  slugify?: SlugifierFn
+  isUnique?: SlugIsUniqueValidator
+  disableArrayWarning?: boolean
+}
+
+/** @public */
+declare type SlugParent = Record<string, unknown> | Record<string, unknown>[]
+
+/** @public */
+declare interface SlugRule extends RuleDef<SlugRule, SlugValue> {}
+
+/** @public */
+declare interface SlugSchemaType extends ObjectSchemaType {
+  jsonType: 'object'
+  options?: SlugOptions
+}
+
+/** @public */
+declare interface SlugSourceContext {
+  parentPath: Path
+  parent: SlugParent
+  projectId: string
+  dataset: string
+  schema: Schema
+  currentUser: CurrentUser | null
+  getClient: (options: {apiVersion: string}) => SanityClient
+}
+
+/** @public */
+declare type SlugSourceFn = (
+  document: SanityDocument,
+  context: SlugSourceContext,
+) => string | Promise<string>
+
+/** @public */
+declare interface SlugValidationContext extends ValidationContext {
+  parent: SlugParent
+  type: SlugSchemaType
+  defaultIsUnique: SlugIsUniqueValidator
+}
+
+/** @public */
+declare interface SlugValue {
+  _type: 'slug'
+  current?: string
+}
+
+/** @beta */
+declare type SortOrdering = {
+  title: string
+  i18n?: I18nTextRecord<'title'>
+  name: string
+  by: SortOrderingItem[]
+}
+
+/** @beta */
+declare interface SortOrderingItem {
+  field: string
+  direction: 'asc' | 'desc'
+}
+
 /**
  * @public
  */
 export declare function spanSelectionPointToBlockOffset({
-  value,
+  context,
   selectionPoint,
 }: {
-  value: Array<PortableTextBlock>
+  context: Pick<EditorContext, 'schema' | 'value'>
   selectionPoint: EditorSelectionPoint
 }): BlockOffset | undefined
 
@@ -5645,6 +7707,60 @@ export declare function splitTextBlock({
 
 declare type StrictExtract<T, U extends T> = U
 
+/** @public */
+declare interface StringDefinition extends BaseSchemaDefinition {
+  type: 'string'
+  options?: StringOptions
+  placeholder?: string
+  validation?: ValidationBuilder<StringRule, string>
+  initialValue?: InitialValueProperty<any, string>
+}
+
+/** @public */
+declare interface StringOptions
+  extends EnumListProps<string>,
+    SearchConfiguration,
+    BaseSchemaTypeOptions {}
+
+/** @public */
+declare interface StringRule extends RuleDef<StringRule, string> {
+  min: (minNumber: number | FieldReference) => StringRule
+  max: (maxNumber: number | FieldReference) => StringRule
+  length: (exactLength: number | FieldReference) => StringRule
+  uppercase: () => StringRule
+  lowercase: () => StringRule
+  regex(
+    pattern: RegExp,
+    name: string,
+    options: {
+      name?: string
+      invert?: boolean
+    },
+  ): StringRule
+  regex(
+    pattern: RegExp,
+    options: {
+      name?: string
+      invert?: boolean
+    },
+  ): StringRule
+  regex(pattern: RegExp, name: string): StringRule
+  regex(pattern: RegExp): StringRule
+  email(): StringRule
+}
+
+/**
+ * This is used for string, text, date and datetime.
+ * This interface represent the compiled version at runtime, when accessed through Schema.
+ *
+ * @public
+ */
+declare interface StringSchemaType extends BaseSchemaType {
+  jsonType: 'string'
+  options?: StringOptions & TextOptions & DateOptions & DatetimeOptions
+  initialValue?: InitialValueProperty<any, string>
+}
+
 /**
  * @beta
  */
@@ -5794,9 +7910,199 @@ declare type TextBlockWithOptionalKey = Omit<PortableTextTextBlock, '_key'> & {
   _key?: PortableTextTextBlock['_key']
 }
 
+/** @public */
+declare interface TextDefinition extends BaseSchemaDefinition {
+  type: 'text'
+  rows?: number
+  options?: TextOptions
+  placeholder?: string
+  validation?: ValidationBuilder<TextRule, string>
+  initialValue?: InitialValueProperty<any, string>
+}
+
+/** @public */
+declare interface TextOptions extends StringOptions {}
+
+/** @public */
+declare interface TextRule extends StringRule {}
+
+/** @public */
+declare interface TitledListValue<V = unknown> {
+  _key?: string
+  title: string
+  value?: V
+}
+
+/**
+ * Represents a type definition that is an alias/extension of an existing type
+ * in your schema. Creating a type alias will re-register that existing type
+ * under a different name. You can also override the default type options with
+ * a type alias definition.
+ *
+ * @public
+ */
+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
+  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>
+  }
+}
+
+/**
+ * Represents a reference to another type registered top-level in your schema.
+ *
+ * @public
+ */
+declare interface TypeReference {
+  type: string
+  name?: string
+  icon?: ComponentType | ReactNode
+  options?: {
+    [key: string]: unknown
+  }
+}
+
 declare type UnsetEvent = {
   type: 'unset'
   previousValue: Array<PortableTextBlock>
 }
 
+/** @public */
+declare interface UriValidationOptions {
+  scheme?: (string | RegExp) | Array<string | RegExp>
+  allowRelative?: boolean
+  relativeOnly?: boolean
+  allowCredentials?: boolean
+}
+
+/** @public */
+declare interface UrlDefinition extends BaseSchemaDefinition {
+  type: 'url'
+  options?: UrlOptions
+  placeholder?: string
+  validation?: ValidationBuilder<UrlRule, string>
+  initialValue?: InitialValueProperty<any, string>
+}
+
+/** @public */
+declare interface UrlOptions extends BaseSchemaTypeOptions {}
+
+/** @public */
+declare interface UrlRule extends RuleDef<UrlRule, string> {
+  uri(options: UriValidationOptions): UrlRule
+}
+
+/** @public */
+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
+ * `Rule.custom` context.
+ *
+ * e.g.
+ *
+ * ```js
+ * Rule.custom((_, validationContext) => {
+ *   // ...
+ * })`
+ * ```
+ *
+ * @public
+ */
+declare interface ValidationContext {
+  getClient: (options: {apiVersion: string}) => SanityClient
+  schema: Schema
+  parent?: unknown
+  type?: SchemaType
+  document?: SanityDocument
+  path?: Path
+  getDocumentExists?: (options: {id: string}) => Promise<boolean>
+  environment: 'cli' | 'studio'
+}
+
+/**
+ * The shape that can be returned from a custom validator to be converted into
+ * a validation marker by the validation logic. Inside of a custom validator,
+ * you can return an array of these in order to specify multiple paths within
+ * an object or array.
+ *
+ * @public
+ */
+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
+  /**
+   * If writing a custom validator, you can return validation messages to
+   * specific path inside of the current value (object or array) by populating
+   * this `path` prop.
+   *
+   * NOTE: This path is relative to the current value and _not_ relative to
+   * the document.
+   */
+  path?: Path
+  /**
+   * 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
+   * provided.
+   *
+   * @deprecated prefer `path`
+   */
+  paths?: Path[]
+  /**
+   * @deprecated Unused. Was used to store the results from `.either()` /`.all()`
+   */
+  children?: ValidationMarker[]
+  /**
+   * @deprecated Unused. Was used to signal if this error came from an `.either()`/`.all()`.
+   */
+  operation?: 'AND' | 'OR'
+  /**
+   * @deprecated Unused. Was relevant when validation error was used as a class.
+   */
+  cloneWithMessage?(message: string): ValidationError
+}
+
+/** @public */
+declare interface ValidationMarker {
+  level: 'error' | 'warning' | 'info'
+  /**
+   * The validation message for this marker. E.g. "Must be greater than 0"
+   */
+  message: string
+  /**
+   * @deprecated use `message` instead
+   */
+  item?: ValidationError
+  /**
+   * The sanity path _relative to the root of the current document_ to this
+   * marker.
+   *
+   * NOTE: Sanity paths may contain keyed segments (i.e. `{_key: string}`) that
+   * are not compatible with deep getters like lodash/get
+   */
+  path: Path
+}
+
 export {}