@wix/patterns 1.457.0 → 1.459.0

package/dist/dts-bundle/functions/operatorFilter.d.ts

@@ -0,0 +1,127 @@
+type FilterItem<T> = T extends (infer V)[] ? V : T;
+interface FilterStateBaseParams<T> {
+    name?: string;
+    /**
+     * Marks the filter as a "context" or "scope" filter. This makes the filter not be visible in the sub-toolbar tag list, not saved in views, not counted as "X filters applied".
+     * @external
+     */
+    persistent?: boolean;
+    /**
+     * The value to initialize the filter with (Optional)
+     * @external
+     */
+    initialValue?: T;
+    /**
+     * A callback function that accepts an item and returns a unique ID of it. typically `item.id`.
+     * @external
+     */
+    itemKey: (item: FilterItem<T>) => string;
+    /**
+     * A callback function that accepts an item and returns the item name which is used in many messages through cairo
+     * @external
+     */
+    itemName: (item: FilterItem<T>) => string;
+    /**
+     * A function which accepts 2 items and returns true if they are equal
+     * @external
+     */
+    equals?: (item1: FilterItem<T>, item2: FilterItem<T>) => boolean;
+    /**
+     * If the filter is a custom field
+     */
+    isCustomField?: boolean;
+}
+
+/**
+ * Filter operators enum for OperatorFilterState
+ * These operators are used to define how filtering should be applied
+ */
+declare enum FilterOperator {
+    /** Equal - exact match */
+    EQUALS = "$eq",
+    /** Not equal - exclude exact match */
+    NOT_EQUALS = "$ne",
+    /** In - value is in the provided array */
+    IN = "$in",
+    /** Not in - value is not in the provided array */
+    NOT_IN = "$nin",
+    /** Starts with - string starts with the provided value */
+    STARTS_WITH = "$startsWith",
+    /** Is empty - value is null or empty */
+    IS_EMPTY = "$isEmpty",
+    /** Contains - string contains the provided value */
+    CONTAINS = "$contains",
+    /** Not contains - string does not contain the provided value */
+    NOT_CONTAINS = "$notContains",
+    /** Exists - field is not null/undefined */
+    EXISTS = "$exists",
+    /** Not exists - field is null/undefined */
+    NOT_EXISTS = "$notExists"
+}
+
+/**
+ * Check if an operator requires a value input.
+ * Operators that don't need a value (IS_EMPTY, EXISTS, NOT_EXISTS) are
+ * immediately "active" when selected, so they have no neutral "zero state".
+ */
+declare const operatorNeedsValue: (operator: FilterOperator) => boolean;
+/**
+ * Standard operator ordering for UI display.
+ * This is the default ordering applied when `operatorOrderOverride` is not set.
+ */
+declare const DEFAULT_OPERATOR_ORDER: FilterOperator[];
+interface OperatorFilterValue<T> {
+    operator: FilterOperator;
+    value: T | null;
+}
+interface OperatorFilterStateParams<T> extends Omit<FilterStateBaseParams<OperatorFilterValue<T>>, 'itemKey' | 'itemName' | 'equals'> {
+    /**
+     * Function to get the key of an item (for value dropdown)
+     */
+    itemKey?: (item: FilterItem<OperatorFilterValue<T>>) => string;
+    /**
+     * Function to get the display name of an item (for value dropdown)
+     */
+    itemName?: (item: FilterItem<OperatorFilterValue<T>>) => string;
+    /**
+     * Function to check if two items are equal
+     */
+    equals?: (item1: FilterItem<OperatorFilterValue<T>>, item2: FilterItem<OperatorFilterValue<T>>) => boolean;
+    /**
+     * Function to encode the value for serialization
+     */
+    encode?: (value: OperatorFilterValue<T>) => unknown;
+    /**
+     * Function to decode a value from serialization
+     */
+    decode?: (value: unknown) => OperatorFilterValue<T>;
+    /**
+     * Function to check if an item matches the filter value
+     */
+    matches?: (item: FilterItem<OperatorFilterValue<T>>, value: OperatorFilterValue<T>) => boolean;
+    /**
+     * List of allowed operators for this filter.
+     * The first operator will be used as the default.
+     */
+    allowedOperators: FilterOperator[];
+    /**
+     * When `true`, keeps `allowedOperators` order as-is instead of
+     * reordering by `DEFAULT_OPERATOR_ORDER`. If the first operator
+     * doesn't require a value, falls back to default order.
+     */
+    operatorOrderOverride?: boolean;
+}
+/**
+ * `OperatorFilterState` — you receive this, you don't construct it.
+ * Produced by `operatorFilter()` (also `stringOperatorFilter()`).
+ */
+declare class OperatorFilterState<T = any> {
+    [key: string]: unknown;
+}
+declare const operatorFilter: <T>(params: OperatorFilterStateParams<T>) => OperatorFilterState<T>;
+declare const stringOperatorFilter: (params: Omit<Partial<OperatorFilterStateParams<string>>, "allowedOperators"> & {
+    allowedOperators: FilterOperator[];
+}) => OperatorFilterState<string>;
+
+export { DEFAULT_OPERATOR_ORDER, OperatorFilterState, operatorFilter, operatorNeedsValue, stringOperatorFilter };
+export type { OperatorFilterStateParams, OperatorFilterValue };

