@wix/patterns 1.476.0 → 1.477.0

package/dist/dts-bundle/components/LayoutSwitch.d.ts

@@ -0,0 +1,931 @@
+import * as React from 'react';
+import React__default, { Ref, JSXElementConstructor, ReactElement, ReactNode, CSSProperties, ComponentType } from 'react';
+import { MessageModalLayoutProps, CardGalleryItemProps, IconElement, AddItemProps, TableColumn as TableColumn$1 } from '@wix/design-system';
+import { AtlasService, RichTextStyleVariables } from '@wix/patterns-fields';
+import { ReportProps } from '@wix/fe-essentials/bi';
+import { ClientRect } from '@wix/wix-style-react-incubator/dnd-kit/core';
+
+type ReportBI = (reportProps: ReportProps) => void;
+
+/**
+ * `CollectionState` — you receive this, you don't construct it.
+ * Produced by `useFilterCollection()` (also `useStaticListFilterCollection()`, `useCollection()`, `createCollection()`).
+ */
+declare class CollectionState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+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;
+};
+
+type ToastType = 'STANDARD' | 'PREMIUM' | 'SUCCESS' | 'WARNING' | 'ERROR';
+type ToastTimeout = 'NONE' | 'NORMAL';
+type ToastPriority = 'LOW' | 'NORMAL' | 'HIGH';
+type ToastActionUiType = 'BUTTON' | 'LINK';
+type ToastAction = {
+    text: string;
+    onClick?: Function;
+    removeToastOnClick?: boolean;
+    uiType?: ToastActionUiType;
+    navigationTarget?: {
+        url: string;
+        openInNewTab?: boolean;
+    };
+};
+type ErrorToastDetails = {
+    requestId: string;
+};
+type ToastConfig = {
+    message: string;
+    biName?: string;
+    timeout?: ToastTimeout;
+    priority?: ToastPriority;
+    type?: ToastType;
+    onCloseClick?: () => unknown;
+    onToastSeen?: () => unknown;
+    action?: ToastAction;
+    details?: ErrorToastDetails;
+};
+
+/**
+ * `Filter` — cut here because it has its own bundle.
+ * Full shape: `types/Filter.d.ts`.
+ */
+interface Filter<T = any> {
+    [key: string]: unknown;
+}
+type FiltersMap = {
+    [key: string]: Filter<any> | undefined;
+};
+type OptionalFiltersMap = {
+    [key: string]: undefined;
+};
+
+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';
+
+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__default.ReactNode;
+}
+
+interface ActionCellAPI$1<T, F extends FiltersMap> {
+    openConfirmModal: (props?: Partial<MessageModalLayoutProps>) => void;
+    openConfirmDeleteModal: (props?: Partial<MessageModalLayoutProps>) => void;
+    collection: CollectionState<T, F>;
+    keyedItem: KeyedItem<T>;
+}
+
+interface DragAndDropParentState<T, F extends FiltersMap> {
+    readonly reportBi: ReportBI;
+    readonly dragAndDropCategories?: (keyof F)[][] | null | undefined;
+    forceRenderIndexes: undefined | number[];
+    readonly containerRect?: ClientRect;
+    readonly _dnd?: DragAndDropState<T, F> | null;
+}
+/**
+ * `DragAndDropState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class DragAndDropState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+type CollectionDragAndDropParentState<T, F extends FiltersMap> = DragAndDropParentState<T, F> & {
+    collection: CollectionState<T, F>;
+    getCollectionSnapshot?: () => {
+        [key: string]: string | number | undefined;
+    };
+};
+
+interface IndexedItem<T> {
+    id: string;
+    item: T;
+    index: number;
+}
+interface CollectionDragEndEvent<T, F extends FiltersMap> {
+    from: IndexedItem<T>;
+    after: IndexedItem<T> | null;
+    over: IndexedItem<T>;
+    filters: ComputedQuery<F>['filters'];
+}
+type DragAndDropSubmit<T, F extends FiltersMap> = (event: CollectionDragEndEvent<T, F>) => Promise<unknown>;
+type DragAndDropCancelResult = Omit<ToastConfig, 'type' | 'biName'> | boolean | null | undefined | void;
+type DragAndDropCancel<T, F extends FiltersMap> = (event: CollectionDragEndEvent<T, F>) => DragAndDropCancelResult | Promise<DragAndDropCancelResult>;
+interface GridCardItemProps {
+    index: number;
+    rowIndex?: number;
+    columnIndex?: number;
+    droppable?: boolean;
+    draggable?: boolean;
+    dragging?: boolean;
+    dragHandleProps?: React__default.HTMLAttributes<HTMLDivElement> & {
+        domRef?: Ref<HTMLDivElement>;
+    };
+    domRef?: (node: HTMLDivElement | null) => void;
+}
+type GridCardItem = React__default.ReactElement<GridCardItemProps, JSXElementConstructor<GridCardItemProps>>;
+interface DraggableCardProps<T, F extends FiltersMap> {
+    state: CollectionDragAndDropParentState<T, F>;
+    index: number;
+    id: string;
+    isOverlay?: boolean;
+    dndDisabled?: boolean;
+    children: GridCardItem;
+}
+interface DraggableCardOverlayProps<T, F extends FiltersMap> {
+    state: CollectionDragAndDropParentState<T, F>;
+    renderItem: (index: number) => ReactElement | null;
+}
+
+type BulkActionToolbarRenderProp<T, F extends FiltersMap> = (props: {
+    selectedValues: T[];
+    uncheckedValues: T[];
+    allSelected: boolean;
+    openModal: () => void;
+    clearSelection: () => void;
+    total: number;
+    openConfirmModal: (props?: Partial<MessageModalLayoutProps>) => void;
+    query: ComputedQuery<F>;
+}) => ReactElement;
+
+/**
+ * `ToolbarCollectionBaseProps` — cut here because it has its own bundle.
+ * Full shape: `types/ToolbarCollectionBaseProps.d.ts`.
+ */
+interface ToolbarCollectionBaseProps<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+type SupportedCardGalleryItemProps = Pick<CardGalleryItemProps, 'badge' | 'title' | 'subtitle' | 'suffix' | 'backgroundImageUrl' | 'backgroundImageNode' | 'primaryActionProps' | 'secondaryActionProps' | 'showSuffixOnHover' | 'settingsMenu'>;
+
+type RenderItemRawProps = Omit<Partial<SupportedCardGalleryItemProps>, 'title' | 'subtitle>'>;
+type GridPresetFullProps<T, P> = P & {
+    preset: 'full';
+    renderItem?: (item: T, index: number) => RenderItemRawProps & {
+        title?: React__default.ReactNode;
+        subtitle?: React__default.ReactNode;
+    };
+};
+type GridPresetFooterProps<T, P> = P & {
+    preset: 'footer';
+    renderItem?: (item: T, index: number) => RenderItemRawProps & {
+        title?: React__default.ReactNode;
+        subtitle?: React__default.ReactNode;
+    };
+};
+type GridPresetTitleProps<T, P> = P & {
+    preset?: 'title';
+    renderItem?: (item: T, index: number) => RenderItemRawProps & {
+        title?: React__default.ReactNode;
+        subtitle?: undefined;
+    };
+};
+type GridPresetEmptyProps<T, P> = P & {
+    preset: 'empty';
+    renderItem?: (item: T, index: number) => RenderItemRawProps & {
+        title?: undefined;
+        subtitle?: undefined;
+    };
+};
+type Preset = 'full' | 'footer' | 'title' | 'empty';
+type GridPresetGenericProps<T, P> = P & {
+    preset?: Preset;
+    renderItem?: (item: T, index: number) => RenderItemRawProps & {
+        title?: React__default.ReactNode;
+        subtitle?: React__default.ReactNode;
+    };
+};
+type GridPresetProps<T, P> = GridPresetFullProps<T, P> | GridPresetTitleProps<T, P> | GridPresetEmptyProps<T, P> | GridPresetGenericProps<T, P> | GridPresetFooterProps<T, P>;
+
+type LayoutType = 'grid' | 'list';
+/**
+ * `GridBaseState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class GridBaseState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+/**
+ * `TableState` — you receive this, you don't construct it.
+ * Produced by `useTableCollection()` (also `useAmbassadorTable()`, `useTableContext()`). Its own API is in `types/TableState.d.ts`.
+ */
+declare class TableState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+interface CtaBaseProps {
+    /**
+     * A unique identifier for the CTA.
+     * @external
+     */
+    id: string;
+    /**
+     * A callback that runs each time the button is clicked.
+     * @external
+     */
+    onClick?: () => void;
+    /**
+     * Button label.
+     * @external
+     */
+    label?: string;
+    /**
+     * An optional Icon prefix.
+     * @external
+     */
+    prefixIcon?: IconElement;
+}
+
+interface SectionBadgeConfig {
+    visible: boolean;
+    skin?: 'light' | 'danger' | 'neutralLight';
+}
+/**
+ * A summary item to display in the section header.
+ * @external
+ */
+interface SectionSummaryItem {
+    /**
+     * An icon to display before the text.
+     * @external
+     */
+    icon: ReactNode;
+    /**
+     * A label for the summary item.
+     * @external
+     */
+    text: string;
+    /**
+     * A count value for the summary item.
+     * @external
+     */
+    count: number;
+}
+interface Section {
+    /**
+     * A title for the section.
+     * @external
+     */
+    title: string;
+    /**
+     * A primary call to action for the section.
+     * @overrideType [CtaBaseProps](./?path=/story/common-types--ctabaseprops)
+     * @external
+     */
+    primaryAction?: CtaBaseProps;
+    /**
+     * A badge for the section. Configuration object for showing item count.
+     * @external
+     */
+    badge?: SectionBadgeConfig;
+    /**
+     * Summary items to display in the section header.
+     * Each item can have an icon, text label, and count.
+     * @external
+     */
+    summary?: SectionSummaryItem[];
+    /**
+     * Whether the section is collapsed.
+     * When true, the section items are hidden.
+     * @external
+     */
+    collapsed?: boolean;
+}
+/**
+ * A function that extracts the grouping key from an item.
+ * @external
+ */
+type GroupBy<T> = (item: T) => string;
+/**
+ * A function that renders section configuration given the section ID and all items in the section.
+ * @external
+ */
+type RenderSection<T> = (sectionId: string, items: T[]) => Section;
+/**
+ * Event callbacks for section interactions.
+ * @external
+ */
+interface SectionEvents {
+    /**
+     * Called when a section is toggled (collapsed/expanded).
+     * @param sectionId - The ID of the section being toggled
+     * @param isCollapsed - Whether the section is now collapsed
+     * @external
+     */
+    onToggle?: (sectionId: string, isCollapsed: boolean) => void;
+}
+
+/**
+ * `GridState` — you receive this, you don't construct it.
+ * Produced by `useGridCollection()` (also `useAmbassadorGrid()`, `useVirtualGridStateContext()`). Its own API is in `types/GridState.d.ts`.
+ */
+declare class GridState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+type ActionCellAPI<T, F extends FiltersMap> = ActionCellAPI$1<T, F>;
+/**
+ * `ActionCellProps` — cut here because it has its own bundle.
+ * Full shape: `types/ActionCellProps.d.ts`.
+ */
+interface ActionCellProps {
+    [key: string]: unknown;
+}
+/**
+ * `ActionCell` — cut here because it has its own bundle.
+ * Full shape: `types/ActionCell.d.ts`.
+ */
+type ActionCell<T = any, F = any> = ActionCellProps | ((item: T, index: number, api: ActionCellAPI<T, F>) => ActionCellProps);
+
+interface FieldsSourceProvider {
+    setOnTable(toolbar: ToolbarCollectionState<any, any>): void;
+}
+
+/**
+ * `CollectionTableBaseProps` — cut here because it has its own bundle.
+ * Full shape: `types/CollectionTableBaseProps.d.ts`.
+ */
+interface CollectionTableBaseProps<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+interface TableSectionsProps<T, F extends FiltersMap> extends CollectionTableBaseProps<T, F> {
+    groupBy: GroupBy<T>;
+    renderSection: RenderSection<T>;
+    table: TableState<T, F>;
+    collapsible?: boolean;
+    events?: SectionEvents;
+}
+declare const TableSections: (<T, F extends FiltersMap>({ groupBy, renderSection, table, columns, rowDetails, collapsible, events, ...collectionTableProps }: TableSectionsProps<T, F>) => React__default.JSX.Element) & {
+    displayName: string;
+};
+type TableSectionsProp<T> = {
+    TableSections: typeof TableSections;
+    groupBy: GroupBy<T>;
+    renderSection: RenderSection<T>;
+    collapsible?: boolean;
+    events?: SectionEvents;
+};
+
+interface TableProps<T, F extends FiltersMap = OptionalFiltersMap> extends CollectionTableBaseProps<T, F> {
+    rowHeight?: number | ((item: T, index: number) => number);
+    estimatedRowHeight?: number;
+    /**
+     * A state instance created using the [`useTableCollection()`](./?path=/story/base-components-collections-table-usetablecollection--usetablecollection) hook, responsible for managing the data displayed in the table.
+     * @overrideType [TableState](./?path=/story/base-components-collections-table-tablestate--tablestate)
+     * @external
+     */
+    state: CollectionState<T, F> | TableState<T, F>;
+    isVirtual?: boolean;
+    /**
+     * Configuration for rendering table sections. When provided, the table will render with section headers
+     * that group related rows together
+     * @external
+     */
+    sections?: TableSectionsProp<T>;
+}
+
+interface TableVirtualProps<T, F extends FiltersMap> extends CollectionTableBaseProps<T, F> {
+    rowHeight?: number | ((item: T, index: number) => number);
+    estimatedRowHeight?: number;
+    state: CollectionState<T, F> | TableState<T, F>;
+    sections?: TableSectionsProp<T>;
+}
+
+interface GridItemBaseProps<T, F extends FiltersMap> {
+    /**
+     * A `CardGalleryItem` preset to preserve the same card size regardless of the provided data.
+     * Subtitle will be shown only in 'full' or 'footer' presets.
+     *
+     * @example
+     * full — renders title + subtitle
+     * title — renders only title
+     * empty — renders a card without a footer
+     *
+     * @default title
+     * @external
+     */
+    preset?: Preset;
+    /**
+     * A function that renders a custom item of the grid.
+     * Returns a WSR [`CardGalleryItemProps`](https://www.docs.wixdesignsystem.com/?path=/story/components-lists--cardgalleryitem) object.
+     * @external
+     */
+    renderItem?: (item: T, index: number) => Partial<SupportedCardGalleryItemProps>;
+    /**
+     * Adds an action on the grid item. For example, a delete button to delete an item.
+     * Accepts an [`ActionCellProps`](https://www.docs.wixdesignsystem.com/?path=/story/components-lists-table--tableactioncell) object, or a function that returns an `ActionCellProps` object.
+     * @external
+     */
+    actionCell?: ActionCell<T, F>;
+    /**
+     * A function that renders [`<AddItem>`](https://www.docs.wixdesignsystem.com/?path=/story/components-actions--additem&activeTab=Description&globals=backgrounds.value:!hex(F8F8F8);backgrounds.grid:false) after all cards in a gallery.
+     * <br><br>
+     * The `<AddItem>` card will not show when filters are applied unless the filter is defined with the persistent option.
+     * @external
+     */
+    renderAddItem?: () => ReactElement<AddItemProps>;
+    /**
+     * Sets placement of a background image.
+     * @external
+     */
+    imagePlacement?: CardGalleryItemProps['imagePlacement'];
+}
+
+interface GridSortableContextProps<T, F extends FiltersMap> {
+    state: GridBaseState<T, F>;
+    children?: ReactNode;
+    onSubmit?: DragAndDropSubmit<T, F>;
+}
+
+declare function setStateObject<T, F extends FiltersMap>({ state, modalsContainerRef, }: {
+    state: GridBaseState<T, F>;
+    modalsContainerRef: {
+        current: HTMLElement | null | undefined;
+    };
+}): void;
+declare const GridDragAndDrop: {
+    SortableContext: (<T, F extends FiltersMap>(props: GridSortableContextProps<T, F>) => React.JSX.Element) & {
+        displayName: string;
+    };
+    DraggableCard: (<T, F extends FiltersMap>(props: DraggableCardProps<T, F>) => React.JSX.Element) & {
+        displayName: string;
+    };
+    DraggableCardOverlay: (<T, F extends FiltersMap>(props: DraggableCardOverlayProps<T, F>) => React.ReactPortal) & {
+        displayName: string;
+    };
+    setStateObject: typeof setStateObject;
+};
+
+interface GridContentBaseProps<T, F extends FiltersMap> {
+    preset?: Preset;
+    imagePlacement?: 'side' | 'top';
+    renderItem?: (item: T, index: number) => Partial<SupportedCardGalleryItemProps>;
+    actionCell?: ActionCell<T, F>;
+    renderAddItem?: () => ReactElement<AddItemProps>;
+    dragAndDrop?: typeof GridDragAndDrop;
+    dragAndDropSubmit?: DragAndDropSubmit<T, F>;
+    dragAndDropCancel?: DragAndDropCancel<T, F>;
+    layoutType?: LayoutType;
+}
+
+interface GridSectionsContentProps<T, F extends FiltersMap> extends GridContentBaseProps<T, F> {
+    state: GridState<T, F>;
+    groupBy: GroupBy<T>;
+    renderSection?: RenderSection<T>;
+}
+declare function _GridSectionsContent<T, F extends FiltersMap>(props: GridSectionsContentProps<T, F>): React__default.JSX.Element;
+declare const GridSectionsContent: typeof _GridSectionsContent & {
+    displayName: string;
+};
+
+interface GridBaseProps<T, F extends FiltersMap> extends Omit<ToolbarCollectionBaseProps<T, F>, 'sticky' | 'maxSelection'>, GridItemBaseProps<T, F> {
+    dataHook?: string;
+    /**
+     * Adds functionality to allow visitors to reorder items manually.
+     * For more information, see the [Drag and Drop Overview](./?path=/story/features-sort-drag-and-drop--overview).
+     * @overrideType [GridDragAndDrop](./?path=/story/features-sort-drag-and-drop--griddraganddrop)
+     * @external
+     */
+    dragAndDrop?: typeof GridDragAndDrop;
+    /**
+     * Grid state instance created using [`useGridCollection`](./?path=/story/base-components-collections-grid-usegridcollection--usegridcollection).
+     * @overrideType [GridState](./?path=/story/base-components-collections-grid-gridstate--gridstate)
+     * @external
+     */
+    state: GridState<T, F>;
+    /**
+     * A toolbar for performing bulk actions on multiple items.<br> <br>
+     * Supported parameters: <br>
+     * -`selectedValues`: [array] Items that are checked in the selection column. <br>
+     * -`uncheckedValues`: [array] Items that are unchecked in the selection column. <br>
+     * -`isSelectAll`: [bool] Whether **Select All** is checked. <br>
+     * -`openModal`: [func] Opens a modal that contains the component from `bulkActionModal` render prop. <br>
+     * -`clearSelection`: [func] Clears all selections. Call this after the action on the selected items finishes. <br>
+     * -`total`: [number] Total number of items in the server. <br>
+     * -`openConfirmModal`: [func] Opens a `<MessageModalLayout>` to confirm an action is about to be applied to the selected items. <br>
+     * -`query`: [object] Current paging, sorting, and filtering. Often used together with bulk actions, such as `updateAll`. <br>
+     * @external
+     */
+    bulkActionToolbar?: BulkActionToolbarRenderProp<T, F>;
+    /**
+     * Creates [grid sections](./?path=/story/features-display-grid-sections--grid-sections) that group data based on the values of a specific field.
+     * @external
+     * @overrideType [SectionsProp](./?path=/story/common-types--sectionsprop)
+     */
+    sections?: {
+        GridSections: typeof GridSectionsContent;
+        groupBy: GroupBy<T>;
+        renderSection?: RenderSection<T>;
+    };
+    layoutType?: LayoutType;
+}
+type GridBasePropsWithoutPreset<T, F extends FiltersMap = OptionalFiltersMap> = Omit<GridBaseProps<T, F>, 'preset' | 'renderItem'>;
+type GridProps<T, F extends FiltersMap = OptionalFiltersMap> = GridPresetProps<T, GridBasePropsWithoutPreset<T, F>>;
+
+interface EditableTableProps<T, F extends FiltersMap = OptionalFiltersMap> extends Omit<TableVirtualProps<T, F>, 'columns' | 'state' | 'onRowClick' | 'forceResize' | 'horizontalScroll' | 'showSelection' | 'showRowNumbers' | 'showAddFieldButton' | 'rowStatus'> {
+    /** EditableTableState instance, created via useEditableTableCollection */
+    state: EditableTableState<T, F>;
+    /** Column definitions with cell types. When a `fieldsSource` is wired, its
+     *  columns are added by the state, so pass `[]` for source-only tables. */
+    columns: EditableColumn<T>[];
+    /** A fields source (e.g. `dataExtensionTableSource(...)`) whose fields become
+     *  columns and whose field management wires into the table. Schema sources
+     *  attach via the `@wix/patterns/schema` collection hooks instead. */
+    fieldsSource?: FieldsSourceProvider;
+    /** When true, hides the built-in header actions popover for all columns. */
+    hideHeaderActions?: boolean;
+    /** data-hook for testkit selectors */
+    dataHook?: string;
+}
+
+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;
+}
+/**
+ * `CellType` — cut here because it has its own bundle.
+ * Full shape: `types/CellType.d.ts`.
+ */
+interface CellType {
+    [key: string]: unknown;
+}
+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;
+
+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';
+};
+
+/**
+ * `ToolbarCollectionState` — you receive this, you don't construct it.
+ * Produced by `useToolbarCollectionContext()` (also `useTableCollectionSyncProps()`, `useKanbanCollectionSyncProps()`, `useToolbarCollectionSyncProps()`).
+ */
+declare class ToolbarCollectionState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+/**
+ * `EditableTableState` — you receive this, you don't construct it.
+ * Produced by `useEditableTableCollection()`.
+ */
+declare class EditableTableState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+/**
+ * `LayoutSwitchState` — you receive this, you don't construct it.
+ * Produced by `useLayoutSwitchCollection()`.
+ */
+declare class LayoutSwitchState<T = any, F = any> {
+    [key: string]: unknown;
+}
+
+/** Table props for a source-driven table: the source supplies the field
+ *  columns and attaches its own fields management. `columns` is optional
+ *  (extras only); the fields-management props are always on and not
+ *  configurable, and there is no `fieldsSource`/`dataExtension`. */
+type SchemaTableProps<T, F extends FiltersMap> = Omit<TableProps<T, F>, 'state' | 'columns' | 'fieldsSource' | 'dataExtension' | 'showFieldTypeIcons' | 'showAddFieldButton'> & {
+    state: TableState<T, F>;
+    /** Columns beyond the source's fields (e.g. an action column). Default: none. */
+    columns?: TableColumn<T>[];
+};
+
+/** EditableTable props for a source-driven table: the source supplies the field
+ *  columns and attaches its own fields management. `columns` is optional
+ *  (extras only); field-type icons are always on, and there is no
+ *  `fieldsSource`/`dataExtension`. */
+type SchemaEditableTableProps<T, F extends FiltersMap> = Omit<EditableTableProps<T, F>, 'state' | 'columns' | 'fieldsSource' | 'dataExtension' | 'showFieldTypeIcons'> & {
+    state: EditableTableState<T, F>;
+    /** Columns beyond the source's fields. Default: none. */
+    columns?: EditableColumn<T>[];
+};
+
+/** A grid driven by a source: the card title comes from the source's display
+ *  value, so `renderItem` sets only the rest of the card (subtitle, image,
+ *  badge, …). Field-type icons are always on, and not configurable. */
+type SchemaGridProps<T, F extends FiltersMap> = Omit<GridProps<T, F>, 'showFieldTypeIcons' | 'renderItem'> & {
+    renderItem?: (item: T, index: number) => Omit<Partial<SupportedCardGalleryItemProps>, 'title'>;
+};
+
+type LayoutBag<P> = Omit<P, 'state' | 'tableGridSwitchButton'>;
+/** LayoutSwitch props for a source-driven page: the per-layout state is derived
+ *  from the single `state`, and each layout's props are the source-adjusted
+ *  versions (columns optional, no fieldsSource, field-type icons on). */
+interface SchemaLayoutSwitchProps<T, F extends FiltersMap> {
+    state: LayoutSwitchState<T, F>;
+    importButton?: ReactElement;
+    tableProps?: LayoutBag<SchemaTableProps<T, F>>;
+    gridProps?: LayoutBag<SchemaGridProps<T, F>>;
+    spreadsheetProps?: LayoutBag<SchemaEditableTableProps<T, F>>;
+}
+declare function _LayoutSwitch<T, F extends FiltersMap>({ state, importButton, tableProps, gridProps, spreadsheetProps, }: SchemaLayoutSwitchProps<T, F>): React__default.JSX.Element;
+declare const LayoutSwitch: typeof _LayoutSwitch;
+
+export { LayoutSwitch };
+export type { SchemaLayoutSwitchProps };