@wix/patterns 1.457.0 → 1.458.0

package/dist/dts-bundle/hooks/useFilterCollection.d.ts

@@ -0,0 +1,41 @@
+import { CollectionConfig, OffsetFetchDataFn, CursorFetchDataFn } from '@wix/bex-core/react';
+
+/**
+ * `CollectionState` — you receive this, you don't construct it.
+ * Produced by `useFilterCollection()` (also `useStaticListFilterCollection()`, `useCollection()`, `createCollection()`).
+ */
+declare class CollectionState<T, F> {
+}
+
+/**
+ * `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 OptionalFiltersMap = {
+    [key: string]: undefined;
+};
+
+type FiltersConfig<F extends FiltersMap> = F extends OptionalFiltersMap ? {
+    filters?: {};
+} : {
+    filters: F;
+};
+type PaginationModeConfig<T, F extends FiltersMap> = {
+    paginationMode?: 'offset';
+    fetchData: OffsetFetchDataFn<T, F>;
+} | {
+    paginationMode: 'cursor';
+    fetchData: CursorFetchDataFn<T, F>;
+};
+type FilterCollectionConfig<T, F extends FiltersMap> = Omit<CollectionConfig<T, F>, 'itemKey' | 'itemName' | 'filters' | 'paginationMode' | 'fetchData' | 'fetchErrorMessage'> & FiltersConfig<F> & PaginationModeConfig<T, F>;
+type FilterCollectionFactory = <T, F extends FiltersMap = FiltersMap>(filter: Filter<T[]>, config: FilterCollectionConfig<T, F>) => CollectionState<T, F>;
+declare function useCreateFilterCollection(): FilterCollectionFactory;
+declare function useFilterCollection<T, F extends FiltersMap = OptionalFiltersMap>(filter: Filter<T[]>, config: FilterCollectionConfig<T, F>): CollectionState<T, F>;
+
+export { useCreateFilterCollection, useFilterCollection };
+export type { FilterCollectionConfig, FilterCollectionFactory };

package/dist/dts-bundle/hooks/useForm.d.ts

@@ -0,0 +1,34 @@
+import { FieldValues, UseFormProps, UseFormReturn } from './types';
+
+/**
+ * Custom hook to manage the entire form.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/useform) • [Demo](https://codesandbox.io/s/react-hook-form-get-started-ts-5ksmm) • [Video](https://www.youtube.com/watch?v=RkXv4AXXC_4)
+ *
+ * @param props - form configuration and validation parameters.
+ *
+ * @returns methods - individual functions to manage the form state. {@link UseFormReturn}
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { register, handleSubmit, watch, formState: { errors } } = useForm();
+ *   const onSubmit = data => console.log(data);
+ *
+ *   console.log(watch("example"));
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit(onSubmit)}>
+ *       <input defaultValue="test" {...register("example")} />
+ *       <input {...register("exampleRequired", { required: true })} />
+ *       {errors.exampleRequired && <span>This field is required</span>}
+ *       <button>Submit</button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+declare function useForm<TFieldValues extends FieldValues = FieldValues, TContext = any, TTransformedValues = TFieldValues>(props?: UseFormProps<TFieldValues, TContext, TTransformedValues>): UseFormReturn<TFieldValues, TContext, TTransformedValues>;
+
+export { useForm };

package/dist/dts-bundle/hooks/useGridCollection.d.ts

@@ -0,0 +1,27 @@
+import { CollectionConfigWithConditionals } from '@wix/bex-core/react';
+
+/**
+ * `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 OptionalFiltersMap = {
+    [key: string]: undefined;
+};
+
+/**
+ * `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> {
+}
+
+type GridCollection = <T, F extends FiltersMap = OptionalFiltersMap>(config: CollectionConfigWithConditionals<T, F>) => GridState<T, F>;
+declare const useGridCollection: GridCollection;
+
+export { useGridCollection };
+export type { GridCollection };

package/dist/dts-bundle/hooks/useGridFolders.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `CollectionState` — you receive this, you don't construct it.
+ * Produced by `useFilterCollection()` (also `useStaticListFilterCollection()`, `useCollection()`, `createCollection()`).
+ */
+declare class CollectionState<T, F> {
+}
+
+/**
+ * `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 CollectionFoldersBaseConfig<T1, F1 extends FiltersMap, T2, F2 extends FiltersMap> {
+    /** A [collection state](./?path=/story/common-hooks--usecollection) that fetches items */
+    items: CollectionState<T1, F1>;
+    /** A [collection state](./?path=/story/common-hooks--usecollection) that fetches folders */
+    folders: CollectionState<T2, F2>;
+}
+
+/**
+ * `GridFoldersState` — you receive this, you don't construct it.
+ * Produced by `useGridFolders()`. Look `GridFoldersState` up in the bundle index for its own API.
+ */
+declare class GridFoldersState<T1, F1, T2, F2> {
+}
+
+interface GridFoldersConfig<T1, F1 extends FiltersMap, T2, F2 extends FiltersMap> extends CollectionFoldersBaseConfig<T1, F1, T2, F2> {
+}
+type GridFoldersFactory = <T1, F1 extends FiltersMap, T2, F2 extends FiltersMap>(config: GridFoldersConfig<T1, F1, T2, F2>) => GridFoldersState<T1, F1, T2, F2>;
+declare function useCreateGridFolders(): GridFoldersFactory;
+declare function useGridFolders<T1, F1 extends FiltersMap, T2, F2 extends FiltersMap>(config: GridFoldersConfig<T1, F1, T2, F2>): GridFoldersState<T1, F1, T2, F2>;
+
+export { useCreateGridFolders, useGridFolders };
+export type { GridFoldersConfig, GridFoldersFactory };

