@wix/patterns 1.457.0 → 1.458.0

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

@@ -0,0 +1,73 @@
+import React from 'react';
+
+interface ExploreAppsModalProps {
+    title: string;
+    subtitle: string;
+    tag: string;
+}
+
+/**
+ * `MoreActionsItem` — cut here because it has its own bundle.
+ * Look `MoreActionsItem` up in the bundle index for its full shape.
+ */
+interface MoreActionsItem {
+}
+
+/**
+ * `WixPatternsContainer` — you receive this, you don't construct it.
+ * Produced by `useWixPatternsContainer()` (also `buildWixPatternsContainer()`, `useCustomFieldsViewWidget()`).
+ */
+declare class WixPatternsContainer {
+}
+
+/**
+ * `CollectionPageState` — you receive this, you don't construct it.
+ * Produced by `useCollectionPageState()` (also `useCollectionPageContext()`).
+ */
+declare class CollectionPageState {
+}
+
+type MoreActionItemFactory = (params: {
+    pageState: CollectionPageState;
+    container: WixPatternsContainer;
+}) => MoreActionsItem;
+type MoreActionsPropItem = MoreActionsItem | MoreActionItemFactory;
+
+interface MoreActionsProps {
+    /**
+     * Actions items that appear in the `MoreActions` popover menu. \
+     * Actions can be grouped by using an array of arrays. \
+     * Each sub-array represents a different group within the popover, \
+     * and a divider will be rendered after each sub-array to separate the groups.
+     * @overrideType [MoreActionsItem](./?path=/story/common-types--moreactionsitem)[] | [MoreActionsItem](./?path=/story/common-types--moreactionsitem)[][]
+     * @external
+     */
+    items?: MoreActionsPropItem[] | MoreActionsPropItem[][];
+    /**
+     * An id of the container defined in the installed on a site application that contains TPA's actions.
+     */
+    containerId?: string;
+    /**
+     * Additional properties passed to the `onClick` of the container's extensions menu items.
+     */
+    containerProps?: Record<string, any>;
+    /**
+     * Additional info for cairoPageCtaClicked BI event.
+     */
+    biAdditionalInfo?: string;
+    dataHook?: string;
+    exploreAppsModalProps?: ExploreAppsModalProps;
+}
+
+interface MoreActionsIconProps extends MoreActionsProps {
+}
+declare function _MoreActionsIcon(params: MoreActionsIconProps): React.JSX.Element;
+declare const MoreActionsIcon: typeof _MoreActionsIcon & {
+    displayName: string;
+};
+declare const MoreActions: typeof _MoreActionsIcon & {
+    displayName: string;
+};
+
+export { MoreActions, MoreActionsIcon };
+export type { MoreActionsIconProps };

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

@@ -0,0 +1,35 @@
+import React, { PropsWithChildren } from 'react';
+import { BoxProps, CheckboxProps } from '@wix/design-system';
+
+/**
+ * `FilterProps` — cut here because it has its own bundle.
+ * Look `FilterProps` up in the bundle index for its full shape.
+ */
+interface FilterProps<V> {
+}
+
+interface MultiAutoInlineCheckboxFilterProps<V> extends FilterProps<V[]>, Partial<Omit<BoxProps, 'filter'>> {
+    /**
+     * List of items to select from
+     * @external
+     */
+    data: V[];
+    /**
+     * A function that returns checkbox props for rendering each item checkbox
+     * @external
+     */
+    renderItem?: (item: V, index: number) => Partial<PropsWithChildren<CheckboxProps>>;
+    /**
+     * Maximum of inline items to display
+     * @default 10
+     * @external
+     */
+    maxInlineItems?: number;
+}
+declare function _MultiAutoInlineCheckboxFilter<V>(props: MultiAutoInlineCheckboxFilterProps<V>): React.JSX.Element;
+declare const MultiAutoInlineCheckboxFilter: typeof _MultiAutoInlineCheckboxFilter & {
+    displayName: string;
+};
+
+export { MultiAutoInlineCheckboxFilter };
+export type { MultiAutoInlineCheckboxFilterProps };

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

