@wix/patterns 1.468.0 → 1.469.0

package/dist/dts-bundle/types/OnSaveParams.d.ts

@@ -1,705 +1,13 @@
-import { ComponentType, ReactNode, ReactElement, MutableRefObject } from 'react';
 import { FieldValues, UseFormReturn } from 'react-hook-form';
 import { cairoPageCtaClickedParams } from '@wix/bex-utils/@wix/bi-logger-os-data/v2/types';
 
-type PatternsFieldType = 'SHORT_TEXT' | 'LONG_TEXT' | 'NUMBER' | 'BOOLEAN' | 'DATE' | 'DATETIME' | 'TIME' | 'URL' | 'ARRAY' | 'REFERENCE' | 'MULTI_REFERENCE' | 'OBJECT' | 'IMAGE' | 'VIDEO' | 'MEDIA_GALLERY' | 'ADDRESS' | 'RICH_TEXT' | 'DOCUMENT' | 'RICH_CONTENT' | 'MULTI_DOCUMENT' | 'EMAIL' | 'AUDIO' | 'COLOR' | 'CUSTOM' | 'UNKNOWN';
-type QueryOperator = 'CONTAINS' | 'ENDS_WITH' | 'EQ' | 'EXISTS' | 'GT' | 'GTE' | 'HAS_ALL' | 'HAS_SOME' | 'LT' | 'LTE' | 'NE' | 'STARTS_WITH' | 'URLIZED';
-interface NumberRange {
-    min?: number;
-    max?: number;
-}
-interface StringLengthRange {
-    minLength?: number;
-    maxLength?: number;
-}
-interface SpecificValue {
-    id: string;
-    value: string;
-}
-interface BaseField {
-    id: string;
-    displayName: string;
-    isPii?: boolean;
-    helpText?: string;
-    /** Whether this is a system-managed field (not user-created). */
-    isSystem?: boolean;
-    /** The group this field belongs to, when the source groups its fields.
-     *  Absent ⇒ ungrouped. */
-    group?: string;
-    /** Whether this is the collection's primary display field. */
-    isPrimary?: boolean;
-    validation?: {
-        numberRange?: NumberRange;
-        stringLengthRange?: StringLengthRange;
-        specificValues?: SpecificValue[];
-        /** Regular expression source the value must match. Applies to text-like
-         *  fields only; mutually exclusive with `specificValues`. */
-        pattern?: string;
-        required: boolean;
-    };
-    capabilities?: {
-        supportedQueryOperators: QueryOperator[];
-        sortable: boolean;
-    };
-}
-interface BaseReferenceField extends BaseField {
-    referenceMetadata: {
-        referencedCollectionId: string;
-    };
-}
-interface ReferenceField extends BaseReferenceField {
-    type: 'REFERENCE';
-}
-interface MultiReferenceField extends BaseReferenceField {
-    type: 'MULTI_REFERENCE';
-}
-interface NonReferenceField extends BaseField {
-    type: Exclude<PatternsFieldType, 'REFERENCE' | 'MULTI_REFERENCE'>;
-    /** Present iff `type` is 'CUSTOM'; keys a field type definition registered on the source. */
-    customType?: string;
-}
-type Field = ReferenceField | MultiReferenceField | NonReferenceField;
-
-/**
- * `OffsetQuery` — cut here because it has its own bundle.
- * Look `OffsetQuery` up in the bundle index for its full shape.
- */
-type OffsetQuery<F = any> = Omit<ComputedQuery<F>, 'cursor'>;
-type OffsetQueryResult<T> = Omit<DataResultRaw<T>, 'cursor'>;
-type CursorQueryResult<T> = Omit<DataResultRaw<T>, 'cursor'> & {
-    cursor: string | undefined | null;
-};
-/**
- * `CursorQuery` — cut here because it has its own bundle.
- * Look `CursorQuery` up in the bundle index for its full shape.
- */
-type CursorQuery<F = any> = Omit<ComputedQuery<F>, 'offset'>;
-type FetchTotalFn = (query: CursorQuery) => Promise<number>;
-
-/** Field-management permissions. Absent when the schema's fields cannot be edited. */
-interface SchemaPermissions {
-    createField: boolean;
-    updateField: boolean;
-    deleteField: boolean;
-}
-/** The per-item delete verdict. */
-interface RemoveItemDisabledResult {
-    disabled: boolean;
-    /** Why the item cannot be deleted — surfaced to the user by consumers. */
-    reason?: string;
-}
-/** Item-level CRUD permissions. */
-interface ItemPermissions<T = Record<string, unknown>> {
-    createItem: boolean;
-    updateItem: boolean;
-    deleteItem: boolean;
-    /** Deleting several items in one operation. Absent = follows `deleteItem`. */
-    bulkDeleteItems?: boolean;
-    /** Per-item refinement of `deleteItem`: disables deleting an item even
-     *  though `deleteItem` is true, optionally with a reason. Must be pure and
-     *  synchronous. Absent = all items deletable. */
-    isRemoveItemDisabled?: (item: T) => RemoveItemDisabledResult;
-}
-/**
- * A source-neutral description of a collection — data only, no behavior.
- * Item access is in `CollectionBackend`, field mutations in `FieldActions`.
- */
-interface Schema {
-    id: string;
-    fields: Record<string, Field | undefined>;
-    /** The field that best represents the entity (titles/selections). */
-    displayField: string;
-    /** The identifier field. */
-    idField: string;
-    /** Group display order, present when fields carry a `group`. */
-    groups?: string[];
-    /** Absent when the schema's fields cannot be edited. */
-    schemaPermissions?: SchemaPermissions;
-    itemPermissions?: ItemPermissions;
-}
-interface BackupConfig {
-    create: () => Promise<{
-        backupId: string;
-    }>;
-    waitForCompletion: (backupId: string, options?: {
-        signal?: AbortSignal;
-    }) => Promise<void>;
-    cancel?: (backupId: string) => Promise<void>;
-    restore?: (backupId: string) => Promise<{
-        restorationId: string;
-    }>;
-    waitForRestoration?: (restorationId: string, options?: {
-        signal?: AbortSignal;
-    }) => Promise<void>;
-}
-interface BulkInsertError {
-    rowIndex: number;
-    message?: string;
-    code?: string;
-}
-interface BulkInsertResult {
-    succeeded?: number;
-    failed?: number;
-    errors?: BulkInsertError[];
-}
-/**
- * Metadata for an item update. `changedFieldIds` narrows follow-up comparison
- * work to fields the UI already knows were edited, which avoids diffing every
- * value when some fields are large or expensive to compare.
- */
-interface CollectionUpdateContext<T = Record<string, unknown>> {
-    previousItem: T;
-    changedFieldIds: string[];
-}
-/** Item data access shared by both pagination modes. `find` (on
- *  `CollectionBackend`) is the only required call — the rest are capabilities
- *  a source provides when it (or its consumer) supports them. */
-interface CollectionBackendBase<T = Record<string, unknown>> {
-    get?: (entityId: string) => Promise<T>;
-    create?: (entity: Partial<T>) => Promise<T>;
-    update?: (entity: T, context?: CollectionUpdateContext<T>) => Promise<T>;
-    delete?: (entityId: string) => Promise<void>;
-    bulkDelete?: (entityIds: string[]) => Promise<void>;
-    move?: (id: string, params: {
-        moveAfterId: string | null | undefined;
-    }) => Promise<void>;
-    backup?: BackupConfig;
-    bulkInsert?: (entities: Partial<T>[]) => Promise<BulkInsertResult>;
-}
-/** Per-call search scope the query layer passes to a backend's `find`. */
-interface FindOptions {
-    searchableFieldIds?: string[];
-}
-/**
- * The query-layer fetch-data fns plus the optional `find` options the runtime
- * already accepts. Kept separate so the shared `OffsetFetchDataFn`/
- * `CursorFetchDataFn` used by `fetchData` stay unchanged.
- */
-type OffsetFindFn<T, F extends FiltersMap> = (query: OffsetQuery<F>, options?: FindOptions) => Promise<OffsetQueryResult<T>>;
-type CursorFindFn<T, F extends FiltersMap> = (query: CursorQuery<F>, options?: FindOptions) => Promise<CursorQueryResult<T>>;
-/**
- * A source's item data access. The source declares its `paginationMode`
- * (offset by default) together with the matching `find`, same as core's
- * `PaginationModeConfig`.
- */
-type CollectionBackend<T = Record<string, unknown>, F extends FiltersMap = OptionalFiltersMap> = CollectionBackendBase<T> & ({
-    paginationMode?: 'offset';
-    find: OffsetFindFn<T, F>;
-} | {
-    paginationMode: 'cursor';
-    find: CursorFindFn<T, F>;
-    fetchTotal?: FetchTotalFn;
-});
-/**
- * Whatever the source's settings section collected in the add/edit field modal.
- * The modal and the collection layer only carry it; the source that produced it
- * is the only one that looks inside, so it declares its own shape on `addField`
- * and `editField` (both are methods, so a narrower parameter type is allowed).
- */
-type FieldSettings = unknown;
-/** Field-management actions. All optional — a read-only source provides none. */
-interface FieldActions {
-    /**
-     * Field-mutating actions return the collection's updated fields map so the
-     * caller can merge its local state from the response, without reloading the
-     * schema. (`renameField` is the exception — nothing consumes its result yet.)
-     */
-    addField?(field: Field, settings?: FieldSettings): Promise<Schema['fields']>;
-    /**
-     * Adds several fields in a single mutation, each under its `field.id` key
-     * (callers decide the keys up front — e.g. CSV import uploads values under
-     * them), unlike `addField`, which derives a fresh key from the display name.
-     */
-    addFields?: (fields: Field[]) => Promise<Schema['fields']>;
-    editField?(fieldId: string, updates: Partial<Field>, settings?: FieldSettings): Promise<Schema['fields']>;
-    deleteField?: (fieldId: string) => Promise<Schema['fields']>;
-    renameField?: (fieldId: string, newName: string) => Promise<void>;
-    makePrimary?: (fieldId: string) => Promise<Schema['fields']>;
-    duplicateField?: (fieldId: string) => Promise<Schema['fields']>;
-    duplicateFieldWithContent?: (fieldId: string) => Promise<Schema['fields']>;
-}
-/** Everything a source provides for a collection. */
-interface LoadedSchema<T = Record<string, unknown>> {
-    schema: Schema;
-    backend: CollectionBackend<T>;
-    fieldActions?: FieldActions;
-}
-
-/** Read/write permission defaults a source supports, per audience. */
-interface FieldPermissions {
-    installedApps?: {
-        hide?: boolean;
-        defaultRead?: boolean;
-        defaultWrite?: boolean;
-    };
-    siteVisitors?: {
-        hide?: boolean;
-        defaultRead?: boolean;
-        defaultWrite?: boolean;
-    };
-}
-/** The add-modal subtitle: a line of text, an optional second note line, and an
- *  optional "learn more" link. */
-interface FieldModalSubtitle {
-    text: string;
-    note?: string;
-    learnMore?: {
-        label: string;
-        href: string;
-    };
-}
-/** The text a source supplies for the add/edit field modal. */
-interface FieldModalText {
-    addTitle: string;
-    editTitle: string;
-    /** Subtitle for the add modal; omit for none. */
-    addSubtitle?: FieldModalSubtitle;
-    /** Label of the collapsible section below the main fields. */
-    settingsLabel?: string;
-}
-/** A warning shown under the PII toggle, with an optional action button. */
-interface FieldPiiWarning {
-    text: string;
-    action?: {
-        label: string;
-        onClick: () => void;
-    };
-}
-interface FieldModalCollectionOption {
-    id: string;
-    label: string;
-}
-type FieldModalCollectionOptionsLoader = () => Promise<FieldModalCollectionOption[]>;
-/** Extra collection picker a field type can add to the main modal body. */
-interface FieldModalCollectionInput {
-    label?: string;
-    placeholder?: string;
-    emptyStateMessage?: string;
-    errorMessage?: string;
-    required?: boolean;
-    loadOptions?: FieldModalCollectionOptionsLoader;
-    /** Restores the picker value from an existing field. */
-    getValue?: (field: Field) => string | undefined;
-    /** Adds picker-derived values to the source-owned settings payload. */
-    getSettings?: (collectionId: string) => FieldSettings;
-}
-interface FieldSettingsProps {
-    /** The picked field type, or absent before one is picked. */
-    fieldType?: string;
-    /** Validation rules the section should render as fixed, not user-editable.
-     *  A section ignores any entry it doesn't recognize. */
-    lockedRules?: readonly string[];
-}
-/**
- * The collapsible section below the main add/edit field inputs, supplied by the
- * source. The modal renders it, blocks confirm while it has an error, and hands
- * its values to the source's own `addField`/`editField` — it never looks inside.
- */
-interface FieldSettingsSection {
-    Component: ComponentType<FieldSettingsProps>;
-    /** True keeps the modal open on confirm. The section shows the error itself. */
-    hasError(fieldType?: string): boolean;
-    /** Passed to `FieldActions.addField`/`editField` as-is. */
-    getValues(fieldType?: string): FieldSettings;
-    /**
-     * Fills the inputs when the modal opens: the field being edited, or nothing
-     * for a new field. Pushed in rather than read from a prop, so the values are
-     * there whether or not the section has been rendered yet.
-     */
-    setValues(field?: Field): void;
-    /**
-     * Prefills a new field's rules from the caller's requested initial values —
-     * there is no backing `Field` yet, so this is separate from `setValues`.
-     * Absent ⇒ the section doesn't support prefilling any rule this way, and
-     * the modal drops that rule from `lockedProperties` rather than locking a
-     * control at a value it could never actually apply.
-     */
-    setInitialValues?(initial: {
-        required?: boolean;
-    }): void;
-}
-
-type ValidationRule = {
-    type: 'required';
-    message: string;
-} | {
-    type: 'min' | 'max';
-    value: number;
-    message: string;
-} | {
-    type: 'minLength' | 'maxLength';
-    value: number;
-    message: string;
-} | {
-    type: 'pattern';
-    value: RegExp;
-    message: string;
-} | {
-    type: 'custom';
-    validate: (value: unknown) => boolean;
-    message: string;
-} | {
-    type: 'specificValues';
-    values: {
-        id: string;
-        value: string;
-    }[];
-    message: string;
-};
-interface Focusable {
-    focus: () => void;
-}
-type EditTrigger = {
-    kind: 'type';
-    key: string;
-} | 'enter' | 'click' | 'doubleClick';
-interface CellViewProps<V> {
-    value: V;
-    typeConfig?: unknown;
-    validation?: ValidationRule[];
-    /** Stable id of the column. Cell components can use it to derive unique DOM ids. */
-    columnId: string;
-    /** Stable key of the row. Cell components can use it to derive unique DOM ids. */
-    rowKey: string;
-}
-interface CellEditProps<V> {
-    value: V;
-    onChange(value: V): void;
-    onCommit: () => void;
-    onCancel: () => void;
-    /**
-     * Signals that the cell is starting an editing operation that will move focus
-     * outside the table (e.g., opening a media manager or a modal). Calling this
-     * sets isEditing=true so the table does not clear cell focus while the
-     * external UI is open. Pair with onCommit (after the operation succeeds)
-     * or onCancel (if the user dismisses without a value change).
-     */
-    onStartEdit?: () => void;
-    /** Ref to the focusable input element. Used for type-to-edit (focusing the input when user starts typing on a focused cell). */
-    inputRef?: MutableRefObject<Focusable | undefined | null>;
-    typeConfig?: unknown;
-    /** How edit mode was triggered. Edit components can use this to customize behavior (e.g., date picker auto-opens on 'type'). */
-    editTrigger?: EditTrigger | null;
-    /** Column-level validation rules. Edit components can derive UI behavior (e.g., maxLength blocking/tooltip) from these. */
-    validation?: ValidationRule[];
-    /** Stable id of the column. Cell components can use it to derive unique DOM ids. */
-    columnId: string;
-    /** Stable key of the row. Cell components can use it to derive unique DOM ids. */
-    rowKey: string;
-}
-/**
- * Props passed to a cell type's optional `EditWrapper`. The table mounts the
- * wrapper around the cell content and keeps it mounted across the edit↔view
- * transition, so the wrapper can own behavior that must outlive the inline
- * editor (e.g. a reference cell navigating to an overlay and refreshing on
- * return). The wrapper hands anything the editor needs down via its own context.
- */
-interface CellEditWrapperProps {
-    /** The column's typeConfig (same value handed to the cell's Edit/View). */
-    typeConfig?: unknown;
-    /** Stable id of the column. */
-    columnId: string;
-    /** Stable key of the row. */
-    rowKey: string;
-    /** The cell content (the Edit or View component) to render inside the wrapper. */
-    children: ReactNode;
-}
-type EditableCellContextMenuAction = 'copy' | 'cut' | 'paste' | 'clear';
-interface EditableCellContextMenuActionContext<V> {
-    /** Current cell value, including pending or draft edits. */
-    value: V;
-    /** Field metadata associated with the column, when available. */
-    field?: Field;
-    /** Stable key of the row. */
-    rowKey: string;
-    /** Stable id of the column. */
-    columnId: string;
-}
-interface EditableCellContextMenuActionConfig<V> {
-    /** Returning a non-empty string disables the action and shows the tooltip. */
-    disabledTooltip(context: EditableCellContextMenuActionContext<V>): string | undefined;
-}
-/**
- * The editable-cell slot of a field type definition: how a cell of that type
- * renders, edits, and moves through the clipboard. The definition's key
- * identifies the type and the definition's `value` owns validation, so the
- * slot carries neither.
- *
- * Members that take `V` use method syntax so a definition typed with a
- * concrete value type stays assignable where a loosely typed definition is
- * expected (see `FieldTypeDefinition`).
- */
-interface EditableCellConfig<V> {
-    /** Render cell in view mode (read-only display). */
-    ViewComponent(props: CellViewProps<V>): ReactElement | null;
-    /** Render cell in edit mode (inline editor). Optional — omit for view-only cells. */
-    EditComponent?(props: CellEditProps<V>): ReactElement | null;
-    /** Serialize value to clipboard string. */
-    serialize?(value: V): string;
-    /** Deserialize clipboard string to value. */
-    deserialize?(raw: string): V;
-    /** Can this cell type be edited? (default: true) */
-    editable?: boolean;
-    /** Availability of Cairo's built-in cell context-menu actions. */
-    contextMenu?: Partial<Record<EditableCellContextMenuAction, EditableCellContextMenuActionConfig<V>>>;
-    /** Toggle value on single click (e.g., boolean checkbox). Skips focus→edit flow. */
-    toggleValue?(value: V): V;
-    /** Enter edit mode on single click (e.g., image cell with no value). */
-    editOnClick?(value: V): boolean;
-    /** Show the EditComponent when the cell is focused, without entering edit mode.
-     *  Keyboard navigation remains active. Similar to toggleValue but without toggling. */
-    showEditWhenFocused?: boolean;
-    /** Optional wrapper component the cell type defines to own behavior that must
-     *  outlive the inline editor. Mounted around the cell content and kept mounted
-     *  across the edit↔view transition. */
-    EditWrapper?: ComponentType<CellEditWrapperProps>;
-    /** Cell content can grow past row height when focused. Only applies to
-     *  showEditWhenFocused cells. */
-    growable?: boolean;
-    /** Called on type-to-edit. Return object with cleared value and/or prevent flag.
-     *  Return undefined to block the key. Return {} to enter edit mode without changing the value. */
-    onTypeToEdit?(params: {
-        key: string;
-        validation?: ValidationRule[];
-    }): {
-        value?: V;
-    } | undefined;
-    /** Optional hook to normalize the committed value (e.g. auto-prepend https://).
-     *  Called before the edit commits; the value is written back before committing. */
-    normalizeOnCommit?(value: V): V;
-    /** When true, type-to-edit flushes the edit-mode render synchronously and
-     *  focuses the input within the same keydown event, then lets the browser's
-     *  default action deliver the keystroke to the now-focused input naturally.
-     *  Use for cells that wrap a controlled input whose value can't be seeded via props. */
-    nativeTypeToEdit?: boolean;
-}
-/** The props the filter builder passes to a definition's toolbar filter
- *  component — the same contract the built-in filter elements receive. */
-interface FilterTypeComponentProps<V = any> {
-    filter: Filter<V>;
-    toolbarItemProps?: {
-        label?: ReactNode;
-    };
-    toolbarTagProps?: {
-        label?: string;
-    };
-    accordionItemProps?: {
-        label?: string;
-    };
-}
-/** The filter slot of a field type definition: the filter state registered on
- *  the collection query and the toolbar element that renders it. */
-interface FilterTypeConfig {
-    createFilter: (field: Field) => Filter<any>;
-    Component: ComponentType<FilterTypeComponentProps>;
-}
-/**
- * The read-only table slot of a field type definition: how a cell of that
- * type renders in the table, and the column's layout. Independent of
- * `editableTable` — neither slot falls back to the other.
- */
-/** What a read-only table cell is told about itself. */
-interface TableCellProps<V> {
-    value: V;
-    /** Stable id of the column. Cell components can use it to derive unique DOM ids. */
-    columnId: string;
-    /** The row this cell belongs to, so a cell can act on its item and not just
-     *  display it. Typed loosely for the same reason as `FieldsSource.getCellValue`:
-     *  the row shape belongs to the source, not to Cairo. */
-    row: unknown;
-}
-interface TableCellConfig<V> {
-    /** Render the cell. Method syntax keeps the definition assignable to
-     *  `FieldTypeDefinition<unknown>` (see FieldTypeDefinition). */
-    CellComponent(props: TableCellProps<V>): ReactElement | null;
-    /** Column width. Required — custom types get no built-in layout default. */
-    width: string;
-    /** Default: 'start'. */
-    align?: 'start' | 'center' | 'end';
-}
-/** An extra menu item a field type definition adds to a field's actions menu. */
-interface FieldTypeActionItem {
-    key: string;
-    label: string;
-    icon?: ReactNode;
-    skin?: 'destructive';
-    onClick: (field: Field) => void;
-    /** Default: visible. */
-    visible?: (field: Field) => boolean;
-    /** Returning a string disables the item and shows the tooltip. */
-    disabledTooltip?: (field: Field) => string | undefined;
-}
-/** The actions slot of a field type definition: extra items for the field's "more actions" menu. */
-interface FieldActionsConfig {
-    items?: FieldTypeActionItem[];
-}
-/** Display metadata for a field type: menu label and type icons. */
-interface FieldTypeDisplay {
-    label: string;
-    icons: {
-        Small: ComponentType;
-        Medium: ComponentType;
-    };
-}
-/** Value semantics of a field type, independent of any rendering surface.
- *  Members use method syntax so a definition typed with a concrete value type
- *  stays assignable where a loosely typed definition is expected. */
-interface FieldValueBehavior<V> {
-    defaultValue?: V;
-    isEmpty?(value: V): boolean;
-    /** Returns an error message, or null when the value is valid. Every surface
-     *  that validates a field of this type runs this. */
-    validate?(value: V, rules?: ValidationRule[]): string | null;
-}
-interface FieldCapabilities {
-    sortable: boolean;
-}
-/** The field-modal slot of a field type definition: opts the type into the
- *  add/edit-field modal's type picker and describes its entry there. */
-interface FieldModalConfig {
-    /** True ⇒ the add-field modal offers this type. */
-    creatable: boolean;
-    /** Placeholder for the name input. Absent ⇒ the modal's generic placeholder. */
-    namePlaceholder?: string;
-    /** One-line description under the type in the picker. */
-    subtitle?: string;
-    /** Group heading this type is listed under in the picker. */
-    group?: string;
-    /** Whether a field of this type can be marked PII. Absent ⇒ follows the
-     *  source-wide setting. */
-    supportsPii?: boolean;
-    /** Warning shown while the PII toggle is on. Read on every render, so it can
-     *  use data that only exists once the schema has loaded. Default: none. */
-    piiWarning?: () => FieldPiiWarning | undefined;
-    /** This type's collapsible settings section — the same contract a
-     *  source-declared type option carries (see `FieldSettingsSection`). */
-    settingsSection?: FieldSettingsSection;
-    /** Collection picker shown in the main add/edit field form. */
-    collectionInput?: FieldModalCollectionInput;
-}
-/**
- * Props the entity-page form dispatcher passes to a field type's form
- * component. The dispatcher owns the form wiring (registration, validation
- * from the definition's `value.validate`) and the field UI (label, required
- * marker, error message); the component renders the input: read `value`,
- * report edits through `onChange`, and hand back the focusable control
- * through `inputRef` so a blocked save can reach it.
- */
-interface FormFieldComponentProps<V> {
-    field: Field;
-    value: V;
-    onChange(value: V): void;
-    /** Call when the input loses focus — marks the field touched, so error
-     *  timing matches the built-in renderers. */
-    onBlur: () => void;
-    /** Ref to the focusable input element. Used to focus the field when a
-     *  blocked save reports an error on it. Absent ⇒ the entity page brings the
-     *  field into view and focuses the first control it finds inside. */
-    inputRef?: MutableRefObject<Focusable | undefined | null>;
-    dataHook?: string;
-}
-/** The entity-page form slot of a field type definition. */
-interface FormTypeConfig<V = unknown> {
-    /** Renders the input. Method syntax keeps the definition assignable to
-     *  `FieldTypeDefinition<unknown>` (see FieldTypeDefinition). */
-    Component(props: FormFieldComponentProps<V>): ReactElement | null;
-}
+/** The resolved source: defaults filled, `loadSchema` memoized. */
 /**
- * A consumer-defined field type. Defined once on the fields source; every
- * entry point that renders the field resolves its slot from here. `V` is the
- * field's value type — `defineFieldType` infers it, and it keeps all the
- * slots consistent with each other.
- *
- * Sources hold definitions of mixed value types in one
- * `FieldTypeDefinition[]` (= `FieldTypeDefinition<unknown>[]`) array. That
- * works because every member that takes `V` is declared with method syntax,
- * which TypeScript checks bivariantly — so `FieldTypeDefinition<number>` is
- * assignable to `FieldTypeDefinition<unknown>` without casts.
+ * `SchemaSource` — cut here because it has its own bundle.
+ * Full shape: `types/SchemaSource.d.ts`.
  */
