@portabletext/editor 3.3.8 → 3.3.9

package/lib/_chunks-dts/index.d.ts

@@ -1,16 +1,2067 @@
-import * as _sanity_types4 from "@sanity/types";
-import { ArrayDefinition, ArraySchemaType, BlockDecoratorDefinition, BlockListDefinition, BlockStyleDefinition, ObjectSchemaType, Path, PortableTextBlock, PortableTextBlock as PortableTextBlock$1, PortableTextChild, PortableTextChild as PortableTextChild$1, PortableTextListBlock, PortableTextObject, PortableTextObject as PortableTextObject$2, PortableTextSpan, PortableTextSpan as PortableTextSpan$2, PortableTextTextBlock, PortableTextTextBlock as PortableTextTextBlock$2, TypedObject } from "@sanity/types";
+import { Asset, AssetInstanceDocument } from "@sanity/media-library-types";
+import { ClientPerspective, SanityClient, StackablePerspective } from "@sanity/client";
+import * as react17 from "react";
+import React$1, { BaseSyntheticEvent, ClipboardEvent, Component, ComponentType, ElementType, FocusEvent, JSX, KeyboardEvent as KeyboardEvent$1, MutableRefObject, PropsWithChildren, ReactElement, ReactNode, RefObject, TextareaHTMLAttributes } from "react";
 import { BaseRange, Descendant, Operation } from "slate";
 import * as xstate228 from "xstate";
 import { ActorRef, ActorRefFrom, EventObject, Snapshot } from "xstate";