@@ -0,0 +1,44 @@
+import { PopoverMenuProps } from '@wix/design-system';
+import React from 'react';
+
+/**
+ * `ActionSubitem` — cut here because it has its own bundle.
+ * Look `ActionSubitem` up in the bundle index for its full shape.
+ */
+type ActionSubitem = unknown;
+
+interface MultiBulkActionToolbarProps {
+    /**
+     * List of primary actions. Primary actions are displayed as individual buttons.
+     * @overrideType [ActionSubitem[]](./?path=/story/common-types--actionsubitem)
+     * @external
+     */
+    primaryActionItems?: ActionSubitem[];
+    /**
+     * List of secondary actions. Secondary actions are displayed when clicking the More Actions menu.
+     * Secondary actions can be grouped by using an array of arrays, and a divider will be added between each group.
+     * @external
+     * @overrideType [ActionSubitem[]](./?path=/story/common-types--actionsubitem) | [ActionSubitem[][]](./?path=/story/common-types--actionsubitem)
+     */
+    secondaryActionItems?: ActionSubitem[] | ActionSubitem[][];
+    /**
+     * [PopoverMenu](https://www.docs.wixdesignsystem.com/?path=/story/components-overlays--popovermenu) props to pass to the 'More Action' popover menu.
+     * @external
+     */
+    secondaryActionsPopoverMenuProps?: Partial<PopoverMenuProps>;
+    /**
+     * This ID is used to specify the target container for [dashboard menu plugin](./?path=/story/features-enrich-slots-and-plugins--slots-and-plugins) items.
+     */
+    containerId?: string;
+    /**
+     * This prop is used to pass additional properties that can be used on the onClick of the container's extensions menu items.
+     */
+    containerProps?: Record<string, any>;
+}
+declare function _MultiBulkActionToolbar(props: MultiBulkActionToolbarProps): React.JSX.Element;
+declare const MultiBulkActionToolbar: typeof _MultiBulkActionToolbar & {
+    displayName: string;
+};
+
+export { MultiBulkActionToolbar };
+export type { MultiBulkActionToolbarProps };

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

@@ -0,0 +1,29 @@
+import React, { PropsWithChildren } from 'react';
+import { BoxProps, CheckboxProps } from '@wix/design-system';
+
+/**
+ * `FilterProps` — cut here because it has its own bundle.
+ * Look `FilterProps` up in the bundle index for its full shape.
+ */
+interface FilterProps<V> {
+}
+
+interface MultiInlineCheckboxFilterProps<V> extends FilterProps<V[]>, Partial<Omit<BoxProps, 'filter'>> {
+    /**
+     * List of items to select from
+     * @external
+     */
+    data: V[];
+    /**
+     * A function that returns checkbox props for rendering each item checkbox
+     * @external
+     */
+    renderItem?: (item: V, index: number) => Partial<PropsWithChildren<CheckboxProps>>;
+}
+declare function MultiInlineCheckboxFilter<V>(props: MultiInlineCheckboxFilterProps<V>): React.JSX.Element;
+declare namespace MultiInlineCheckboxFilter {
+    var displayName: string;
+}
+
+export { MultiInlineCheckboxFilter };
+export type { MultiInlineCheckboxFilterProps };

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