package/dist/dts-bundle/functions/stringFilter.d.ts

@@ -0,0 +1,27 @@
+interface StringFilterStateParams {
+    readonly name?: string;
+    readonly persistent?: boolean;
+    /**
+     * The value to initialize the filter with (Optional)
+     * @external
+     */
+    readonly initialValue?: string;
+    /**
+     * The value to set the value to, when clearing the filter (Optional)
+     * @external
+     */
+    defaultValue: string;
+    readonly matches?: (item: string, value: string) => boolean;
+    readonly equals?: (item1: string, item2: string) => boolean;
+}
+/**
+ * `StringFilterState` — you receive this, you don't construct it.
+ * Produced by `stringFilter()`.
+ */
+declare class StringFilterState {
+    [key: string]: unknown;
+}
+declare const stringFilter: (params?: Partial<StringFilterStateParams>) => StringFilterState;
+
+export { StringFilterState, stringFilter };
+export type { StringFilterStateParams };

package/dist/dts-bundle/functions/stringsArrayFilter.d.ts

@@ -0,0 +1,83 @@
+type FilterItem<T> = T extends (infer V)[] ? V : T;
+interface FilterStateBaseParams<T> {
+    name?: string;
+    /**
+     * Marks the filter as a "context" or "scope" filter. This makes the filter not be visible in the sub-toolbar tag list, not saved in views, not counted as "X filters applied".
+     * @external
+     */
+    persistent?: boolean;
+    /**
+     * The value to initialize the filter with (Optional)
+     * @external
+     */
+    initialValue?: T;
+    /**
+     * A callback function that accepts an item and returns a unique ID of it. typically `item.id`.
+     * @external
+     */
+    itemKey: (item: FilterItem<T>) => string;
+    /**
+     * A callback function that accepts an item and returns the item name which is used in many messages through cairo
+     * @external
+     */
+    itemName: (item: FilterItem<T>) => string;
+    /**
+     * A function which accepts 2 items and returns true if they are equal
+     * @external
+     */
+    equals?: (item1: FilterItem<T>, item2: FilterItem<T>) => boolean;
+    /**
+     * If the filter is a custom field
+     */
+    isCustomField?: boolean;
+}
+
+interface ArrayFilterStateParams<T> extends FilterStateBaseParams<T[]> {
+    /**
+     * The value to set the value to, when clearing the filter (Optional)
+     * @external
+     */
+    defaultValue?: T[];
+    /**
+     * Convert a unknown object to a T.<br>
+     * If the function returns null, the item will be skipped when we try to deserializate it from an array.
+     * @param value
+     * @external
+     */
+    readonly parse: (value: Record<string, unknown> | string | null | undefined) => T | null;
+    /**
+     * Return a simplified form of an item for serialization.
+     * @param value
+     * @external
+     */
+    readonly simplify?: (value: T) => Partial<T>;
+    /**
+     * Indicates whether an item matches the current value of the filter
+     * @external
+     */
+    readonly matches?: (item: T, value: T[]) => boolean;
+    readonly equals?: (item1: T, item2: T) => boolean;
+}
+/**
+ * `ArrayFilterState` — you receive this, you don't construct it.
+ * Produced by `stringsArrayFilter()` (also `arrayFilter()`, `idNameArrayFilter()`, `idArrayFilter()`).
+ */
+declare class ArrayFilterState<T = any> {
+    [key: string]: unknown;
+}
+declare const stringsArrayFilter: <T extends string>(params?: Partial<ArrayFilterStateParams<T>>) => ArrayFilterState<T>;
+declare const arrayFilter: <T>(params: ArrayFilterStateParams<T>) => ArrayFilterState<T>;
+declare const idNameArrayFilter: <T extends {
+    id: string;
+    name: string;
+}>(params?: Partial<ArrayFilterStateParams<T>>) => ArrayFilterState<T>;
+declare const idArrayFilter: <T extends {
+    id: string;
+}>(params?: Partial<ArrayFilterStateParams<T>>) => ArrayFilterState<T>;
+declare const idNameArrayFilterNum: <T extends {
+    id: number;
+    name: string;
+}>(params?: Partial<ArrayFilterStateParams<T>>) => ArrayFilterState<T>;
+
+export { ArrayFilterState, arrayFilter, idArrayFilter, idNameArrayFilter, idNameArrayFilterNum, stringsArrayFilter };
+export type { ArrayFilterStateParams };

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

