@wix/patterns 1.457.0 → 1.458.0

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

@@ -0,0 +1,460 @@
+import { useTranslation, Trans } from '@wix/fe-essentials/react';
+import { History as History$1 } from 'history';
+import * as lodash from 'lodash';
+import { IObservableArray } from 'mobx';
+import { EventEmitter } from 'events';
+import { Essentials, EssentialsOptions } from '@wix/fe-essentials/core';
+import { ReportProps, LogParams } from '@wix/fe-essentials/bi';
+import { errorHandler } from '@wix/essentials';
+import { QueryCache } from 'react-query/core';
+import { ReactElement, FunctionComponent } from 'react';
+import { HttpRequestOrHttpRequestFactory, RequestOverrides } from '@wix/fe-essentials/http-client';
+import { SDK } from '@wix/dashboard';
+import { Messages } from '@wix/fe-essentials/i18n';
+
+type Arguments<T> = [T] extends [(...args: infer U) => any] ? U : [T] extends [void] ? [] : [T];
+interface TypedEventEmitter<Events> {
+    addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    on<E extends keyof Events>(event: E, listener: Events[E]): this;
+    once<E extends keyof Events>(event: E, listener: Events[E]): this;
+    off<E extends keyof Events>(event: E, listener: Events[E]): this;
+    removeAllListeners<E extends keyof Events>(event?: E): this;
+    removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
+    emit<E extends keyof Events>(event: E, ...args: Arguments<Events[E]>): boolean;
+    listeners<E extends keyof Events>(event: E): Events[E][];
+}
+type TypedEmitter<Events> = Omit<EventEmitter, keyof TypedEventEmitter<Events>> & TypedEventEmitter<Events>;
+
+interface Environment {
+    readonly language: string;
+    readonly artifactId: string;
+    readonly componentId?: string;
+    readonly componentName?: string;
+    readonly uiLibVersion?: string;
+    readonly providerType?: 'bm' | 'giza' | 'essentials';
+    readonly msid?: string;
+}
+interface EnvironmentBi {
+    readonly artifactId?: string;
+    readonly componentId?: string;
+}
+
+type MonitorLogger = Pick<Essentials['fedopsLogger'], 'interactionStarted' | 'interactionEnded' | 'reportErrorThrownOncePerFlow'>;
+
+interface ErrorMonitor {
+    captureException(exception: unknown): string;
+}
+
+interface OnlineManager {
+    isOnline: () => boolean;
+    subscribe: (listener?: () => unknown) => () => void;
+}
+
+type History = History$1;
+
+interface PartialWindow {
+    readonly location: Pick<Location, 'href'>;
+    readonly matchMedia: Window['matchMedia'];
+    readonly download: (uri: string, saveAs?: string) => void;
+    readonly close: () => void;
+}
+
+type PartialLodash = Pick<typeof lodash, 'debounce' | 'throttle'>;
+
+interface FocusManager {
+    isFocused: () => boolean;
+    subscribe: (listener?: () => unknown) => () => void;
+}
+
+interface Experiments {
+    enabled(key: string): boolean;
+    ready(): Promise<any>;
+    get(key: string): any;
+}
+
+interface ModalLayoutProps {
+    title?: string;
+    content?: string;
+    onConfirm?: () => void;
+    onResume?: () => void;
+    onClose?: () => void;
+    onAfterClose?: () => void;
+    primaryButtonText?: string;
+    secondaryButtonText?: string;
+}
+
+/**
+ * `TaskState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class TaskState<T> {
+}
+
+/**
+ * `TransitionState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class TransitionState<T> {
+}
+
+/**
+ * `OptimisticPatch` — you receive this, you don't construct it.
+ * Produced by `prepareItemsToMergeIntoPage()`.
+ */
+declare class OptimisticPatch<T> {
+}
+
+/**
+ * `CollectionState` — you receive this, you don't construct it.
+ * Produced by `useFilterCollection()` (also `useStaticListFilterCollection()`, `useCollection()`, `createCollection()`).
+ */
+declare class CollectionState<T, F> {
+}
+
+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;
+};
+type RemoveToast = () => void;
+type ShowToast = (toastConfig: ToastConfig) => {
+    remove: RemoveToast;
+};
+
+/**
+ * `ConditionalModalState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class ConditionalModalState<T> {
+}
+
+type PatternsLayoutType = 'panel' | 'page';
+
+type WixPatternsContainerEvents = TypedEmitter<{
+    navigation: () => ModalLayoutProps | null | undefined;
+}>;
+interface WixPatternsContainerParams {
+    readonly initialProps?: WixPatternsInitialProps;
+    readonly createEssentials: WixPatternsEssentials['createEssentials'];
+    readonly biLogger?: WixPatternsEssentials['biLogger'];
+    readonly messagesEnImport?: () => Promise<{}>;
+    readonly fetchTranslations?: (p: {
+        readonly errorMonitor: ErrorMonitor;
+    }) => (locale: string) => Promise<{}>;
+    readonly createComponentSettings?: WixPatternsEssentials['createComponentSettings'];
+    readonly errorMonitor: ErrorMonitor;
+    readonly httpClient: WixPatternsEssentials['httpClient'];
+    readonly onlineManager: OnlineManager;
+    readonly focusManager: FocusManager;
+    readonly contextType?: ContextType;
+    readonly history: History;
+    readonly window: PartialWindow;
+    readonly useTranslation: typeof useTranslation;
+    readonly Trans: typeof Trans;
+    readonly useExperiments: WixPatternsEssentials['useExperiments'];
+    readonly experiments: WixPatternsEssentials['experiments'];
+    readonly environment: WixPatternsEssentials['environment'];
+    readonly environmentBI: WixPatternsEssentials['environmentBI'];
+    readonly errorHandler?: WixPatternsEssentials['errorHandler'];
+    readonly user: WixPatternsEssentials['user'];
+    readonly showToast?: ShowToast;
+    readonly usePageLocation?: WixPatternsEssentials['usePageLocation'];
+    readonly navigateTo?: WixPatternsEssentials['navigateTo'];
+    readonly onNavigation?: OnNavigation;
+    readonly getHostContainer?: GetHostContainer;
+    readonly queryCache: QueryCache;
+    readonly patchesCache: Map<string, IObservableArray<OptimisticPatch<any>>>;
+    readonly onSidePanelOpen?: OnSidePanelOpen;
+    readonly closeSidePanel?: CloseSidePanel;
+    readonly lodash: PartialLodash;
+    readonly events?: WixPatternsContainerEvents;
+    readonly sidePanel?: TransitionState<string>;
+    readonly onNavigationModal?: ConditionalModalState<ModalLayoutProps>;
+    readonly sidePanelComponents?: Map<string, ReactElement>;
+    readonly appendModalsToBody?: boolean;
+    readonly layoutType?: PatternsLayoutType;
+    readonly useRelativeSidePanel?: boolean;
+    readonly onBeforeUnload?: WixPatternsEssentials['onBeforeUnload'];
+    readonly onLayerStateChange?: WixPatternsEssentials['onLayerStateChange'];
+    readonly openMediaManager?: WixPatternsEssentials['openMediaManager'];
+}
+/**
+ * `WixPatternsContainer` — you receive this, you don't construct it.
+ * Produced by `useWixPatternsContainer()` (also `buildWixPatternsContainer()`, `useCustomFieldsViewWidget()`).
+ */
+declare class WixPatternsContainer {
+}
+
+interface HttpClient {
+    request<T>(req: HttpRequestOrHttpRequestFactory<T>, overrides?: RequestOverrides): Promise<{
+        data: T;
+        status: number;
+        statusText: string;
+        headers: Record<string, string | undefined>;
+    }>;
+}
+
+/**
+ * `Filter` — cut here because it has its own bundle.
+ * Look `Filter` up in the bundle index for its full shape.
+ */
+interface Filter<T> {
+}
+type FiltersMap = {
+    [key: string]: Filter<any> | undefined;
+};
+
+interface DataCapsule {
+    setItem<T>(key: string, value: T, options?: Record<string, any>): Promise<void>;
+    removeItem(key: string, options?: Record<string, any>): Promise<void>;
+    getItem<T>(key: string): Promise<T>;
+}
+
+type OnSidePanelOpen = (listener: () => void) => {
+    remove(): void;
+};
+type CloseSidePanel = () => unknown;
+interface BiLogger {
+    report(reportProps: ReportProps): Promise<any>;
+}
+interface CairoBILoggerFactory {
+    updateDefaults(params: LogParams): this;
+    logger(): BiLogger;
+}
+type PageLocation = {
+    pageId: string;
+    pathname: string;
+    search?: string;
+    hash?: string;
+};
+type OnNavigationPause = () => {
+    resume(): void;
+};
+type OnNavigationCallback = (pause: OnNavigationPause) => void;
+type OnNavigation = (callback: OnNavigationCallback) => {
+    remove(): void;
+};
+type NavigateToObject = {
+    pageId: string;
+    relativeUrl?: string;
+    appState?: string;
+    referrer?: string;
+    /**
+     * How the target page should be presented. `overlay` opens it as a layer on
+     * top of the current page (e.g. the dashboard overlay). Hosts that don't
+     * support layered navigation ignore this and navigate in place.
+     */
+    displayMode?: 'auto' | 'main' | 'overlay';
+    /** Whether the navigation should push a new history entry or replace the current one. */
+    history?: 'push' | 'replace';
+};
+type NavigateToFunc = (to: NavigateToObject) => void;
+type BeforeUnloadResponse = {
+    remove: () => void;
+};
+type OnBeforeUnload = (callback: (event: Event) => void) => BeforeUnloadResponse;
+/** The layered-navigation state of the current page relative to the host. */
+type LayerState = 'background' | 'foreground';
+/**
+ * Subscribe to layer-state transitions of the current page. Fires `background`
+ * when another layer (e.g. an overlay) is opened on top of the current page and
+ * `foreground` when it returns to the top. Hosts without layered navigation
+ * leave this undefined.
+ */
+type OnLayerStateChange = (callback: (newState: LayerState) => void) => {
+    remove: () => void;
+};
+interface HostContainerExtension {
+    appId?: string;
+    componentId: string;
+    title?: string;
+    menuItem?: {
+        IconComponent?: FunctionComponent;
+        IconSmallComponent?: FunctionComponent;
+        structuredAction: (params?: Record<string, any>) => unknown;
+    };
+    Component?: React.ComponentType;
+    Extension?: React.ComponentType;
+}
+type GetExtensions = () => HostContainerExtension[] | Promise<HostContainerExtension[]>;
+interface HostContainer {
+    getExtensions: GetExtensions;
+}
+type GetHostContainer = (hostContainerId: string) => HostContainer;
+type OpenMediaManager = SDK['openMediaManager'];
+type CreateEssentials = (options: EssentialsOptions) => {
+    i18n: Essentials['i18n'];
+    dataCapsule: Essentials['dataCapsule'];
+    biLoggerFactory?: () => CairoBILoggerFactory;
+    errorMonitor: ErrorMonitor;
+    fedopsLogger?: MonitorLogger;
+    experiments?: Experiments;
+};
+type CreateComponentSettings = (container: {
+    httpClient: HttpClient;
+    queryCache: QueryCache;
+    environment: Environment;
+    createEssentials: CreateEssentials;
+}) => (options: {
+    namespace: string;
+}) => DataCapsule;
+interface PatternsErrorHandler {
+    withErrorHandler: errorHandler.ErrorHandler['withErrorHandler'];
+    getResolvedError?: errorHandler.ErrorHandler['getResolvedError'];
+    showError?: errorHandler.ErrorHandler['showError'];
+    reportRetryAttempt?: errorHandler.ErrorHandler['reportRetryAttempt'];
+}
+interface WixPatternsEssentials {
+    httpClient: HttpClient;
+    /** A `ErrorMonitor` instance `@wix/fe-essentials/error-monitor` */
+    errorMonitor: ErrorMonitor;
+    /** A `Experiments` instance `@wix/fe-essentials/experiments` */
+    experiments: Experiments;
+    errorHandler?: PatternsErrorHandler;
+    biLogger?: BiLogger | null;
+    /**
+     * A function that returns the shape `{ i18n }` - should be compatible with `{createEssentials} from '@wix/fe-essentials'` */
+    createEssentials: CreateEssentials;
+    /** A `DataCapsule` to store component-level settings such as `Views` */
+    createComponentSettings?: CreateComponentSettings;
+    /** The user's environment
+     * - `language` - preferable language for the user
+     * - `artifactId` - App level identifier, usually the artifact ID
+     * - `componentId` - Component/page level identifier (Optional)
+     * - `componentName` - Readable component/page name (Optional)
+     */
+    environment: Pick<Environment, 'language'> & Partial<Omit<Environment, 'language'>> & {
+        uiLibVersion?: string;
+        msid?: string;
+    };
+    environmentBI: EnvironmentBi;
+    /** `useTranslation` hook from `react-i18next` or `@wix/fe-essentials/react` */
+    useTranslation: typeof useTranslation;
+    /** `Trans` component from `react-i18next` or `@wix/fe-essentials/react */
+    Trans: typeof Trans;
+    user: {
+        id?: string;
+        permissions: string[];
+    };
+    /** `useExperiments` hook from `@wix/yoshi-flow-bm` or `@wix/fe-essentials/react` */
+    useExperiments: () => {
+        ready: boolean;
+        experiments: {
+            enabled: (key: string) => boolean;
+        };
+    };
+    usePageLocation?: () => PageLocation | undefined;
+    /** A function that shows a global toast. For BM usage, it should be `showToast` from `business-manager-api` */
+    showToast?: ShowToast;
+    /** A function to perform a navigation to a given pageId */
+    navigateTo?: NavigateToFunc;
+    useAppLoaded?: () => void;
+    onSidePanelOpen?: OnSidePanelOpen;
+    closeSidePanel?: CloseSidePanel;
+    /** Custom [history](https://github.com/remix-run/history/tree/v5.3.0/packages/history) instance to sync custom consumer navigations with Cairo navigations */
+    history?: History$1;
+    /** An optional query cache instance for controlling the cache from other modules */
+    queryCache?: QueryCache;
+    /** A function that interrupts a navigation to another app inside wix platforms */
+    onNavigation?: OnNavigation;
+    getHostContainer?: GetHostContainer;
+    onlineManager?: OnlineManager;
+    /**
+     * Deals with dirty state by setting up a listener that triggers a confirmation dialog when a user attempts to leave a page. The event listener is removed upon component unmount.
+     * @param callback - called on navigation with an event object. Use event.preventDefault() within the callback to display the dialog.
+     * @returns { remove: () => void } - object that includes a remove method. You can use this method to remove the listener whenever necessary.
+     */
+    onBeforeUnload?: OnBeforeUnload;
+    /**
+     * Subscribe to layer-state transitions of the current page (e.g. to refresh
+     * data when an overlay opened on top of it is closed). Provided by hosts that
+     * support layered navigation; left undefined otherwise.
+     */
+    onLayerStateChange?: OnLayerStateChange;
+    /** Opens the Wix Media Manager. Provided by the Dashboard SDK via context. */
+    openMediaManager?: OpenMediaManager;
+}
+type ContextType = 'ACCOUNT' | 'SITE';
+
+interface WixPatternsInitialProps {
+    messages?: Messages;
+}
+
+type ViewType = 'table' | 'grid' | 'spreadsheet';
+/**
+ * `ViewTypeState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class ViewTypeState {
+}
+
+interface ICollectionComponentState {
+    toolbar: ToolbarCollectionState<any, any>;
+}
+
+/**
+ * `GridState` — you receive this, you don't construct it.
+ * Produced by `useGridCollection()` (also `useAmbassadorGrid()`, `useVirtualGridStateContext()`). Look `GridState` up in the bundle index for its own API.
+ */
+declare class GridState<T, F> {
+}
+
+/**
+ * `ToolbarCollectionState` — you receive this, you don't construct it.
+ * Produced by `useToolbarCollectionContext()` (also `useTableCollectionSyncProps()`, `useKanbanCollectionSyncProps()`, `useToolbarCollectionSyncProps()`).
+ */
+declare class ToolbarCollectionState<T, F> {
+}
+
+/**
+ * `TableState` — you receive this, you don't construct it.
+ * Produced by `useTableCollection()` (also `useAmbassadorTable()`, `useTableContext()`). Look `TableState` up in the bundle index for its own API.
+ */
+declare class TableState<T, F> {
+}
+
+interface TableGridSwitchStateParams<T, F extends FiltersMap> {
+    readonly collection: CollectionState<T, F>;
+    readonly container: WixPatternsContainer;
+    readonly containerOverrides: Partial<WixPatternsContainerParams>;
+}
+declare class TableGridSwitchState<T, F extends FiltersMap> implements ICollectionComponentState {
+    collection: CollectionState<T, F>;
+    readonly container: WixPatternsContainer;
+    readonly containerOverrides: Partial<WixPatternsContainerParams>;
+    readonly initTask: TaskState<unknown>;
+    readonly gridState: GridState<T, F>;
+    readonly tableState: TableState<T, F>;
+    readonly viewTypeState: ViewTypeState;
+    constructor(params: TableGridSwitchStateParams<T, F>);
+    get viewType(): ViewType;
+    set viewType(viewType: ViewType);
+    get toolbar(): ToolbarCollectionState<T, F>;
+    init(): void;
+}
+
+export { TableGridSwitchState };
+export type { TableGridSwitchStateParams };

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