@@ -0,0 +1,118 @@
+import React from 'react';
+import { ListItemSelectSizes, MultiSelectCheckboxProps, DropdownLayoutOption } from '@wix/design-system';
+
+/**
+ * `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 KeyedItem<T> {
+    item: T;
+    key: string;
+    id: string;
+    pageIndex: number;
+    indexWithinPage: number;
+    index: number;
+}
+
+/**
+ * `DropdownSelectState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class DropdownSelectState<V> {
+}
+
+interface ListItem {
+    className?: string;
+    checkbox?: boolean;
+    prefix?: React.ReactNode;
+    title?: string;
+    subtitle?: string;
+    suffix?: React.ReactNode;
+    selected?: boolean;
+    disabled?: boolean;
+    size?: ListItemSelectSizes;
+    ellipsis?: boolean;
+    dataHook?: string;
+    sectionId?: string;
+    label?: string;
+}
+
+interface CollectionFilterInitialFetchTimingProps {
+    /**
+     * At which point the initial fetch of the filter collection data takes place. If this prop is omitted, it will take place on component mount.<br> <br>
+     * Supported values: <br>
+     * - `focus`: On the first visitor interaction with the filter component.
+     * @default undefined - on component mount
+     * @external
+     */
+    initialFetchTiming?: 'focus';
+    collection: {
+        initialFetch: () => unknown;
+    };
+}
+
+/**
+ * `FilterProps` — cut here because it has its own bundle.
+ * Look `FilterProps` up in the bundle index for its full shape.
+ */
+interface FilterProps<V> {
+}
+
+type KeyedItemOption<T> = DropdownLayoutOption & {
+    keyedItem: KeyedItem<T>;
+};
+type MultiSelectCheckboxFilterBaseOption<V> = KeyedItemOption<V> | DropdownLayoutOption;
+interface MultiSelectCheckboxFilterBaseProps<V> extends Partial<MultiSelectCheckboxProps>, FilterProps<V[]> {
+    /**
+     * Applies a data-hook HTML attribute that can be used in the tests
+     * @default `collection-filter-${filter.name}`
+     */
+    dataHook?: string;
+    options: MultiSelectCheckboxFilterBaseOption<V>[];
+    dropdownSelect: DropdownSelectState<V>;
+    placeholder?: string;
+}
+
+interface CollectionMultiSelectCheckboxProps<V, F extends FiltersMap = FiltersMap> extends Omit<MultiSelectCheckboxFilterBaseProps<V>, 'options' | 'dropdownSelect'>, CollectionFilterInitialFetchTimingProps {
+    /**
+     * A collection state object to fetch the dropdown items.<br>
+     * A collection created using [useFilterCollection](./?path=/story/features-filter-hooks--usefiltercollection) or [useStaticListFilterCollection](./?path=/story/features-filter-hooks--usestaticlistfiltercollection)
+     * @external
+     */
+    collection: CollectionState<V, F>;
+    /**
+     * A function that returns a [ListItemSelectProps](https://www.docs.wixdesignsystem.com/?path=/story/components-form-dropdownlistitems--listitemselect) (Optional)
+     */
+    renderItem?: (item: V, index: number) => ListItem;
+    /**
+     * The maximum number of items that can be selected. Once reached, every
+     * unselected option becomes disabled (already-selected options stay
+     * deselectable). When undefined, selection is unbounded.
+     *
+     * Read once on mount — later changes to this prop are ignored. (Optional)
+     */
+    maxSelected?: number;
+}
+
+interface MultiSelectCheckboxFilterProps<V, F extends FiltersMap = FiltersMap> extends CollectionMultiSelectCheckboxProps<V, F> {
+}
+declare function _MultiSelectCheckboxFilter<V, F extends FiltersMap = FiltersMap>(props: MultiSelectCheckboxFilterProps<V, F>): React.JSX.Element;
+declare const MultiSelectCheckboxFilter: typeof _MultiSelectCheckboxFilter & {
+    displayName: string;
+};
+
+export { MultiSelectCheckboxFilter };
+export type { MultiSelectCheckboxFilterProps };

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