-import * as react18 from "react";
-import React$1, { BaseSyntheticEvent, ClipboardEvent, Component, FocusEvent, JSX, KeyboardEvent as KeyboardEvent$1, MutableRefObject, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
 import { Patch, Patch as Patch$1 } from "@portabletext/patches";
 import * as _portabletext_schema5 from "@portabletext/schema";
-import { AnnotationDefinition, AnnotationSchemaType, BaseDefinition, BlockObjectDefinition, BlockObjectSchemaType, DecoratorDefinition, DecoratorSchemaType, FieldDefinition, InlineObjectDefinition, InlineObjectSchemaType, ListDefinition, ListSchemaType, PortableTextObject as PortableTextObject$1, PortableTextSpan as PortableTextSpan$1, PortableTextTextBlock as PortableTextTextBlock$1, Schema, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, StyleDefinition, StyleSchemaType, defineSchema } from "@portabletext/schema";
+import { AnnotationDefinition, AnnotationSchemaType, BaseDefinition, BlockObjectDefinition, BlockObjectSchemaType, DecoratorDefinition, DecoratorSchemaType, FieldDefinition, InlineObjectDefinition, InlineObjectSchemaType, ListDefinition, ListSchemaType, PortableTextObject, PortableTextSpan, PortableTextTextBlock, Schema, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, StyleDefinition, StyleSchemaType, defineSchema } from "@portabletext/schema";
 import { Observable, Subject } from "rxjs";
 import { ReactEditor } from "slate-react";
 import * as xstate_guards12 from "xstate/guards";
+/**
+ * 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$1> = Omit<T$1, 'name' | 'hidden'> & {
+  name?: string;
+};
+/** @public */
+declare type ArrayOfType<TType$1 extends IntrinsicTypeName = IntrinsicTypeName, TAlias extends IntrinsicTypeName | undefined = undefined> = IntrinsicArrayOfDefinition[TType$1] | 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$1 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?: AssetSourceUploaderClass;
+}
+/** @public */
+declare interface AssetSourceComponentProps {
+  action?: 'select' | 'upload';
+  assetSource: AssetSource;
+  assetType?: 'file' | 'image' | 'sanity.video';
+  accept: string;
+  selectionType: 'single';
+  dialogHeaderTitle?: React.ReactNode;
+  selectedAssets: Asset$1[];
+  onClose: () => void;
+  onSelect: (assetFromSource: AssetFromSource[]) => void;
+  schemaType?: ImageSchemaType | FileSchemaType;
+  /** @beta */
+  uploader?: AssetSourceUploader;
+}
+/** @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 AssetSourceUploaderClass = new (...args: any[]) => AssetSourceUploader;
+/** @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' | 'alreadyExists';
+  error?: Error;
+  result?: unknown;
+}
+/** @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>;
+    portableText?: {
+      plugins?: 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;
+  canvasApp?: CanvasAppOptions;
+}
+/**
+ * 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-through'},
+ *           {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-through'},
+ *           {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'>[];
+}
+/**
+ * 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';
+  /**
+   * When enabled, the editor will restrict all line breaks and soft breaks,
+   * forcing content to remain on a single line. This will also update
+   * the styling of the editor to reflect the single-line constraint.
+   *
+   * Pasting content that is on multiple lines will be normalized to a single line, if possible.
+   *
+   * @defaultValue false
+   */
+  oneLine?: boolean;
+}
+/** @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;
+}
+/** @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>;
+}
+/**
+ * Options for configuring how Canvas app interfaces with the type or field.
+ *
+ * @public
+ */
+declare interface CanvasAppOptions {
+  /** Set to true to exclude a type or field from appearing in Canvas */
+  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 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;
+}
+/** @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[];
+}
+/** @public */
+declare interface CustomValidator<T$1 = unknown> {
+  (value: T$1, 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;
+  displayTimeZone?: string;
+  allowTimeZoneSwitch?: boolean;
+}
+/** @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;
+}
+/** @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> {}
+/** @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';
+}
+/**
+ * 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$1<TType$1 extends IntrinsicTypeName = IntrinsicTypeName, TAlias extends IntrinsicTypeName | undefined = undefined> = (InlineFieldDefinition[TType$1] | 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[];
+  mediaLibrary?: MediaLibraryOptions;
+}
+/** @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 */
+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?: string | ((document: {
+    id: string;
+    type?: string;
+  }) => string | null);
+}
+/** @public */
+declare interface HotspotOptions {
+  previews?: HotspotPreview[];
+}
+/** @public */
+declare interface HotspotPreview {
+  title: string;
+  aspectRatio: number;
+}
+/** @public */
+declare type I18nTextRecord<K$1 extends string> = { [P in K$1]?: {
+  key: string;
+  ns: string;
+} };
+/** @public */
+declare interface ImageAsset extends Asset$1 {
+  _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$1[];
+  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 ImageSchemaType extends Omit<ObjectSchemaType, 'options'> {
+  options?: ImageOptions;
+}
+/** @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$1;
+  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>;
+} };
+/** @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 | undefined;
+  groups?: Array<{
+    name: string;
+    title?: string;
+    of?: Array<string>;
+  }> | undefined;
+  /** defaultValue `true` */
+  showIcons?: boolean | undefined;
+  /** @defaultValue `[{name: 'list'}]` */
+  views?: Array<{
+    name: 'list';
+  } | {
+    name: 'grid';
+    previewImageUrl?: (schemaTypeName: string) => string | undefined;
+  }> | undefined;
+}
+/** @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'];
+/** @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;
+}
+/** @public */
+declare type MediaAssetTypes = AssetInstanceDocument['_type'];
+/** @public */
+declare interface MediaLibraryFilter {
+  name: string;
+  query: string;
+}
+/** @public */
+declare interface MediaLibraryOptions {
+  filters?: MediaLibraryFilter[];
+}
+/** @public */
+declare interface MediaValidationValue<T$1 extends MediaAssetTypes = MediaAssetTypes> {
+  /**
+   * Media information
+   */
+  media: {
+    /**
+     * The Media Library Asset.
+     */
+    asset: Asset & {
+      currentVersion: Extract<AssetInstanceDocument, {
+        _type: T$1;
+      }>;
+    };
+  };
+  /**
+   * The field value which the media is used in.
+   */
+  value: unknown;
+}
+/** @public */
+declare interface MediaValidator<T$1 extends MediaAssetTypes = MediaAssetTypes> {
+  (value: MediaValidationValue<T$1>, context: ValidationContext): CustomValidatorResult | Promise<CustomValidatorResult>;
+}
+/** @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 */
+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>;
+}
+/** @public */
+declare interface ObjectDefinition extends BaseSchemaDefinition {
+  type: 'object';
+  /**
+   * Object must have at least one field. This is validated at Studio startup.
+   */
+  fields: FieldDefinition$1[];
+  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$1 extends SchemaType = SchemaType> {
+  name: string;
+  fieldset?: string;
+  group?: string | string[];
+  type: ObjectFieldType<T$1>;
+}
+/** @public */
+declare type ObjectFieldType<T$1 extends SchemaType = SchemaType> = T$1 & {
+  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 */
+declare type Path = PathSegment[];
+/** @public */
+declare type PathSegment = string | number | KeyedSegment | IndexTuple;
+/** @alpha */
+declare type PortableTextBlock = PortableTextTextBlock$1 | PortableTextObject$1;
+/** @alpha */
+declare type PortableTextChild = PortableTextObject$1 | PortableTextSpan$1;
+/** @alpha */
+declare interface PortableTextListBlock extends PortableTextTextBlock$1 {
+  listItem: string;
+  level: number;
+}
+/** @alpha */
+declare interface PortableTextObject$1 {
+  _type: string;
+  _key: string;
+  [other: string]: unknown;
+}
+/** @alpha */
+declare interface PortableTextSpan$1 {
+  _key: string;
+  _type: 'span';
+  text: string;
+  marks?: string[];
+}
+/** @alpha */
+declare interface PortableTextTextBlock$1<TChild = PortableTextSpan$1 | PortableTextObject$1> {
+  _type: string;
+  _key: string;
+  children: TChild[];
+  markDefs?: PortableTextObject$1[];
+  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;
+  perspective: StackablePerspective[];
+  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?: Exclude<ClientPerspective, 'raw' | 'previewDrafts'>;
+};
+/**
+ * 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;
+/** @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$1 = unknown>(fn: CustomValidator<T$1>, options?: {
+    bypassConcurrencyLimit?: boolean;
+  }): Rule;
+  media<T$1 extends MediaAssetTypes = MediaAssetTypes>(fn: MediaValidator<T$1>): 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$1 extends RuleDef<T$1, FieldValue>, FieldValue = unknown> = T$1 | T$1[];
+/** @public */
+declare interface RuleDef<T$1, FieldValue = unknown> {
+  required: () => T$1;
+  custom: <LenientFieldValue extends FieldValue>(fn: CustomValidator<LenientFieldValue | undefined>) => T$1;
+  info: (message?: string | LocalizedValidationMessages) => T$1;
+  error: (message?: string | LocalizedValidationMessages) => T$1;
+  warning: (message?: string | LocalizedValidationMessages) => T$1;
+  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 | FieldReference;
+} | {
+  flag: 'max';
+  constraint: number | string | FieldReference;
+} | {
+  flag: 'length';
+  constraint: number | FieldReference;
+} | {
+  flag: 'valid';
+  constraint: unknown[];
+} | {
+  flag: 'precision';
+  constraint: number | FieldReference;
+} | {
+  flag: 'lessThan';
+  constraint: number | FieldReference;
+} | {
+  flag: 'greaterThan';
+  constraint: number | FieldReference;
+} | {
+  flag: 'stringCasing';
+  constraint: 'uppercase' | 'lowercase';
+} | {
+  flag: 'assetRequired';
+  constraint: {
+    assetType: 'asset' | 'image' | 'file';
+  };
+} | {
+  flag: 'media';
+  constraint: MediaValidator<any>;
+} | {
+  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$1 {
+  /** @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[];
+  /**
+   * Returns the types which were explicitly defined in this schema,
+   * as opposed to the types which were inherited from the parent.
+   */
+  getLocalTypeNames: () => string[];
+  /**
+   * Returns the parent schema.
+   */
+  parent?: Schema$1;
+}
+/**
+ * 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$1 extends IntrinsicTypeName = IntrinsicTypeName> = IntrinsicDefinitions[IntrinsicTypeName] | TypeAliasDefinition<string, TType$1>;
+/** @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 */
+declare interface SingleFieldSet {
+  single: true;
+  field: ObjectField;
+  hidden?: ConditionalProperty;
+  readOnly?: ConditionalProperty;
+  group?: string | string[];
+}
+/** @public */
+declare interface SlugDefinition extends BaseSchemaDefinition {
+  type: 'slug';
+  options?: SlugOptions;
+  validation?: ValidationBuilder<SlugRule, SlugValue>;
+  initialValue?: InitialValueProperty<any, Omit<SlugValue, '_type'>>;
+}
+/** @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$1;
+  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 */
+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>;
+}
+/** @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$1 extends string, TAlias extends IntrinsicTypeName | undefined> extends BaseSchemaDefinition {
+  type: TType$1;
+  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>;
+  };
+}
+/** @public */
+declare interface TypedObject {
+  [key: string]: unknown;
+  _type: string;
+}
+/**
+ * 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;
+  };
+}
+/** @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$1 extends RuleDef<T$1, FieldValue>, FieldValue = unknown> = (rule: T$1) => RuleBuilder<T$1, 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$1;
+  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;
+  /**
+   * 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;
+  /**
+   * 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;
+  /**
+   * 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;
+}
 type MIMEType = `${string}/${string}`;
 /**
  * @internal
@@ -84,8 +2135,8 @@ interface PortableTextSlateEditor extends ReactEditor {
   _type: 'editor';
   createPlaceholderBlock: () => Descendant;
   history: History;
-  isTextBlock: (value: unknown) => value is PortableTextTextBlock;
-  isTextSpan: (value: unknown) => value is PortableTextSpan;
+  isTextBlock: (value: unknown) => value is PortableTextTextBlock$1;
+  isTextSpan: (value: unknown) => value is PortableTextSpan$1;
   isListBlock: (value: unknown) => value is PortableTextListBlock;
   value: Array<PortableTextBlock>;
   decoratedRanges: Array<DecoratedRange>;
@@ -247,7 +2298,7 @@ declare class PortableTextEditor extends Component<PortableTextEditorProps<Inter
   componentDidUpdate(prevProps: PortableTextEditorProps): void;
   componentWillUnmount(): void;
   setEditable: (editable: EditableAPI) => void;
-  render(): react18.JSX.Element;
+  render(): react17.JSX.Element;
   /**
    * @deprecated
    * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
@@ -258,7 +2309,7 @@ declare class PortableTextEditor extends Component<PortableTextEditorProps<Inter
    * const isActive = useEditorSelector(editor, selectors.getActiveAnnotations)
    * ```
    */
-  static activeAnnotations: (editor: PortableTextEditor) => PortableTextObject[];
+  static activeAnnotations: (editor: PortableTextEditor) => PortableTextObject$1[];
   /**
    * @deprecated
    * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
@@ -269,7 +2320,7 @@ declare class PortableTextEditor extends Component<PortableTextEditorProps<Inter
    * const isActive = useEditorSelector(editor, selectors.isActiveAnnotation(...))
    * ```
    */
-  static isAnnotationActive: (editor: PortableTextEditor, annotationType: PortableTextObject["_type"]) => boolean;
+  static isAnnotationActive: (editor: PortableTextEditor, annotationType: PortableTextObject$1["_type"]) => boolean;
   /**
    * @deprecated
    * Use `editor.send(...)` instead
@@ -318,7 +2369,7 @@ declare class PortableTextEditor extends Component<PortableTextEditorProps<Inter
    */
   static delete: (editor: PortableTextEditor, selection: EditorSelection, options?: EditableAPIDeleteOptions) => void;
   static findDOMNode: (editor: PortableTextEditor, element: PortableTextBlock | PortableTextChild) => Node | undefined;
-  static findByPath: (editor: PortableTextEditor, path: Path) => [_sanity_types4.PortableTextTextBlock<PortableTextObject | _sanity_types4.PortableTextSpan> | PortableTextObject | _sanity_types4.PortableTextSpan | undefined, Path | undefined];
+  static findByPath: (editor: PortableTextEditor, path: Path) => [PortableTextTextBlock$1<PortableTextObject$1 | PortableTextSpan$1> | PortableTextObject$1 | PortableTextSpan$1 | undefined, Path | undefined];
   /**
    * @deprecated
    * Use `editor.send(...)` instead
@@ -656,7 +2707,7 @@ type PortableTextEditableProps = Omit<TextareaHTMLAttributes<HTMLDivElement>, 'o
  * ```
  * @group Components
  */
-declare const PortableTextEditable: react18.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react18.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
+declare const PortableTextEditable: react17.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react17.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
 /**
  * @public
  */
@@ -702,8 +2753,8 @@ type AddedAnnotationPaths = {
 };
 /** @beta */
 interface EditableAPI {
-  activeAnnotations: () => PortableTextObject[];
-  isAnnotationActive: (annotationType: PortableTextObject['_type']) => boolean;
+  activeAnnotations: () => PortableTextObject$1[];
+  isAnnotationActive: (annotationType: PortableTextObject$1['_type']) => boolean;
   addAnnotation: <TSchemaType extends {
     name: string;
   }>(type: TSchemaType, value?: {
@@ -955,7 +3006,7 @@ interface BlockRenderProps {
 }
 /** @beta */
 interface BlockChildRenderProps {
-  annotations: PortableTextObject[];
+  annotations: PortableTextObject$1[];
   children: ReactElement<any>;
   editorElementRef: RefObject<HTMLElement | null>;
   focused: boolean;
@@ -977,7 +3028,7 @@ interface BlockAnnotationRenderProps {
   selected: boolean;
   /** @deprecated Use `schemaType` instead */
   type: ObjectSchemaType;
-  value: PortableTextObject;
+  value: PortableTextObject$1;
 }
 /** @beta */
 interface BlockDecoratorRenderProps {
@@ -993,7 +3044,7 @@ interface BlockDecoratorRenderProps {
 }
 /** @beta */
 interface BlockListItemRenderProps {
-  block: PortableTextTextBlock;
+  block: PortableTextTextBlock$1;
   children: ReactElement<any>;
   editorElementRef: RefObject<HTMLElement | null>;
   focused: boolean;
@@ -1017,7 +3068,7 @@ type RenderPlaceholderFunction = () => React.ReactNode;
 type RenderStyleFunction = (props: BlockStyleRenderProps) => JSX.Element;
 /** @beta */
 interface BlockStyleRenderProps {
-  block: PortableTextTextBlock;
+  block: PortableTextTextBlock$1;
   children: ReactElement<any>;
   editorElementRef: RefObject<HTMLElement | null>;
   focused: boolean;
@@ -1286,15 +3337,15 @@ type BlockOffset = {
   path: BlockPath;
   offset: number;
 };
-type TextBlockWithOptionalKey = Omit<PortableTextTextBlock$1, '_key'> & {
-  _key?: PortableTextTextBlock$1['_key'];
+type TextBlockWithOptionalKey = Omit<PortableTextTextBlock, '_key'> & {
+  _key?: PortableTextTextBlock['_key'];
 };
-type ObjectBlockWithOptionalKey = Omit<PortableTextObject$1, '_key'> & {
-  _key?: PortableTextObject$1['_key'];
+type ObjectBlockWithOptionalKey = Omit<PortableTextObject, '_key'> & {
+  _key?: PortableTextObject['_key'];
 };
 type BlockWithOptionalKey = TextBlockWithOptionalKey | ObjectBlockWithOptionalKey;
-type SpanWithOptionalKey = Omit<PortableTextSpan$1, '_key'> & {
-  _key?: PortableTextSpan$1['_key'];
+type SpanWithOptionalKey = Omit<PortableTextSpan, '_key'> & {
+  _key?: PortableTextSpan['_key'];
 };
 type ChildWithOptionalKey = SpanWithOptionalKey | ObjectBlockWithOptionalKey;
 type EditorPriority = {
@@ -1502,7 +3553,7 @@ declare const editorMachine: xstate228.StateMachine<{
   initialValue?: Array<PortableTextBlock>;
 }, xstate228.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
   type: "blurred";
-  event: react18.FocusEvent<HTMLDivElement, Element>;
+  event: react17.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "done loading";
 } | {
@@ -1514,7 +3565,7 @@ declare const editorMachine: xstate228.StateMachine<{
   data: unknown;
 } | {
   type: "focused";
-  event: react18.FocusEvent<HTMLDivElement, Element>;
+  event: react17.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "invalid value";
   resolution: InvalidValueResolution | null;
@@ -2081,7 +4132,7 @@ declare const editorMachine: xstate228.StateMachine<{
         editor: PortableTextSlateEditor;
       }, undefined, never, never, never, never, InternalPatchEvent | MutationEvent | PatchesEvent | {
         type: "blurred";
-        event: react18.FocusEvent<HTMLDivElement, Element>;
+        event: react17.FocusEvent<HTMLDivElement, Element>;
       } | {
         type: "done loading";
       } | {
@@ -2093,7 +4144,7 @@ declare const editorMachine: xstate228.StateMachine<{
         data: unknown;
       } | {
         type: "focused";
-        event: react18.FocusEvent<HTMLDivElement, Element>;
+        event: react17.FocusEvent<HTMLDivElement, Element>;
       } | {
         type: "invalid value";
         resolution: InvalidValueResolution | null;
@@ -2913,7 +4964,7 @@ declare const editorMachine: xstate228.StateMachine<{
                         editor: PortableTextSlateEditor;
                       }, undefined, never, never, never, never, InternalPatchEvent | MutationEvent | PatchesEvent | {
                         type: "blurred";
-                        event: react18.FocusEvent<HTMLDivElement, Element>;
+                        event: react17.FocusEvent<HTMLDivElement, Element>;
                       } | {
                         type: "done loading";
                       } | {
@@ -2925,7 +4976,7 @@ declare const editorMachine: xstate228.StateMachine<{
                         data: unknown;
                       } | {
                         type: "focused";
-                        event: react18.FocusEvent<HTMLDivElement, Element>;
+                        event: react17.FocusEvent<HTMLDivElement, Element>;
                       } | {
                         type: "invalid value";
                         resolution: InvalidValueResolution | null;
@@ -3475,4 +5526,4 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   event: TBehaviorEvent;
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
-export { BlockAnnotationRenderProps as $, EditorEmittedEvent as $t, PortableTextTextBlock$2 as A, ReadyChange as At, EditorSelector as B, ScrollSelectionIntoViewFunction as Bt, ListDefinition as C, OnPasteResultOrPromise as Ct, PortableTextChild$1 as D, PortableTextMemberSchemaTypes as Dt, PortableTextBlock$1 as E, PatchObservable as Et, BlockOffset as F, RenderDecoratorFunction as Ft, EditorConfig as G, AnnotationPath as Gt, EditorProvider as H, UndoChange as Ht, useEditor as I, RenderEditableFunction as It, defineBehavior as J, PortableTextEditable as Jt, EditorEvent as K, BlockPath as Kt, defaultKeyGenerator as L, RenderListItemFunction as Lt, StyleDefinition as M, RenderAnnotationFunction as Mt, StyleSchemaType as N, RenderBlockFunction as Nt, PortableTextObject$2 as O, RangeDecoration as Ot, defineSchema as P, RenderChildFunction as Pt, AddedAnnotationPaths as Q, PortableTextEditorProps as Qt, usePortableTextEditorSelection as R, RenderPlaceholderFunction as Rt, InlineObjectSchemaType as S, OnPasteResult as St, Patch$1 as T, PatchChange as Tt, EditorProviderProps as U, UnsetChange as Ut, useEditorSelector as V, SelectionChange as Vt, Editor as W, ValueChange as Wt, EditorContext as X, HotkeyOptions as Xt, BehaviorGuard as Y, PortableTextEditableProps as Yt, EditorSnapshot as Z, PortableTextEditor as Zt, BlockObjectSchemaType as _, LoadingChange as _t, forward as a, BlurChange as at, FieldDefinition as b, OnCopyFn as bt, CustomBehaviorEvent as c, EditableAPIDeleteOptions as ct, SyntheticBehaviorEvent as d, EditorSelection as dt, MutationEvent as en, BlockChildRenderProps as et, PatchesEvent as f, EditorSelectionPoint as ft, BlockObjectDefinition as g, InvalidValueResolution as gt, BaseDefinition as h, InvalidValue as ht, execute as i, BlockStyleRenderProps as it, SchemaDefinition$1 as j, RedoChange as jt, PortableTextSpan$2 as k, RangeDecorationOnMovedDetails as kt, InsertPlacement as l, EditorChange as lt, AnnotationSchemaType as m, FocusChange as mt, BehaviorActionSet as n, BlockListItemRenderProps as nt, raise as o, ConnectionChange as ot, AnnotationDefinition as p, ErrorChange as pt, Behavior as q, ChildPath as qt, effect as r, BlockRenderProps as rt, BehaviorEvent as s, EditableAPI as st, BehaviorAction as t, EditorSchema as tn, BlockDecoratorRenderProps as tt, NativeBehaviorEvent as u, EditorChanges as ut, DecoratorDefinition as v, MutationChange as vt, ListSchemaType as w, PasteData as wt, InlineObjectDefinition as x, OnPasteFn as xt, DecoratorSchemaType as y, OnBeforeInputFn as yt, usePortableTextEditor as z, RenderStyleFunction as zt };
+export { BlockStyleRenderProps as $, PortableTextChild as $t, BlockOffset as A, RenderDecoratorFunction as At, EditorConfig as B, AnnotationPath as Bt, ListDefinition as C, RangeDecoration as Ct, StyleDefinition as D, RenderAnnotationFunction as Dt, SchemaDefinition$1 as E, RedoChange as Et, EditorSelector as F, ScrollSelectionIntoViewFunction as Ft, EditorContext as G, HotkeyOptions as Gt, Behavior as H, ChildPath as Ht, useEditorSelector as I, SelectionChange as It, BlockAnnotationRenderProps as J, EditorEmittedEvent as Jt, EditorSnapshot as K, PortableTextEditor as Kt, EditorProvider as L, UndoChange as Lt, defaultKeyGenerator as M, RenderListItemFunction as Mt, usePortableTextEditorSelection as N, RenderPlaceholderFunction as Nt, StyleSchemaType as O, RenderBlockFunction as Ot, usePortableTextEditor as P, RenderStyleFunction as Pt, BlockRenderProps as Q, PortableTextBlock as Qt, EditorProviderProps as R, UnsetChange as Rt, InlineObjectSchemaType as S, PortableTextMemberSchemaTypes as St, Patch$1 as T, ReadyChange as Tt, defineBehavior as U, PortableTextEditable as Ut, EditorEvent as V, BlockPath as Vt, BehaviorGuard as W, PortableTextEditableProps as Wt, BlockDecoratorRenderProps as X, EditorSchema as Xt, BlockChildRenderProps as Y, MutationEvent as Yt, BlockListItemRenderProps as Z, KeyedSegment as Zt, BlockObjectSchemaType as _, OnPasteResult as _t, forward as a, EditorChanges as at, FieldDefinition as b, PatchChange as bt, CustomBehaviorEvent as c, ErrorChange as ct, SyntheticBehaviorEvent as d, InvalidValueResolution as dt, PortableTextListBlock as en, BlurChange as et, PatchesEvent as f, LoadingChange as ft, BlockObjectDefinition as g, OnPasteFn as gt, BaseDefinition as h, OnCopyFn as ht, execute as i, EditorChange as it, useEditor as j, RenderEditableFunction as jt, defineSchema as k, RenderChildFunction as kt, InsertPlacement as l, FocusChange as lt, AnnotationSchemaType as m, OnBeforeInputFn as mt, BehaviorActionSet as n, PortableTextSpan$1 as nn, EditableAPI as nt, raise as o, EditorSelection as ot, AnnotationDefinition as p, MutationChange as pt, AddedAnnotationPaths as q, PortableTextEditorProps as qt, effect as r, PortableTextTextBlock$1 as rn, EditableAPIDeleteOptions as rt, BehaviorEvent as s, EditorSelectionPoint as st, BehaviorAction as t, PortableTextObject$1 as tn, ConnectionChange as tt, NativeBehaviorEvent as u, InvalidValue as ut, DecoratorDefinition as v, OnPasteResultOrPromise as vt, ListSchemaType as w, RangeDecorationOnMovedDetails as wt, InlineObjectDefinition as x, PatchObservable as xt, DecoratorSchemaType as y, PasteData as yt, Editor as z, ValueChange as zt };