@@ -0,0 +1,29 @@
+import { FieldValues, FieldPath, UseControllerProps, UseControllerReturn } from './types';
+
+/**
+ * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/usecontroller) • [Demo](https://codesandbox.io/s/usecontroller-0o8px)
+ *
+ * @param props - the path name to the form field value, and validation rules.
+ *
+ * @returns field properties, field and form state. {@link UseControllerReturn}
+ *
+ * @example
+ * ```tsx
+ * function Input(props) {
+ *   const { field, fieldState, formState } = useController(props);
+ *   return (
+ *     <div>
+ *       <input {...field} placeholder={props.name} />
+ *       <p>{fieldState.isTouched && "Touched"}</p>
+ *       <p>{formState.isSubmitted ? "submitted" : ""}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useController<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>, TTransformedValues = TFieldValues>(props: UseControllerProps<TFieldValues, TName, TTransformedValues>): UseControllerReturn<TFieldValues, TName>;
+
+export { useController };

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

@@ -0,0 +1,349 @@
+interface ExtendedFieldsDataMap {
+    [key: string]: any;
+}
+interface ExtendedFields {
+    _type?: 'ExtendedFields';
+    /**
+     * Data Extensions extended fields
+     * Key: Namespace
+     * Value: extended fields data in Struct format
+     */
+    namespaces?: {
+        _user_fields?: ExtendedFieldsDataMap | undefined;
+        [key: string]: ExtendedFieldsDataMap | undefined;
+    };
+}
+
+type PaginationModeRef = {
+    current: 'offset' | 'cursor' | undefined;
+};
+
+/**
+ * `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 OffsetQuery<F extends FiltersMap = OptionalFiltersMap> = Omit<ComputedQuery<F>, 'cursor'>;
+type OffsetQueryResult<T> = Omit<DataResultRaw<T>, 'cursor'>;
+type OffsetFetchDataFn<T, F extends FiltersMap> = (query: OffsetQuery<F>) => Promise<OffsetQueryResult<T>>;
+type CursorQueryResult<T> = Omit<DataResultRaw<T>, 'cursor'> & {
+    cursor: string | undefined | null;
+};
+/**
+ * `CursorQuery` — cut here because it has its own bundle.
+ * Look `CursorQuery` up in the bundle index for its full shape.
+ */
+type CursorQuery<F = any> = Record<string, unknown>;
+type CursorFetchDataFn<T, F extends FiltersMap> = (query: CursorQuery<F>) => Promise<CursorQueryResult<T>>;
+type FetchTotalFn = (query: CursorQuery) => Promise<number>;
+type PaginationModeConfig<T, F extends FiltersMap> = {
+    paginationMode?: 'offset';
+    fetchData: OffsetFetchDataFn<T, F>;
+} | {
+    paginationMode: 'cursor';
+    fetchTotal?: FetchTotalFn;
+    fetchData: CursorFetchDataFn<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 = any> {
+    [key: string]: unknown;
+}
+type FiltersMap = {
+    [key: string]: Filter<any> | undefined;
+};
+type OptionalFiltersMap = {
+    [key: string]: undefined;
+};
+
+/**
+ * `ComputedQuery` — cut here because it has its own bundle.
+ * Look `ComputedQuery` up in the bundle index for its full shape.
+ */
+interface ComputedQuery<F = any> {
+    [key: string]: unknown;
+}
+
+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 ComputedResult {
+    total: number;
+    available: number;
+}
+
+type OnResultUpdated<F extends FiltersMap> = (params: {
+    query: ComputedQuery<F>;
+    result: ComputedResult;
+}) => unknown;
+type OnNewPageAdded<F extends FiltersMap> = (params: {
+    totalNewItems: number;
+    result: {
+        total: number;
+        available: number;
+    };
+    query: ComputedQuery<F>;
+}) => unknown;
+interface CollectionEvents<F extends FiltersMap> {
+    /** When the first page of items is ready */
+    readonly onInitialPageFetched?: OnResultUpdated<F>;
+    /** When fetching new items as a result new search */
+    readonly onSearch?: (params: {
+        query: ComputedQuery<F>;
+    }) => unknown;
+    /** When the result of a search is ready */
+    readonly onSearchResults?: OnResultUpdated<F>;
+    /** When starting to load the next page of items */
+    readonly onNewPageStart?: (params: {
+        query: ComputedQuery<F>;
+    }) => void | undefined | null | OnNewPageAdded<F>;
+    /** When the result of the next page is ready */
+    readonly onNewPageAdded?: OnNewPageAdded<F>;
+    /** When `fetchData` throws an error. Return `true` from this function if the error was reported and shouldn't be reported again internally. */
+    readonly onError?: (params: {
+        err: unknown;
+        isOnline: boolean;
+    }) => boolean | undefined | null | void;
+}
+
+/**
+ * Retry configuration for failed queries.
+ * - `false`: Disable retries entirely
+ * - `number`: Retry up to this many times
+ * - `function`: Custom retry logic that receives (failureCount, error) and returns boolean
+ */
+type RetryValue = boolean | number | ((failureCount: number, error: unknown) => boolean);
+interface QueryOptions {
+    staleTime?: number;
+    retryDelay?: number;
+    /**
+     * Configure retry behavior for failed queries.
+     *
+     * By default, Cairo retries all failed queries up to 3 times.
+     *
+     * @example
+     * // Disable retries entirely
+     * queryOptions: { retry: false }
+     *
+     * @example
+     * // Custom retry logic
+     * queryOptions: {
+     *   retry: (failureCount, error) => {
+     *     // Only retry on 5xx server errors
+     *     if (isHttpError(error) && error.response?.status >= 500) {
+     *       return failureCount < 3;
+     *     }
+     *     return false;
+     *   }
+     * }
+     */
+    retry?: RetryValue;
+}
+
+interface CollectionConfigBase<T, F extends FiltersMap> {
+    /**
+     * Whether to disable "Select All" server simulation for bulk selection.
+     * @external
+     */
+    disableAutoSelectAllCount?: boolean;
+    /**
+     * Whether to enable new "Select All" logic.
+     * <br> <br>
+     * If `true`: <br>
+     * - Unchecking items after checking "Select All" does not fallback to specific selection logic and values. This means in `<bulkActionToolbar />` and `<MultiBulkActionToolbar />`, "Total Selected" will show `total - unchecked items` and `isSelectAll` will be true. <br>
+     * - You will receive a list of unchecked IDs.
+     * @external
+     */
+    useNewSelectAllLogic?: boolean;
+    /**
+     * Unique value for each API endpoint consumed in `fetchData`.
+     * @external
+     */
+    queryName: string;
+    /**
+     * Entity fqdn.
+     * @external
+     */
+    fqdn?: string;
+    /**
+     * The `ExtendedFields` object used to render custom field values
+     * Optional in case your data complies to the type `{ extendedFields: ExtendedFields }`
+     */
+    toExtendedFields?: (item: T) => ExtendedFields | undefined | null;
+    /**
+     * Message shown in a toast when fetching from the server fails.
+     * <br> <br>
+     * If the function returns a nullish value, no toast is shown.
+     * @external
+     * @deprecated Instead of using `fetchErrorMessage`, use `errorState` prop in the component, which will show the error message in the card.
+     */
+    fetchErrorMessage?: (params: {
+        err: unknown;
+        isOnline: boolean;
+    }) => string | null | undefined;
+    search?: Filter<string>;
+    queryOptions?: QueryOptions;
+    /**
+     * Persist the selected filters, search & sort in the query parameters of the URL.<br/>
+     * For improved readability, sort & columns are formatted in CSV-like formatting, i.e "?sort=name+desc,price+asc". Do not use commas and/or spaces for your columns IDs.<br>
+     * Note: The filters from the selected view will be persist, but the actual view will not be selected
+     * @default false
+     */
+    persistQueryToUrl?: boolean;
+    /**
+     * Whether the collection refreshes when different columns are selected.
+     * <br> <br>
+     * Selected columns are passed in `fetchData(query.columns)`.
+     * @default false
+     * @external
+     */
+    refreshOnColumnsChange?: boolean;
+    initialPage?: DataResultRaw<T>;
+    deferInitialLoading?: boolean;
+    /**
+     * Preserve or clear selection after applying a new search or filter.
+     * @default preserve
+     * @external
+     */
+    selectionConsistencyMode?: 'preserve' | 'clear';
+    /**
+     * Optional callbacks for various events of the collection state lifecycle
+     * - `onInitialPageFetched` - when the first page of items is ready
+     * - `onSearch` - when fetching new items as a result new search
+     * - `onSearchResults` - when the result of a search is ready
+     * - `onNewPageStart` - when starting to load the next page of items
+     * - `onNewPageAdded` - when the result of the next page is ready
+     * - `onError` - When `fetchData` throws an error. Return `true` from this function if the error was reported and shouldn't be reported again internally.
+     */
+    events?: CollectionEvents<F>;
+}
+interface CollectionConfigAnyPaginationMode<T, F extends FiltersMap> extends CollectionConfigBase<T, F> {
+    /**
+     * Function that fetches the collection data.<br> <br>
+     * Supported parameters: <br>
+     * - `query`: [object] [ComputedQuery](./com?path=/story/common-models--computedquery) instance.
+     * <br> <br>
+     *
+     * Must return a [DataResultRaw](./?path=/story/common-models--dataresultraw) Promise.
+     * @external
+     */
+    fetchData: (query: ComputedQuery<F>) => Promise<DataResultRaw<T>>;
+    /**
+     * A function that fetches the total number of items in the collection.<br> <br>
+     * Supported parameters: <br>
+     * - `query`: [object] [ComputedQuery](./com?path=/story/common-models--computedquery) of type `CursorQuery`.
+     * <br> <br>
+     * Must return a number Promise.
+     * @external
+     */
+    fetchTotal?: FetchTotalFn;
+    /**
+     * Defines the filters that the collection supports.
+     * <br> <br>
+     * Either an [arrayFilter](./?path=/story/features-filter-factories--arrayfilter) or a [customFilter](./?path=/story/features-filter-factories--customfilter).
+     * @external
+     */
+    filters: F;
+    /**
+     * Used to identify the item in many messages from Wix Patterns.
+     * <br> <br>
+     * For example, '{entity} "{itemName}" was deleted successfully' may become 'Contact "Johnny Doe" was deleted successfully'.
+     * <br> <br>
+     * If your data has an ID, then `itemKey` will default to this ID.
+     * @external
+     */
+    itemName: (item: T) => string;
+    /**
+     * Unique key within the collection. The item's ID is often used for its key.
+     * <br> <br>
+     * If your data has an ID, then `itemKey` will default to this ID.
+     * @external
+     */
+    itemKey: (item: T) => string;
+    /**
+     * Maximum number of items fetched per page.
+     * @external
+     */
+    limit?: number;
+}
+interface CollectionConfig<T, F extends FiltersMap> extends CollectionConfigAnyPaginationMode<T, F> {
+    /**
+     * Pagination type supported by `fetchData`.
+     * <br> <br>
+     * Supported values: <br>
+     * - `"offset"`: Server accepts `query.offset`. <br>
+     * - `"cursor"`: Server returns a cursor when `fetchData` is called.
+     * @default offset
+     * @external
+     */
+    paginationMode?: 'cursor' | 'offset';
+}
+
+type ItemKeyConfig<T> = T extends {
+    id?: string | null;
+} ? {
+    itemKey?: (item: T) => string;
+} : T extends {
+    _id?: string | null;
+} ? {
+    itemKey?: (item: T) => string;
+} : {
+    itemKey: (item: T) => string;
+};
+type ItemNameConfig<T> = T extends {
+    name?: string | null;
+} ? {
+    itemName?: (item: T) => string;
+} : {
+    itemName: (item: T) => string;
+};
+type FiltersConfig<F extends FiltersMap> = F extends OptionalFiltersMap ? {
+    filters?: {};
+} : {
+    filters: F;
+};
+type CollectionConfigConditionals<T, F extends FiltersMap> = FiltersConfig<F> & ItemKeyConfig<T> & ItemNameConfig<T> & PaginationModeConfig<T, F>;
+type CollectionConfigWithConditionals<T, F extends FiltersMap> = Omit<CollectionConfig<T, F>, 'itemKey' | 'itemName' | 'filters' | 'paginationMode' | 'fetchData'> & CollectionConfigConditionals<T, F>;
+
+type CollectionFactory = <T, F extends FiltersMap = OptionalFiltersMap>(config: CollectionConfigWithConditionals<T, F>) => CollectionState<T, F>;
+declare function usePrivateCreateCollection(): <T, F extends FiltersMap = OptionalFiltersMap>(config: CollectionConfigWithConditionals<T, F>, options?: {
+    paginationModeRef?: PaginationModeRef;
+}) => CollectionState<T, F>;
+declare function useCreateCollection(): CollectionFactory;
+declare function useCollection<T, F extends FiltersMap = OptionalFiltersMap>(config: CollectionConfigWithConditionals<T, F>): CollectionState<T, F>;
+
+export { useCollection, useCreateCollection, usePrivateCreateCollection };
+export type { CollectionFactory };

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

@@ -0,0 +1,19 @@
+import { FieldValues } from 'react-hook-form';
+
+/**
+ * `EntityPageState` — you receive this, you don't construct it.
+ * Produced by `useEntityPage()` (also `useEntityPageContext()`).
+ */
+declare class EntityPageState<T = any, V = any> {
+    [key: string]: unknown;
+}
+
+/**
+ * `UseEntityPageParams` — cut here because it has its own bundle.
+ * Look `UseEntityPageParams` up in the bundle index for its full shape.
+ */
+type UseEntityPageParams<T = any, V = any> = Record<string, unknown>;
+declare function useEntityPage<T, V extends FieldValues = FieldValues>(props: UseEntityPageParams<T, V>): EntityPageState<T, V>;
+
+export { useEntityPage };
+export type { UseEntityPageParams };