@@ -0,0 +1,105 @@
+import React from 'react';
+import { ListItemSelectSizes, MultiSelectProps, DropdownLayoutOption, TagProps } from '@wix/design-system';
+
+/**
+ * `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 KeyedItem<T> {
+    item: T;
+    key: string;
+    id: string;
+    pageIndex: number;
+    indexWithinPage: number;
+    index: number;
+}
+
+/**
+ * `DropdownSelectState` — you receive this, you don't construct it.
+ * An internal state object — reached through another state object, never built directly.
+ */
+declare class DropdownSelectState<V> {
+}
+
+interface ListItem {
+    className?: string;
+    checkbox?: boolean;
+    prefix?: React.ReactNode;
+    title?: string;
+    subtitle?: string;
+    suffix?: React.ReactNode;
+    selected?: boolean;
+    disabled?: boolean;
+    size?: ListItemSelectSizes;
+    ellipsis?: boolean;
+    dataHook?: string;
+    sectionId?: string;
+    label?: string;
+}
+
+interface CollectionFilterInitialFetchTimingProps {
+    /**
+     * At which point the initial fetch of the filter collection data takes place. If this prop is omitted, it will take place on component mount.<br> <br>
+     * Supported values: <br>
+     * - `focus`: On the first visitor interaction with the filter component.
+     * @default undefined - on component mount
+     * @external
+     */
+    initialFetchTiming?: 'focus';
+    collection: {
+        initialFetch: () => unknown;
+    };
+}
+
+/**
+ * `FilterProps` — cut here because it has its own bundle.
+ * Look `FilterProps` up in the bundle index for its full shape.
+ */
+interface FilterProps<V> {
+}
+
+type KeyedItemOption<T> = DropdownLayoutOption & {
+    keyedItem: KeyedItem<T>;
+};
+type MultiSelectFilterBaseOption<T> = KeyedItemOption<T> | DropdownLayoutOption;
+interface MultiSelectFilterBaseProps<V> extends Partial<MultiSelectProps>, FilterProps<V[]> {
+    filter: Filter<V[]>;
+    options: MultiSelectFilterBaseOption<V>[];
+    renderTag?: (item: V) => TagProps;
+    dropdownSelect: DropdownSelectState<V>;
+    placeholder?: string;
+}
+
+interface MultiSelectCollectionFilterProps<V, F extends FiltersMap> extends Omit<MultiSelectFilterBaseProps<V>, 'options' | 'dropdownSelect'>, CollectionFilterInitialFetchTimingProps {
+    /**
+     * A collection state object to fetch the dropdown items.<br>
+     * A collection created using [useFilterCollection](./?path=/story/features-filter-hooks--usefiltercollection) or [useStaticListFilterCollection](./?path=/story/features-filter-hooks--usestaticlistfiltercollection)
+     * @external
+     */
+    collection: CollectionState<V, F>;
+    /**
+     * A function that returns a [ListItemSelectProps](https://www.docs.wixdesignsystem.com/?path=/story/components-form-dropdownlistitems--listitemselect) (Optional)
+     * @external
+     */
+    renderItem?: (item: V, index: number) => ListItem;
+}
+declare function MultiSelectCollectionFilter<V, F extends FiltersMap>(props: MultiSelectCollectionFilterProps<V, F>): React.JSX.Element;
+declare namespace MultiSelectCollectionFilter {
+    var displayName: string;
+}
+
+export { MultiSelectCollectionFilter };
+export type { MultiSelectCollectionFilterProps };

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

@@ -0,0 +1,28 @@
+import React from 'react';
+
+/**
+ * `RangeItem` — cut here because it has its own bundle.
+ * Look `RangeItem` up in the bundle index for its full shape.
+ */
+interface RangeItem<T> {
+}
+
+/**
+ * `FilterProps` — cut here because it has its own bundle.
+ * Look `FilterProps` up in the bundle index for its full shape.
+ */
+interface FilterProps<V> {
+}
+
+interface NumberRangeFilterProps extends FilterProps<RangeItem<number>> {
+    decimal?: boolean;
+    min?: number;
+    max?: number;
+}
+declare function NumberRangeFilter({ filter, decimal, min, max, }: NumberRangeFilterProps): React.JSX.Element;
+declare const _default: typeof NumberRangeFilter & {
+    displayName: string;
+};
+
+export { _default as default };
+export type { NumberRangeFilterProps };

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

