@wix/patterns 1.475.0 → 1.477.0

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

@@ -0,0 +1,839 @@
+import React, { MutableRefObject, ReactElement, ComponentType, ReactNode, CSSProperties } from 'react';
+import { AtlasService, RichTextStyleVariables } from '@wix/patterns-fields';
+import { TableColumn as TableColumn$1 } from '@wix/design-system';
+
+/**
+ * `TranslationsKeys` — widened to `string`.
+ * Generated key list that is cairo's own, not something a caller writes, so it is not published as its own bundle.
+ */
+type TranslationsKeys = string;
+type Translate = {
+    (key: TranslationsKeys, params?: Record<string, string | number>): string;
+    (key: 'cairo.import.summaryUpdated', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.import.missingRequiredMessage', params: {
+        fields: string;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.deleteModal.body.asLabels', params: {
+        name: string;
+    }): string;
+    (key: 'cairo.filtersPanel.numRange.maxRange.consumer.error', params: {
+        maxAmount: number;
+    }): string;
+    (key: 'cairo.bulkSelectedWithTotal', params: {
+        num: number;
+        total: number;
+    }): string;
+    (key: 'cairo.import.newFieldOption', params: {
+        column: string;
+    }): string;
+    (key: 'cairo.setupWidget.progress.label', params: {
+        completed: string;
+        total: number;
+    }): string;
+    (key: 'cairo.search.Tab.noresults.title', params: {
+        tabName: string;
+    }): string;
+    (key: 'cairo.fieldValidation.charactersLimit.outOfBounds.error', params: {
+        min: number;
+        max: number;
+    }): string;
+    (key: 'cairo.manageView.setAsDefault.error.toast', params: {
+        viewName: string;
+    }): string;
+    (key: 'cairo.deleteSuccess', params: {
+        itemName: string;
+    }): string;
+    (key: 'cairo.import.partialSuccess', params: {
+        succeeded: string;
+        failed: string;
+    }): string;
+    (key: 'cairo.saveView.Success.toast', params: {
+        viewName: string;
+    }): string;
+    (key: 'cairo.customFields.fieldType.date.invalid.value', params: {
+        dateFormat: string;
+    }): string;
+    (key: 'cairo.customFields.maxFields.tooltip', params: {
+        max: number;
+    }): string;
+    (key: 'cairo.bulkActions.max.selection', params: {
+        total: number;
+        max: number;
+    }): string;
+    (key: 'cairo.customFields.delete.modal.title', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.customFields.deleted.success.toast', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.collectionPage.nestedLimit.tooltip', params: {
+        subCatsAmount: number;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.list.create.CTA', params: {
+        tagName: string;
+    }): string;
+    (key: 'cairo.import.summaryCreated', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.customFields.archive.modal.title.enabled', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.editableTable.contextMenu.deleteRow.CTA', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.import.partialSuccessToast', params: {
+        failed: string;
+        imported: string;
+    }): string;
+    (key: 'cairo.settings.search.anchor-doesnt-exist.error', params: {
+        anchorName: string;
+    }): string;
+    (key: 'cairo.tags.creationLimitReached.error.asLabels', params: {
+        limit: string;
+        count: number;
+    }): string;
+    (key: 'cairo.editableTable.field.validation.required', params: {
+        fieldName: string;
+    }): string;
+    (key: 'cairo.emptyState.subtitle.nothingMatches', params: {
+        term: string;
+    }): string;
+    (key: 'cairo.customFields.restore.error.toast', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.editableTable.updateItem.success.toast', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.sortableColumns.modal.title', params: {
+        columnTitle: string;
+    }): string;
+    (key: 'cairo.table.deleteViewModal.deleteBody', params: {
+        viewName: string;
+    }): string;
+    (key: 'cairo.table.summaryBar.list.item', params: {
+        title: string;
+        value: string;
+    }): string;
+    (key: 'cairo.customFields.delete.modal.description', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.bulkSelected', params: {
+        num: number;
+    }): string;
+    (key: 'cairo.tags.collectionPage.popover.create.CTA.asLabels', params: {
+        tagName: string;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.title.asLabels', params: {
+        EntityName: string;
+    }): string;
+    (key: 'cairo.fieldValidation.maxCharacter', params: {
+        charMax: number;
+    }): string;
+    (key: 'cairo.picker.itemsSelected', params: {
+        total: number;
+        max: number;
+    }): string;
+    (key: 'cairo.filtersPanel.numRange.minRange.consumer.error', params: {
+        minAmount: number;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.list.create.CTA.asLabels', params: {
+        tagName: string;
+    }): string;
+    (key: 'cairo.manageView.Rename.Success.toast', params: {
+        oldViewName: string;
+        newViewName: string;
+    }): string;
+    (key: 'cairo.tags.creationLimitReached.error', params: {
+        limit: string;
+        count: number;
+    }): string;
+    (key: 'cairo.fieldValidation.minCharacter', params: {
+        charMin: number;
+    }): string;
+    (key: 'cairo.appliedFilters', params: {
+        num: number;
+    }): string;
+    (key: 'cairo.tags.bulkItemUpdate.toast.error.asLabels', params: {
+        total: number;
+    }): string;
+    (key: 'cairo.fieldValidation.minNumber', params: {
+        minAmount: number;
+    }): string;
+    (key: 'cairo.setupWidget.aggregated.counter', params: {
+        completed: string;
+        total: number;
+    }): string;
+    (key: 'cairo.bulkSelected.selectUpTo', params: {
+        max: number;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.deleteModal.body', params: {
+        name: string;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.title', params: {
+        EntityName: string;
+    }): string;
+    (key: 'cairo.sortableColumns.modal.description', params: {
+        columnTitle: string;
+    }): string;
+    (key: 'cairo.deleteView.Success.toast', params: {
+        viewName: string;
+    }): string;
+    (key: 'cairo.entity.item', params: {
+        num: number;
+    }): string;
+    (key: 'cairo.import.summaryFailed', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.manageView.saveChanges.Success.toast', params: {
+        viewName: string;
+    }): string;
+    (key: 'cairo.search.nothingMatches.title', params: {
+        term: string;
+    }): string;
+    (key: 'cairo.editableTable.deleteItem.success.toast', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.dragAndDrop.live-region.itemDragged.sr', params: {
+        currentNumber: number;
+        totalNumber: number;
+    }): string;
+    (key: 'cairo.editableTable.field.validation.pattern', params: {
+        fieldName: string;
+    }): string;
+    (key: 'cairo.import.summaryCounts', params: {
+        succeeded: string;
+        failed: string;
+    }): string;
+    (key: 'cairo.import.newFieldHelper', params: {
+        typeName: string;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.list.input.validation.maxLength', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.selector.modal.items.selected', params: {
+        total: number;
+    }): string;
+    (key: 'cairo.import.missingRequiredField', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.tags.manageTags.modal.list.input.validation.maxLength.asLabels', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.selected', params: {
+        total: number;
+    }): string;
+    (key: 'cairo.editableTable.contextMenu.clearCell.CTA', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.filtersPanel.search.noResults.title', params: {
+        term: string;
+    }): string;
+    (key: 'cairo.sortableColumns.notification', params: {
+        columnTitle: string;
+    }): string;
+    (key: 'cairo.tags.popover.creationLimitReached.error.asLabels', params: {
+        limit: string;
+        count: number;
+    }): string;
+    (key: 'cairo.import.summaryErrorRow', params: {
+        row: string;
+        message: string;
+    }): string;
+    (key: 'cairo.editableTable.field.validation.specificValues', params: {
+        fieldName: string;
+    }): string;
+    (key: 'cairo.tags.popover.creationLimitReached.error', params: {
+        limit: string;
+        count: number;
+    }): string;
+    (key: 'cairo.fieldValidation.maxNumber', params: {
+        maxAmount: number;
+    }): string;
+    (key: 'cairo.customFields.archive.success.toast.enabled', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.customFields.restored.success.toast', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.appliedFilters.selected', params: {
+        num: number;
+    }): string;
+    (key: 'cairo.editableTable.contextMenu.removeRows.CTA', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.customFields.delete.error.toast', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.tags.collectionPage.popover.create.CTA', params: {
+        tagName: string;
+    }): string;
+    (key: 'cairo.import.fileNameLabel', params: {
+        name: string;
+    }): string;
+    (key: 'cairo.tags.bulkItemUpdate.toast.error', params: {
+        total: number;
+    }): string;
+    (key: 'cairo.dragAndDrop.button-role-label.sr', params: {
+        itemName: string;
+    }): string;
+    (key: 'cairo.dropdownSearch.filters.selected', params: {
+        total: number;
+    }): string;
+    (key: 'cairo.tags.tagsWidget.options.add.CTA', params: {
+        tagName: string;
+    }): string;
+    (key: 'cairo.customFields.archive.error.toast', params: {
+        selectedField: string;
+    }): string;
+    (key: 'cairo.editableTable.row.invalidFields.tooltip', params: {
+        count: number;
+    }): string;
+    (key: 'cairo.a11y.liveRegion.resultsFound', params: {
+        num: number;
+    }): string;
+    (key: 'cairo.dragAndDrop.live-region.itemDropped.sr', params: {
+        currentNumber: number;
+    }): string;
+    (key: 'cairo.manageView.setAsDefault.success.toast', params: {
+        viewName: string;
+    }): string;
+    (key: 'cairo.filtersPanel.appliedFilters.label', params: {
+        numberAppliedFilters: number;
+    }): string;
+    (key: 'cairo.tags.tagsWidget.options.add.CTA.asLabels', params: {
+        tagName: string;
+    }): string;
+};
+
+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;
+
+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;
+    /** Whether the cell is editable. Used to conditionally render placeholders (don't show them for read-only cells). */
+    isEditable?: boolean;
+}
+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;
+}
+
+type SortOrder = 'asc' | 'desc';
+type SortOrderWithNone = SortOrder | undefined;
+/**
+ * @deprecated always option is deprecated
+ */
+type SortModeDeprecated = 'always';
+type SortMode = SortModeDeprecated | SortOrderWithNone[];
+
+/**
+ * `ComputedQuery` — cut here because it has its own bundle.
+ * Full shape: `types/ComputedQuery.d.ts`.
+ */
+interface ComputedQuery<F = any> {
+    [key: string]: unknown;
+}
+
+interface KeyedItem<T> {
+    item: T;
+    key: string;
+    id: string;
+    pageIndex: number;
+    indexWithinPage: number;
+    index: number;
+}
+
+/**
+ * Canonical field type keys (UPPER_SNAKE_CASE).
+ * The map is keyed by these values; incoming camelCase strings
+ * are normalised before lookup.
+ */
+type FieldType = 'SHORT_TEXT' | 'LONG_TEXT' | 'NUMBER' | 'BOOLEAN' | 'DATE' | 'DATE_TIME' | 'DATETIME' | 'TIME' | 'URL' | 'EMAIL' | 'IMAGE' | 'MEDIA_GALLERY' | 'AUDIO' | 'DOCUMENT' | 'MULTI_DOCUMENT' | 'RICH_TEXT' | 'RICH_CONTENT' | 'REFERENCE' | 'MULTI_REFERENCE' | 'OBJECT' | 'ARRAY' | 'ADDRESS' | 'COLOR' | 'INTEGER' | 'DECIMAL' | 'CHECKBOX' | 'DROPDOWN' | 'FILES' | 'MULTI_SELECT';
+
+type TableColumnBase<T = any> = Omit<TableColumn$1<T>, 'sortDescending' | 'sortable' | 'infoTooltipProps' | 'style' | 'titleSuffix'> & {
+    style?: CSSProperties | ((column: TableColumn$1, rowData: KeyedItem<T>, rowNum: number) => CSSProperties);
+    reorderDisabled?: boolean;
+    defaultSortOrder?: SortOrder;
+    sortMode?: SortMode;
+    searchable?: boolean;
+    infoTooltipProps?: TableColumn$1['infoTooltipProps'] & {
+        panelContent?: ReactNode;
+    };
+    mobile?: ColumnMobileConfig;
+    /**
+     * The field type string used to resolve a prefix icon for the column.
+     * Cairo maps this to the appropriate icon internally.
+     * @external
+     */
+    fieldType?: FieldType;
+    /**
+     * Explicit prefix icons for the column (e.g. a custom field type's
+     * `display.icons`). When present, used instead of the `fieldType` mapping.
+     * @external
+     */
+    fieldTypeIcons?: {
+        Small: ComponentType;
+        Medium: ComponentType;
+    };
+    /**
+     * Whether the field contains personally identifiable information.
+     * @external
+     */
+    isPii?: boolean;
+    /**
+     * only for cms. Whether this is a system-managed field.
+     * @external
+     */
+    isSystem?: boolean;
+    /**
+     * Whether this is the primary display field.
+     * @external
+     */
+    isPrimary?: boolean;
+    /**
+     * Column-level validation rules. When a `required` rule is present, a required indicator is shown in the custom columns panel.
+     * @external
+     */
+    validation?: ValidationRule[];
+};
+interface TableColumnOptional<T> extends TableColumnBase<T> {
+    id?: string;
+    name?: string;
+    hiddenFromCustomColumnsSelection?: undefined | true;
+    hideable?: undefined;
+    defaultHidden?: undefined;
+}
+interface TableColumnCustom<T> extends TableColumnBase<T> {
+    id: string;
+    name: string;
+    hiddenFromCustomColumnsSelection?: false;
+    hideable?: true;
+    defaultHidden?: boolean;
+}
+interface TableColumnCustomOptionalName<T> extends TableColumnBase<T> {
+    id: string;
+    name?: string;
+    title: TableColumnBase['title'];
+    hiddenFromCustomColumnsSelection?: false;
+    hideable?: true;
+    defaultHidden?: boolean;
+}
+interface TableColumnCustomDefaultHidden<T> extends TableColumnBase<T> {
+    id: string;
+    name?: string;
+    title: TableColumnBase['title'];
+    hiddenFromCustomColumnsSelection?: false;
+    hideable: false;
+    defaultHidden?: undefined | false;
+}
+type CustomColumnConfig<T> = TableColumnOptional<T> | TableColumnCustom<T> | TableColumnCustomDefaultHidden<T> | TableColumnCustomOptionalName<T>;
+interface SortableColumnConfig<T> extends TableColumnBase<T> {
+    id: string;
+    sortable: true;
+}
+interface NotSortableColumnConfig<T> extends TableColumnBase<T> {
+    id?: string;
+    sortable?: false;
+}
+type SortableConfig<T> = SortableColumnConfig<T> | NotSortableColumnConfig<T>;
+/**
+ * `TableColumn` — cut here because it has its own bundle.
+ * Full shape: `types/TableColumn.d.ts`.
+ */
+type TableColumn<T = any> = CustomColumnConfig<T> & SortableConfig<T>;
+type ColumnMobileConfig = {
+    /**
+     * Which mobile column to display in.
+     * - 'first': Stacks vertically with other 'first' columns
+     * - 'second': Displays as standalone second column
+     * - undefined: Hidden on mobile
+     */
+    column: 'first';
+    /**
+     * Sort order within 'first' column (lower appears higher).
+     * Only relevant when column is 'first'.
+     * @default Infinity
+     */
+    order?: number;
+} | {
+    /**
+     * Which mobile column to display in.
+     * - 'first': Stacks vertically with other 'first' columns
+     * - 'second': Displays as standalone second column
+     * - undefined: Hidden on mobile
+     */
+    column?: 'second';
+};
+
+interface ReferenceItem {
+    id: string;
+    name: string;
+    image?: string;
+}
+type RefFieldType = 'IMAGE';
+interface RefSchemaField {
+    type: RefFieldType;
+}
+interface RefSchema {
+    id: string;
+    /** The id of the referenced collection, used to navigate to it from the cell editor. */
+    collectionId?: string;
+    displayField: string;
+    idField: string;
+    fields?: Record<string, RefSchemaField | undefined>;
+}
+interface ReferenceTypeConfig {
+    refSchema: RefSchema;
+    fetchReferenceItems: (query: ComputedQuery) => Promise<{
+        items: ReferenceItem[];
+        total: number;
+    }>;
+    renderFooter?: () => React.ReactNode;
+}
+
+interface AddressCellTypeConfig {
+    /**
+     * Atlas service used to fetch address suggestions. Defaults to the SDK-backed
+     * WixAtlasService, which requires Wix runtime/auth context. Inject a custom
+     * implementation for tests or non-Wix consumers.
+     */
+    atlasService?: AtlasService;
+}
+
+interface RichTextCellTypeConfig {
+    textStyle?: RichTextStyleVariables;
+}
+interface Cell {
+    rowKey: string;
+    columnId: string;
+}
+interface CellBorder {
+    top: boolean;
+    bottom: boolean;
+    left: boolean;
+    right: boolean;
+}
+
+interface ValidationResult {
+    valid: boolean;
+    errors?: string[];
+}
+interface CellType {
+    type: keyof CellTypeConfigMap;
+    /** Render cell in view mode (read-only display) */
+    ViewComponent: ComponentType<CellViewProps<any>>;
+    /** Render cell in edit mode (inline editor). Optional — omit for view-only cells. */
+    EditComponent?: ComponentType<CellEditProps<any>>;
+    /** Serialize value to clipboard string */
+    serialize?: (value: any) => string;
+    /** Deserialize clipboard string to value */
+    deserialize?: (raw: string) => any;
+    /** Validate a cell value. Return null if valid, or error message string.
+     *  `translate` is optional so cell types whose validate doesn't need
+     *  localization (text/number/date/…) can keep their existing call sites.
+     *  Cell types that DO localize (array/object) must be called with a translator. */
+    validate?: (value: any, rules?: ValidationRule[], translate?: Translate) => string | null;
+    /** Can this cell type be edited? (default: true) */
+    editable?: boolean;
+    /** Availability of Cairo's built-in cell context-menu actions. */
+    contextMenu?: EditableCellConfig<unknown>['contextMenu'];
+    /** Toggle value on single click (e.g., boolean checkbox). Skips focus→edit flow. */
+    toggleValue?: (value: any) => any;
+    /** Enter edit mode on single click (e.g., image cell with no value). */
+    editOnClick?: (value: any) => 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. EditableCell mounts it around the cell content
+     *  and keeps it mounted across the edit↔view transition (e.g. a reference cell
+     *  navigating to an overlay and refreshing the table on return). The wrapper
+     *  hands anything the editor needs down via its own context. */
+    EditWrapper?: ComponentType<CellEditWrapperProps>;
+    /** Cell content can grow past row height when focused (e.g. multi-document
+     *  wraps chips into multiple rows). The framework releases the bottom anchor
+     *  and lays an opaque base under the selection tint so the overflow doesn't
+     *  bleed adjacent rows through.
+     *  Only applies to showEditWhenFocused cells — others release the bottom
+     *  anchor via :editing already. */
+    growable?: boolean;
+    /** Called on type-to-edit. Return object with cleared value and/or prevent flag.
+     *  CMS-web pattern: text clears to '', number clears only for digits, date blocks non-digits.
+     *  Return undefined to block the key. Return {} to enter edit mode without changing the value. */
+    onTypeToEdit?: (params: {
+        key: string;
+        validation?: ValidationRule[];
+    }) => {
+        value?: any;
+    } | undefined;
+    /** Optional hook to normalize the committed value (e.g. auto-prepend https://).
+     *  Called before commitEdit() from EditableCell (blur/Enter) and useKeyboardNavigation (Tab).
+     *  The value is written back to editingValue via runInAction before committing. */
+    normalizeOnCommit?: (value: any) => any;
+    /** 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
+     *  (no preventDefault, no programmatic value injection).
+     *  Mirrors cms-web's `focusOnTyping` pattern. Use for cells that wrap a
+     *  controlled input whose value can't be seeded via props (e.g. WSR TimeInput). */
+    nativeTypeToEdit?: boolean;
+}
+interface CellTypeConfigMap {
+    text: never;
+    number: never;
+    boolean: never;
+    url: never;
+    email: never;
+    color: never;
+    date: never;
+    time: never;
+    datetime: never;
+    object: never;
+    array: never;
+    image: never;
+    document: never;
+    multiDocument: never;
+    richContent: never;
+    video: never;
+    audio: never;
+    richText: RichTextCellTypeConfig;
+    mediaGallery: never;
+    reference: ReferenceTypeConfig;
+    multiReference: ReferenceTypeConfig;
+    address: AddressCellTypeConfig;
+    /** An inline custom cell: the full cell contract minus the registry key.
+     *  Authorable directly on a column (`cellType: 'custom'` + `typeConfig`),
+     *  and also produced by the column builder when a schema field's type
+     *  definition (registered via the source's `fieldTypes`) has an
+     *  `editableTable` slot. */
+    custom: Omit<CellType, 'type'>;
+}
+interface EditableColumnBase<T> extends Omit<TableColumn<T>, 'render'> {
+    id: string;
+    /** Column type — maps to a CellType in the registry */
+    cellType: keyof CellTypeConfigMap;
+    /** Extract the cell value from the row data */
+    getValue: (item: T) => any;
+    /** Field metadata associated with the column, when available. */
+    field?: Field;
+    /** Return updated item with new cell value (immutable) */
+    setValue?: (item: T, value: any) => T;
+    /** Column-level validation rules */
+    validation?: ValidationRule[];
+    /** Is this column editable? (default: true if setValue exists) */
+    editable?: boolean | ((item: T) => boolean);
+    /** True if this column represents the schema's primary field. Drives header-action disable rules (e.g. blocks Delete, blocks Make Primary). */
+    isPrimary?: boolean;
+    /** True if this column represents a system field. Drives header-action disable rules (e.g. blocks Edit, Delete, Duplicate). */
+    isSystem?: boolean;
+}
+type EditableColumn<T, C extends keyof CellTypeConfigMap = keyof CellTypeConfigMap> = C extends C ? EditableColumnBase<T> & {
+    cellType: C;
+    typeConfig?: CellTypeConfigMap[C] extends never ? never : CellTypeConfigMap[C];
+} : never;
+
+export type { Cell, CellBorder, CellType, CellTypeConfigMap, EditableColumn, RichTextCellTypeConfig, ValidationResult, ValidationRule };