-interface FieldTypeDefinition<V = unknown> {
-    /** Unique key for the type. A built-in type uses its `PatternsFieldType`; a
-     *  consumer-defined type uses the string its fields reference via `customType`. */
-    type: string;
-    display: FieldTypeDisplay;
-    /** Filter behavior, or an explicit opt-out — never silently absent. */
-    filter: FilterTypeConfig | {
-        filterable: false;
-    };
-    value?: FieldValueBehavior<V>;
-    capabilities?: FieldCapabilities;
-    /** Absent ⇒ the field renders with the default cell in the read-only table. */
-    table?: TableCellConfig<V>;
-    /** Absent ⇒ the field renders as a read-only cell in editable surfaces. */
-    editableTable?: EditableCellConfig<V>;
-    /** Required once a field of this type renders on an entity page:
-     *  development throws without it; production skips the field. */
-    form?: FormTypeConfig<V>;
-    /** Extra items for the field's "more actions" menu. */
-    actions?: FieldActionsConfig;
-    /** Absent ⇒ the add/edit field modal never offers this type. Fields of the
-     *  type created elsewhere still open in the modal for name/PII edits. */
-    fieldModal?: FieldModalConfig;
-}
-
-/** A field type the add/edit field modal offers, with everything that type
- *  brings to it. Declare one entry per `patternsType` — the type is the entry's
- *  identity. Nothing here reaches the table or the filters; that is `fieldTypes`
- *  (`FieldTypeDefinition[]`). */
-interface FieldTypeOption {
-    patternsType: PatternsFieldType;
-    /** Custom display name. Absent ⇒ the UI's standard name for this type. */
-    label?: string;
-    /** Custom name-input placeholder. Absent ⇒ the UI's standard placeholder. */
-    namePlaceholder?: string;
-    /** A one-line description shown under the type in the add-field menu. */
-    subtitle?: string;
-    /** The group heading this type is listed under in the add-field menu, in
-     *  first-seen order. Types sharing a heading form one group. Absent ⇒
-     *  ungrouped. */
-    group?: string;
-    /** Whether a field of this type can be marked PII. Absent ⇒ follows the
-     *  source's `supportsPii`. */
-    supportsPii?: boolean;
-    /** Warning shown while the PII toggle is on. Read on every render, so it can
-     *  use data that only exists once the schema has loaded. Default: none. */
-    piiWarning?: () => FieldPiiWarning | undefined;
-    /** This type's own part of the collapsible section in the add/edit field
-     *  modal. Default: none. */
-    settingsSection?: FieldSettingsSection;
-    /** Collection picker shown in the main add/edit field form. */
-    collectionInput?: FieldModalCollectionInput;
-}
-/** The resolved source: defaults filled, `loadSchema` memoized. */
-interface SchemaSource<T> {
-    readonly collectionId: string;
-    loadSchema: () => Promise<LoadedSchema<T>>;
-    readonly paginationMode: 'offset';
-    /** Stable row identity. */
-    itemKey: (item: T) => string;
-    /** Row display label. */
-    itemName: (item: T) => string;
-    /** Sources for referenced collections, keyed by referenced collection id. */
-    readonly references: Record<string, SchemaSource<any>>;
-    getReferencedCollectionSource?: (collectionId: string) => SchemaSource<any> | undefined;
-    readonly fieldModal: {
-        text?: FieldModalText;
-        loadReferenceableCollectionOptions?: FieldModalCollectionOptionsLoader;
-        types: FieldTypeOption[];
-    };
-    readonly fieldTypes: FieldTypeDefinition[];
-    searchableFieldIds: (schema: Schema) => string[];
-    canAddFields: (schema: Schema) => boolean;
-    canEditField: (field: Field, schema: Schema) => boolean;
-    canDeleteField: (field: Field, schema: Schema) => boolean;
-    readonly fieldPermissions?: FieldPermissions;
-    readonly supportsPii: boolean;
-    /** The value of a field on an item. */
-    getFieldValue: (item: T, field: Field) => unknown;
-    /** Writes a field's value on an item, returning the updated item. */
-    setFieldValue: (item: T, field: Field, value: unknown) => T;
-    /** Replaces the memoized schema returned by later `loadSchema()` calls.
-     *  No-op before the first successful load. */
-    setLoadedSchema?: (schema: Schema) => void;
+interface SchemaSource<T = any> {
+    [key: string]: unknown;
 }
 
 type ToastType = 'STANDARD' | 'PREMIUM' | 'SUCCESS' | 'WARNING' | 'ERROR';
@@ -750,36 +58,6 @@ interface ActionsBarConfig {
     };
 }
 