@@ -0,0 +1,70 @@
+import * as React from 'react';
+import React__default from 'react';
+
+/**
+ * `Translate` — cut here because it has its own bundle.
+ * Look `Translate` up in the bundle index for its full shape.
+ */
+type Translate = unknown;
+
+interface OperatorFilterValue<T> {
+    operator: FilterOperator;
+    value: T | null;
+}
+
+type FilterItem<T> = T extends (infer V)[] ? V : T;
+
+/**
+ * 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"
+}
+
+/**
+ * `FilterProps` — cut here because it has its own bundle.
+ * Look `FilterProps` up in the bundle index for its full shape.
+ */
+interface FilterProps<V> {
+}
+
+declare const renderOperatorFilterToolbarTag: (container: {
+    translate: Translate;
+}, params: {
+    filterProps: FilterProps<any>;
+}) => <T>(item: FilterItem<OperatorFilterValue<T>>) => {
+    children: React.FunctionComponentElement<{
+        filterProps: FilterProps<any>;
+    }>;
+};
+
+interface OperatorPickerProps<T> extends FilterProps<OperatorFilterValue<T>> {
+}
+declare function _OperatorFilterPicker<T>(props: OperatorPickerProps<T>): React__default.JSX.Element;
+declare const OperatorFilterPicker: typeof _OperatorFilterPicker & {
+    displayName?: string;
+    renderPresetToolbarTag?: typeof renderOperatorFilterToolbarTag;
+};
+
+export { OperatorFilterPicker };
+export type { OperatorPickerProps };

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

@@ -0,0 +1,20 @@
+import { PathRouteProps, LayoutRouteProps } from 'react-router-dom';
+
+type RouteType = 'collection' | 'createEntity' | 'editEntity' | 'other';
+interface RouteBaseProps {
+    /**
+     * Page type. Supported values: <br />
+     * - `"collection"` <br />
+     * - `"createEntity"` <br />
+     * - `"editEntity"` <br />
+     * - `"other"` <br />
+     * @external
+     */
+    type: RouteType;
+}
+
+type PatternsReactProps = (PathRouteProps | LayoutRouteProps) & RouteBaseProps;
+declare const PatternsReactRoute: (_props: PatternsReactProps) => null;
+
+export { PatternsReactRoute };
+export type { PatternsReactProps };

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