@@ -0,0 +1,206 @@
+/**
+ * `TaskState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class TaskState<T> {
+}
+
+/**
+ * `CollectionState` — you receive this, you don't construct it.
+ * Produced by `useFilterCollection()` (also `useStaticListFilterCollection()`, `useCollection()`, `createCollection()`).
+ */
+declare class CollectionState<T, F> {
+}
+
+/**
+ * `WixPatternsContainer` — you receive this, you don't construct it.
+ * Produced by `useWixPatternsContainer()` (also `buildWixPatternsContainer()`, `useCustomFieldsViewWidget()`).
+ */
+declare class WixPatternsContainer {
+}
+
+/**
+ * `Filter` — cut here because it has its own bundle.
+ * Look `Filter` up in the bundle index for its full shape.
+ */
+interface Filter<T> {
+}
+type FiltersMap = {
+    [key: string]: Filter<any> | undefined;
+};
+
+type SortOrder = 'asc' | 'desc';
+
+interface KeyedItem<T> {
+    item: T;
+    key: string;
+    id: string;
+    pageIndex: number;
+    indexWithinPage: number;
+    index: number;
+}
+
+type QueryStatusValue = 'idle' | 'loading' | 'error' | 'success';
+interface QueryStatusBase {
+    status: QueryStatusValue;
+}
+interface QueryStatusError extends QueryStatusBase {
+    isError: true;
+    isIdle: false;
+    isLoading: false;
+    isSuccess: false;
+    status: 'error';
+}
+
+interface DataResultKeyed<T> {
+    items: T[];
+    total?: number | null;
+    available: number | null;
+    cursor: string | null;
+    hasNext?: boolean | null;
+}
+
+interface QueryResultStatusBase<T, E> {
+    data?: T;
+    error?: E | null;
+    isFetching?: boolean;
+}
+interface QueryResultStatusError<T, E> extends QueryResultStatusBase<T, E>, QueryStatusError {
+    error: E;
+}
+
+/**
+ * `Column` — cut here because it has its own bundle.
+ * Look `Column` up in the bundle index for its full shape.
+ */
+interface Column {
+}
+
+/**
+ * `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, F> {
+}
+
+type ToolbarFeatureInitializer = (state: ToolbarCollectionState<any, any>) => {
+    init: () => void | (() => void);
+    initTask: TaskState<unknown> | null;
+};
+
+interface ToolbarCollectionStateParamsInitParams {
+    featuresInitializers: (ToolbarFeatureInitializer | undefined)[];
+    hasMultiLevelSorting?: boolean;
+    skipFilterListeners?: boolean;
+}
+/**
+ * `ToolbarCollectionState` — you receive this, you don't construct it.
+ * Produced by `useToolbarCollectionContext()` (also `useTableCollectionSyncProps()`, `useKanbanCollectionSyncProps()`, `useToolbarCollectionSyncProps()`).
+ */
+declare class ToolbarCollectionState<T, F> {
+}
+
+interface ICollectionComponentState {
+    toolbar: ToolbarCollectionState<any, any>;
+}
+
+/**
+ * `TableVirtualState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class TableVirtualState<K, T, F> {
+}
+
+/**
+ * `LoadingRowState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class LoadingRowState {
+}
+
+interface TableStateParams<T, F extends FiltersMap> {
+    readonly collection: CollectionState<T, F>;
+    readonly container: WixPatternsContainer;
+    readonly toolbar?: ToolbarCollectionState<T, F>;
+}
+interface TableDragAndDropStateBase<T, F extends FiltersMap> {
+    getStickyColumnsCount: (params: {
+        stickyColumns: number;
+    }) => number;
+    init: () => void;
+    dnd: DragAndDropState<T, F>;
+}
+interface TableStateInitParams extends ToolbarCollectionStateParamsInitParams {
+    hasMultiLevelSorting?: boolean;
+}
+interface TableStatePublicAPI<T, F extends FiltersMap> {
+    /**
+     * Underlying [CollectionState](./?path=/story/common-state--collectionstate) instance
+     * @external
+     */
+    readonly collection: CollectionState<T, F>;
+    /**
+     * Underlying [ToolbarCollectionState](./?path=/story/common-state--toolbarcollectionstate) instance
+     * @external
+     */
+    readonly toolbar: ToolbarCollectionState<T, F>;
+    /**
+     * Reset active filters & sorting and adds new items to the collection.
+     * @external
+     * @param items - new items to add to the collection
+     */
+    onAddItemActionComplete(items: T[]): void;
+    /**
+     * Visible columns as selected via [CustomColumns](./?path=/story/features-display--customcolumns)
+     * @external
+     */
+    readonly visibleColumns: {
+        id: string;
+    }[];
+    /**
+     * Sorts the collection by a specified column and optional sort direction.
+     * @external
+     */
+    sort: (columnId: string, params: {
+        forceDirection?: SortOrder;
+    }) => void;
+}
+declare class TableState<T, F extends FiltersMap> implements ICollectionComponentState, TableStatePublicAPI<T, F> {
+    readonly toolbar: ToolbarCollectionState<T, F>;
+    readonly virtual: TableVirtualState<KeyedItem<T>, T, F>;
+    readonly loadingRowState: LoadingRowState;
+    tableDragAndDropState: TableDragAndDropStateBase<T, F> | null;
+    /** The sticky table header element (column headers row) */
+    headerElement: HTMLElement | null;
+    constructor(params: TableStateParams<T, F>);
+    get visibleColumns(): Column[];
+    get table(): ToolbarCollectionState<T, F>;
+    get collection(): CollectionState<T, F>;
+    get tableState(): this;
+    get itemsContentWidth(): number;
+    get itemsToRenderCount(): number;
+    init(params: TableStateInitParams): () => void;
+    get keyedItems(): KeyedItem<T>[];
+    getStickyColumnsCount(params: {
+        stickyColumns?: number;
+        horizontalScroll?: boolean;
+        showSelection?: boolean;
+        stickySelectionColumn?: boolean;
+    }): number | undefined;
+    get showEmptyState(): boolean;
+    get hasAvailableItems(): boolean;
+    get resultOriginQuerySearch(): string | undefined;
+    get hasNonPersistentActiveFilters(): boolean;
+    get showErrorState(): boolean;
+    get errorStatus(): QueryResultStatusError<DataResultKeyed<unknown>, F> | undefined;
+    get showLoadingState(): boolean;
+    get initTask(): TaskState<unknown>;
+    retryErrorState: () => void;
+    onAddItemActionComplete: (items: T[]) => Promise<void>;
+    sort: (columnId: string, { forceDirection }?: {
+        forceDirection?: SortOrder;
+    }) => void;
+}
+
+export { TableState };
+export type { TableStateInitParams, TableStateParams, TableStatePublicAPI };