-/**
- * `Filter` — cut here because it has its own bundle.
- * Look `Filter` up in the bundle index for its full shape.
- */
-interface Filter<T = any> {
-    [key: string]: unknown;
-}
-type FiltersMap = {
-    [key: string]: Filter<any> | undefined;
-};
-type OptionalFiltersMap = {
-    [key: string]: undefined;
-};
-
-/**
- * `ComputedQuery` — cut here because it has its own bundle.
- * Look `ComputedQuery` up in the bundle index for its full shape.
- */
-interface ComputedQuery<F = any> {
-    [key: string]: unknown;
-}
-
-/**
- * `DataResultRaw` — cut here because it has its own bundle.
- * Look `DataResultRaw` up in the bundle index for its full shape.
- */
-interface DataResultRaw<T = any> {
-    [key: string]: unknown;
-}
-
 type DeleteErrorToast = (err: unknown, params: {
     retry: () => void;
 }) => {
@@ -915,7 +193,7 @@ interface EntityPageStateParamsBase<T, V extends FieldValues = FieldValues> {
 }
 /**
  * `EntityPageStateParams` — cut here because it has its own bundle.
- * Look `EntityPageStateParams` up in the bundle index for its full shape.
+ * Full shape: `types/EntityPageStateParams.d.ts`.
  */
 type EntityPageStateParams<T = any, V = any> = EntityPageStateParamsBase<T, V>;
 interface EntityPageStateInterface {
@@ -929,7 +207,7 @@ interface EntityPageWidgetState {
 }
 /**
  * `EntityPageState` — you receive this, you don't construct it.
- * Produced by `useEntityPage()` (also `useEntityPageContext()`). Look `EntityPageState` up in the bundle index for its own API.
+ * Produced by `useEntityPage()` (also `useEntityPageContext()`). Its own API is in `types/EntityPageState.d.ts`.
  */
 declare class EntityPageState<T = any, V = any> {
     [key: string]: unknown;