package/dist/dts-bundle/hooks/useOptimisticActions.d.ts

@@ -0,0 +1,97 @@
+import { IterateeShorthand } from 'lodash';
+
+/**
+ * `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;
+};
+
+/**
+ * `ComputedQuery` — cut here because it has its own bundle.
+ * Look `ComputedQuery` up in the bundle index for its full shape.
+ */
+interface ComputedQuery<F> {
+}
+
+/**
+ * `QueryState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class QueryState<F> {
+}
+
+type Iterator<T> = (value: T, index: number) => unknown;
+interface Order<T> {
+    fieldName: Iterator<T> | IterateeShorthand<T>;
+    order: 'asc' | 'desc';
+}
+
+/**
+ * `CollectionOptimisticSequenceExecutor` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class CollectionOptimisticSequenceExecutor {
+}
+
+interface CollectionOptimisticActionsBaseParams<T, F extends FiltersMap> {
+    /**
+     * A function that simulates the filtering in the server.
+     * The function should return another function that accepts an item, and return a boolean that indicates whether the item passes the query filters or not.
+     * @param computedQuery - The computed query object.
+     * @external
+     */
+    readonly predicate?: (computedQuery: ComputedQuery<F>) => (item: T) => boolean;
+    /**
+     * A function that simulates the ordering of the items in the server.<br>
+     * The function should return a list of rules in the form of `{fieldName: string; order: 'asc' | 'desc';}` to order the items by
+     * @param computedQuery - The computed query object.
+     * @external
+     */
+    readonly orderBy?: (computedQuery: ComputedQuery<F>) => Order<T>[];
+    /**
+     * A function to retrieve the creation date of an item.
+     * @param item - The item.
+     * @external
+     */
+    readonly createdAt?: (item: T) => Date;
+    /**
+     * Time to wait before batching multiple `updateMany` calls into a single server call.
+     * @default 0
+     * @external
+     */
+    readonly batchWait?: number;
+    /**
+     * Indicates whether to refresh the current page without invalidating the cache.
+     * @external
+     */
+    readonly noInvalidate?: boolean;
+    /**
+     * Adds a namespace to the cache key.
+     * @external
+     */
+    readonly cacheNamespace?: string;
+    readonly sequences?: Map<string, CollectionOptimisticSequenceExecutor>;
+    readonly query?: QueryState<F>;
+}
+/**
+ * `CollectionOptimisticActions` — you receive this, you don't construct it.
+ * Produced by `useOptimisticActions()` (also `createNestedOptimisticActions()`, `useCreateNestedOptimisticActions()`, `useCreateOptimisticActions()`). Look `CollectionOptimisticActions` up in the bundle index for its own API.
+ */
+declare class CollectionOptimisticActions<T, F> {
+}
+
+/**
+ * `CollectionState` — you receive this, you don't construct it.
+ * Produced by `useFilterCollection()` (also `useStaticListFilterCollection()`, `useCollection()`, `createCollection()`).
+ */
+declare class CollectionState<T, F> {
+}
+
+declare function useCreateOptimisticActions(): <T, F extends FiltersMap>(collection: CollectionState<T, F>, params?: Partial<CollectionOptimisticActionsBaseParams<T, F>>) => CollectionOptimisticActions<T, F>;
+declare function useOptimisticActions<T, F extends FiltersMap>(collection: CollectionState<T, F>, params?: Partial<CollectionOptimisticActionsBaseParams<T, F>>): CollectionOptimisticActions<T, F>;
+
+export { useCreateOptimisticActions, useOptimisticActions };