@@ -0,0 +1,7 @@
+import React from 'react';
+
+declare const PatternsReactRouter: ({ children, }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+
+export { PatternsReactRouter };

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

@@ -0,0 +1,49 @@
+import { CustomModalLayoutProps, ModalProps } from '@wix/design-system';
+import React, { ReactElement } from '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 MultipleSelection = boolean | number;
+
+/**
+ * `PickerModalState` — you receive this, you don't construct it.
+ * Produced by `usePickerModal()` (also `usePickerModalState()`).
+ */
+declare class PickerModalState<T, F> {
+}
+
+interface PickerModalProps<T, F extends FiltersMap = FiltersMap> extends Partial<CustomModalLayoutProps> {
+    /**
+     * Optional props to forward to `Modal` component
+     */
+    modalProps?: Partial<ModalProps>;
+    /** State object created with [`usePickerModal`](./?path=/story/base-components-collections-picker-hooks--usepickermodal) */
+    state: PickerModalState<T, F>;
+    /**
+     * A component to be rendered in the modal content when there's a failure fetching the data
+     * @param params
+     * @param params.err - The original failure error object
+     * @param params.isOnline - Indicates whether internet connection is available or not
+     */
+    renderError: (params: {
+        err: unknown;
+        isOnline: boolean;
+    }) => ReactElement;
+    /**
+     * Limits the number of items that can be selected.<br>
+     * Either a boolean or a number. A number indicates the maximum number of selections, `true` indicates no limit, `false` indicates only 1 item (radio button will be shown instead of checkboxes)
+     */
+    multiple?: MultipleSelection;
+}
+declare function PickerModal<T, F extends FiltersMap = FiltersMap>(props: PickerModalProps<T, F>): React.JSX.Element;
+
+export { PickerModal };
+export type { PickerModalProps };

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

@@ -0,0 +1,41 @@
+import React from 'react';
+import { ButtonProps } from '@wix/design-system';
+
+interface PrimaryActionButtonProps extends Omit<ButtonProps, 'size' | 'fullWidth' | 'dataHook' | 'skin' | 'as'> {
+    /**
+     * Callback that is called each time the button is clicked.
+     * @external
+     */
+    onClick?: any;
+}
+declare const PrimaryActionButton: React.ForwardRefExoticComponent<PrimaryActionButtonProps & React.RefAttributes<{
+    button: React.RefObject<HTMLButtonElement>;
+    focus: (options?: FocusOptions) => void;
+    getBoundingClientRect: () => DOMRect | undefined;
+    render(): React.JSX.Element;
+    context: any;
+    setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ButtonProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+    forceUpdate(callback?: (() => void) | undefined): void;
+    readonly props: Readonly<ButtonProps> & Readonly<{
+        children?: React.ReactNode | undefined;
+    }>;
+    state: Readonly<{}>;
+    refs: {
+        [key: string]: React.ReactInstance;
+    };
+    componentDidMount?(): void;
+    shouldComponentUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+    componentWillUnmount?(): void;
+    componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+    getSnapshotBeforeUpdate?(prevProps: Readonly<ButtonProps>, prevState: Readonly<{}>): any;
+    componentDidUpdate?(prevProps: Readonly<ButtonProps>, prevState: Readonly<{}>, snapshot?: any): void;
+    componentWillMount?(): void;
+    UNSAFE_componentWillMount?(): void;
+    componentWillReceiveProps?(nextProps: Readonly<ButtonProps>, nextContext: any): void;
+    UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ButtonProps>, nextContext: any): void;
+    componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
+    UNSAFE_componentWillUpdate?(nextProps: Readonly<ButtonProps>, nextState: Readonly<{}>, nextContext: any): void;
+}>>;
+
+export { PrimaryActionButton };
+export type { PrimaryActionButtonProps };

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

@@ -0,0 +1,13 @@
+import React, { ReactElement } from 'react';
+
+/**
+ * `ActionSubitem` — cut here because it has its own bundle.
+ * Look `ActionSubitem` up in the bundle index for its full shape.
+ */
+type ActionSubitem = unknown;
+
+type PrimaryActionsElement = ReactElement<ActionSubitem, typeof PrimaryActions>;
+declare function PrimaryActions({ subItems, ...props }: ActionSubitem): React.JSX.Element;
+
+export { PrimaryActions };
+export type { PrimaryActionsElement };

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

@@ -0,0 +1,21 @@
+import React, { ReactElement } from 'react';
+import { ButtonProps } from '@wix/design-system';
+
+interface PrimaryPageButtonBaseProps {
+    onClick: React.MouseEventHandler<HTMLButtonElement>;
+    /**
+     * The button content, defaults to "Create New"
+     * @external
+     */
+    text?: string;
+}
+type PrimaryPageButtonProps = PrimaryPageButtonBaseProps & Omit<ButtonProps, 'children' | 'onClick' | 'size' | 'skin'>;
+type PrimaryPageButtonElement = ReactElement<PrimaryPageButtonProps, typeof PrimaryPageButton>;
+/**
+ * @deprecated
+ * Use `PrimaryActions` component instead.
+ */
+declare function PrimaryPageButton({ onClick, text, prefixIcon, ...rest }: PrimaryPageButtonProps): React.JSX.Element;
+
+export { PrimaryPageButton };
+export type { PrimaryPageButtonElement, PrimaryPageButtonProps };