package/dist/dts-bundle/hooks/usePatternsNavigate.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `WixPatternsRouterState` — you receive this, you don't construct it.
+ * Produced by `useWixPatternsRouter()`.
+ */
+declare class WixPatternsRouterState {
+}
+
+declare const useWixPatternsRouter: () => WixPatternsRouterState | null;
+
+declare const usePatternsNavigate: <T>() => {
+    navigateToEntityPage: ({ path, entity }: {
+        path: string;
+        entity: T;
+    }) => void;
+    navigateToCollectionPage: ({ path }: {
+        path: string;
+    }) => void;
+};
+
+export { usePatternsNavigate, useWixPatternsRouter };

package/dist/dts-bundle/hooks/usePickerModal.d.ts

@@ -0,0 +1,387 @@
+import { PaginationModeConfig } from '@wix/bex-core/react';
+import { Essentials } from '@wix/fe-essentials/core';
+import React, { CSSProperties, ReactElement, ReactNode, ComponentType } from 'react';
+import { SearchProps, BoxProps, TableListItemProps, SelectorListItem, TableListItemColumn, CustomModalLayoutProps, IconElement, FloatingNotificationProps, FloatingNotification, SelectorListContentProps } from '@wix/design-system';
+
+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 ErrorMonitor {
+    captureException(exception: unknown): string;
+}
+
+/**
+ * `Translate` — cut here because it has its own bundle.
+ * Look `Translate` up in the bundle index for its full shape.
+ */
+type Translate = unknown;
+
+interface SelectionStatus {
+    id: string;
+    toggle: () => SelectionStatus;
+    start: () => SelectionStatus;
+    final: () => SelectionStatus;
+    isChecked: boolean;
+    isIndeterminate: boolean;
+}
+
+/**
+ * `PickerState` — you receive this, you don't construct it.
+ * Produced by `usePicker()`.
+ */
+declare class PickerState<T, F> {
+}
+
+/**
+ * `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 OptionalFiltersMap = {
+    [key: string]: undefined;
+};
+
+type ExtractFilterValue<T> = T extends Filter<infer U> ? U : undefined;
+/**
+ * `ComputedQuery` — cut here because it has its own bundle.
+ * Look `ComputedQuery` up in the bundle index for its full shape.
+ */
+interface ComputedQuery<F> {
+}
+
+interface DataResultRaw<T> {
+    /**
+     * Array of items returned from the server.
+     * @external
+     */
+    items: T[];
+    /**
+     * Total items available in the server, *after* applying filters. If not provided, offset pagination will not work correctly.
+     * If you are using a cursor and did not include `total` in your query request, you can use the `fetchTotal` function to extract it asynchronously.
+     * @default `items.length`
+     * @external
+     */
+    total?: number | null;
+    /**
+     * Total items available in the server, *before* applying filters.
+     * @external
+     */
+    available?: number;
+    /**
+     * In case of cursor pagination, this will be the value that will be sent in the query on the next page request.
+     * @external
+     */
+    cursor?: string | undefined | null;
+    /**
+     * Indicates whether there are more items available after the current page.
+     * @external
+     */
+    hasNext?: boolean | null;
+}
+
+interface CollectionSearchProps extends Partial<SearchProps> {
+    onSearchChange?: (value: string) => unknown;
+    onSearchClick?: () => unknown;
+    onSearchBlur?: (value: string) => unknown;
+    visibility?: CSSProperties['visibility'];
+}
+declare const CollectionSearch: (<T, F extends FiltersMap = FiltersMap>({ onSearchChange, onSearchClick, onSearchBlur, visibility, expandable, ...rest }: CollectionSearchProps) => React.JSX.Element) & {
+    displayName: string;
+};
+
+type CollectionSearchElement = ReactElement<CollectionSearchProps, typeof CollectionSearch>;
+
+type MultipleSelection = boolean | number;
+type MaxSelectionLabelProps = {
+    dataHook?: string;
+    multiple?: MultipleSelection;
+    t: Translate;
+    customLabel?(_: {
+        num: number;
+        max: number;
+    }): string;
+    selectedCount: number;
+};
+
+interface PickerProps<T, F extends FiltersMap> {
+    dataHook?: BoxProps['dataHook'];
+    flex?: CSSProperties['flex'];
+    state: PickerState<T, F>;
+    renderError: (params: {
+        err: unknown;
+        isOnline: boolean;
+    }) => ReactElement;
+    renderEmptyState?: (params: {
+        hasAvailableItems: boolean;
+        query: ComputedQuery<F>;
+    }) => ReactElement | null | undefined;
+    hasFilterDropdown?: boolean;
+    children: ReactNode;
+}
+
+interface PickerListItemProps extends Partial<Omit<TableListItemProps, 'options'>>, SelectorListItem {
+    options: (Omit<TableListItemColumn, 'value'> & {
+        value?: ReactNode;
+        end?: boolean;
+    })[];
+}
+
+interface PickerContentBaseWrappedProps extends Partial<CustomModalLayoutProps> {
+}
+
+interface PickerContentItemsSelectionProps<T, F extends FiltersMap> extends Partial<PickerContentBaseWrappedProps> {
+    modalState: PickerModalState<T, F>;
+    customContentButtonText?: string;
+    customContentButtonPrefixIcon?: IconElement;
+    /**
+     * A callback to be called when the custom content button is clicked
+     */
+    customContentButtonOnClick?: (param: {
+        onClose: (newItems?: T[]) => void;
+    }) => void;
+    customContent?: CustomModalContent<T>;
+    /**
+     * Shows "Select All" checkbox as a side action (overrides "customContent" prop).
+     * If `multiple={number}` or `multiple={false}` are used, this prop does nothing.
+     */
+    showSelectAllCheckbox?: boolean;
+    multiple?: MultipleSelection;
+    /**
+     * Shows a SingleSelectFilter component in a picker modal to filter items;
+     */
+    filterComponent?: ReactElement;
+    /**
+     * A function that render a item row in the selector list
+     */
+    renderItem: (item: T, index: number) => Partial<PickerListItemProps>;
+    /**
+     * A render function to be rendered when there're no items to show in the table.<br>
+     * You can use the built in [`<CollectionEmptyState />`](./?path=/story/features-display-empty-states--collectionemptystate).<br>
+     * The function accepts the following parameters
+     *   * `hasAvailableItems`: Indicates whether other items might have been shown using other filtering / search
+     *   * `query`: An instance of [ComputedQuery](./?path=/story/common-types--computedquery) that represents the query that resulted with an empty state
+     */
+    renderEmptyState?: (params: {
+        hasAvailableItems: boolean;
+        query: ComputedQuery<F>;
+    }) => ReactElement<any, any> | null | undefined;
+    renderError: PickerProps<T, F>['renderError'];
+    /**
+     * When set to `true`, the modal primary button will be always enabled.
+     */
+    enablePrimaryButton?: boolean;
+    /**
+     * Displays a search input in the picker modal.
+     * Accepts a boolean or a custom CollectionSearch element as a parameter.
+     * When passing `false`, no search input is displayed.
+     * @default true
+     * @external
+     */
+    search?: boolean | CollectionSearchElement;
+    /**
+     * @deprecated Use search={false} instead
+     * Hides the search input of the picker
+     */
+    hideSearch?: boolean;
+    /**
+     * Function that returns label for multi selection like:
+     * '2 items selected (24 max)`
+     * This function accepts argument {num: number, max: number}
+     */
+    customMaxSelectionLabel?: MaxSelectionLabelProps['customLabel'];
+    /**
+     * Function that returns custom notification that will be displayed in the picker modal.
+     * Useful to describe additional information about the selection (for instance how to increase limit of selected items).
+     * @param data.selected - number of selected items
+     * @param data.total - total number of items
+     */
+    renderCustomNotification?: (data: {
+        selected?: number;
+        total?: number;
+    }) => ReactElement<FloatingNotificationProps, typeof FloatingNotification>;
+    /** Displays count of selected items in <CustomModalLayout /> `sideActions` */
+    showSelectedCount?: boolean;
+}
+
+interface PickerContentAdditionalStepProps<T> extends Partial<PickerContentBaseWrappedProps> {
+    /** When true, the picker will start directly on the additional step, skipping the first selection step. The back button will also be hidden. */
+    autoAdditionalStepOnInitialSelect?: boolean;
+    /** The additional step title */
+    additionalStepTitle?: string;
+    /** The additional step subtitle */
+    additionalStepSubtitle?: string;
+    /** Defines a function that returns a component to render in the additional step content area, if `hasAdditionalStep` returns `false` this prop is ignored. */
+    renderAdditionalStepContent?: (props: {
+        item: T;
+    }) => JSX.Element;
+    /** Indicates if selected item has additional step or not */
+    hasAdditionalStep?: (props: {
+        item: T;
+    }) => boolean;
+    /** Defines a callback function just before primaryButtonOnClick callback, returned value will be added as `additionalStepData` in onSelect payload */
+    onBeforeSelectAdditionalStep?: () => Promise<unknown>;
+    /** Defines a callback function after user clicks on the continue button to additional step content */
+    continueButtonOnClick?: (props: {
+        item: T;
+    }) => void;
+    /** Defines a callback function after user clicks on the back button in the additional step content */
+    backButtonOnClick?: (props: {
+        item: T;
+    }) => void;
+    /** Additional steps modal content overrides */
+    additionalStepOverrides?: {
+        extraNode?: React.ReactNode;
+        extraText?: string;
+        subtitle?: string;
+        image?: React.ReactNode;
+        enablePrimaryButton?: boolean;
+    };
+}
+
+interface PickerContentComponentBaseProps<T, F extends FiltersMap> extends PickerContentItemsSelectionProps<T, F>, PickerContentAdditionalStepProps<T> {
+    /**
+     * Additional props to pass to [SelectorList](https://www.docs.wixdesignsystem.com/?path=/story/components-lists--selectorlist), i.e `imageSize`, `imageShape` etc.
+     */
+    selectorListProps?: Partial<SelectorListContentProps>;
+}
+type PickerContentComponentProps<T, F extends FiltersMap = OptionalFiltersMap> = Omit<PickerContentComponentBaseProps<T, F>, 'renderItem' | 'pickerContentState' | 'renderEmptyState' | 'renderPickerContent'>;
+type PickerContentComponent<T, F extends FiltersMap = OptionalFiltersMap> = ComponentType<PickerContentComponentProps<T, F>>;
+
+type RawFiltersParams<F extends FiltersMap> = {
+    [P in keyof F]: {
+        initialValue?: ExtractFilterValue<F[P]>;
+    };
+};
+interface PickerModalEvents {
+    readonly onError?: (params: {
+        err: unknown;
+        isOnline: boolean;
+    }) => boolean | null | undefined | void;
+}
+interface OnSelectOptions<T> {
+    isSelectAll: boolean;
+    uncheckedValues: T[];
+    selectedCount: number;
+    /**
+     * @deprecated Read `values` prop instead
+     */
+    partiallySelectedIds: string[];
+    values: {
+        status: SelectionStatus;
+        value: T;
+    }[];
+    defaultStatus: SelectionStatus;
+    additionalStepData?: unknown;
+}
+interface UsePickerModalParamsBase<T, F extends FiltersMap> {
+    /** The user's environment
+     * - `language` - preferable language for the user  */
+    environment: Environment;
+    /** A `ErrorMonitor` instance `@wix/fe-essentials/error-monitor` */
+    errorMonitor: ErrorMonitor;
+    /** A `BILoggerFactory` instance `@wix/fe-essentials/bi` */
+    biLoggerFactory: Essentials['biLoggerFactory'];
+    /**
+     * Number of items to fetch on each page
+     */
+    limit?: number;
+    /**
+     * Defines the initial values and config for filters that the collection supports.
+     * For example: { premium: {initialValue: 'true'} }
+     */
+    filters?: Partial<RawFiltersParams<F>>;
+    /**
+     * Optional function that loads more dependencies required for the content of the modal to show.
+     * The modal will keep showing a loader when this promise is still pending.
+     * For example custom i18n translations.
+     */
+    fetchInitialProps?: () => Promise<unknown>;
+    minContentHeight?: string | number;
+    /**
+     * A function being called after clicking the primary button of the modal.  It accepts the following parameters:
+     * - `items` - The items that were selected in the modal's internal selector list
+     * - `options.isSelectAll` - Indicates the user toggled on the "Select All" checkbox (relevant only when `showSelectAllCheckbox` is passed to `<PickerContent />`)
+     * - `options.selectedCount` - The number of items the user selected. Subtracts from total count the items that were unchecked after toggling on the "Select All" checkbox
+     * - `options.uncheckedValues` - The items the user unchecked after toggling on the "Select All" checkbox (relevant only when `showSelectAllCheckbox` is passed to `<PickerContent />`)
+     * - `options.partiallySelectedIds` - Selected items in indeterminate status
+     */
+    onSelect: (items: T[], options: OnSelectOptions<T>) => unknown;
+    /**
+     * A function that returns a promise of dynamically imported component that renders [`<PickerContent `/>](./?path=/story/base-components-collections-picker--pickercontent) internally
+     */
+    pickerContentComponent: () => Promise<{
+        default: PickerContentComponent<T, F>;
+    }>;
+    shouldFilterNotAffectTotalCount?: (filterName: keyof F) => boolean;
+    /**
+     * Optional callbacks for various events of the picker modal lifecycle
+     * `onError` - when there's an error fetching initial data, picker content chunk or initial props.
+     */
+    events?: PickerModalEvents;
+    /**
+     * Indicates what type of pagination the `fetchData` function supports.<br>
+     * In case the server accepts the `query.offset` parameter - pass `'offset'`
+     * In case the server returns a `cursor` from `fetchData` - pass `'cursor'`
+     * @default offset
+     */
+    paginationMode?: 'offset' | 'cursor';
+    /**
+     * The query name used for cache purposes. This should be a unique value per API endpoint consumed inside the `fetchData` function.<br>
+     * It's recommended to use the [Fqdn](https://bo.wix.com/wix-docs/rnd/p13n-guidelines---aips/guidance-aips/wix-api-basics/[1009]-fqdn) of the service used in `fetchData` as `queryName`
+     */
+    queryName: string;
+    /**
+     * A function that integrates with the API to fetch the collection data from.<br>
+     * Accepts the following parameters:
+     * - `query`: A [ComputedQuery](./?path=/story/common-types--computedquery)  instance. Holds all the relevant variables to query the server API with.
+     *
+     * The function must return a promise of [DataResultRaw](./?path=/story/common-models--dataresultraw)
+     */
+    fetchData?: (query: ComputedQuery<F>) => Promise<DataResultRaw<T>>;
+    isOpenInitially?: boolean;
+    /**
+     * In the picker modal, the data is prefetched before the user opens the modal. This flag disables this behavior.
+     */
+    skipFirstPagePrefetch?: boolean;
+    /**
+     * A flag to disable default behavior when fetch data returns a single item.
+     * Instead of calling onSelect a dialog will be opened.
+     */
+    disableAutoSelectOnSingleItem?: boolean;
+}
+
+type CustomModalContent<T> = (props: {
+    isOpen: boolean;
+    close: (items?: T[]) => Promise<unknown>;
+    width?: CustomModalLayoutProps['width'];
+}) => ReactNode;
+
+/**
+ * `PickerModalState` — you receive this, you don't construct it.
+ * Produced by `usePickerModal()` (also `usePickerModalState()`).
+ */
+declare class PickerModalState<T, F> {
+}
+
+interface UsePickerModalParamsOverrides<T, F extends FiltersMap> {
+    environment?: Partial<UsePickerModalParamsBase<T, F>['environment']>;
+}
+type UsePickerModalParamsBM<T, F extends FiltersMap> = Omit<UsePickerModalParamsBase<T, F>, 'paginationMode' | 'fetchData' | 'environment' | 'errorMonitor' | 'biLoggerFactory'>;
+type UsePickerModalParams<T, F extends FiltersMap> = UsePickerModalParamsBM<T, F> & UsePickerModalParamsOverrides<T, F> & PaginationModeConfig<T, F>;
+type PikerModalFactory = <T, F extends FiltersMap = OptionalFiltersMap>(config: UsePickerModalParams<T, F>) => PickerModalState<T, F>;
+declare function useCreatePickerModal(): PikerModalFactory;
+declare function usePickerModal<T, F extends FiltersMap = OptionalFiltersMap>(params: UsePickerModalParams<T, F>): PickerModalState<T, F>;
+
+export { useCreatePickerModal, usePickerModal };
+export type { PikerModalFactory, UsePickerModalParams };

package/dist/dts-bundle/hooks/useStaticListFilterCollection.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `CollectionState` — you receive this, you don't construct it.
+ * Produced by `useFilterCollection()` (also `useStaticListFilterCollection()`, `useCollection()`, `createCollection()`).
+ */
+declare class CollectionState<T, F> {
+}
+
+/**
+ * `Filter` — cut here because it has its own bundle.
+ * Look `Filter` up in the bundle index for its full shape.
+ */
+interface Filter<T> {
+}
+
+declare function useStaticListFilterCollection<T>(
+/**
+ * This is a reference to the filter that was defined in the main collection. For example: `collection.filters.<filterName>`
+ */
+filter: Filter<T[]>, 
+/**
+ * Static list of items to show in the filter component
+ */
+list: T[]): CollectionState<T, {}>;
+
+export { useStaticListFilterCollection };