@wix/patterns 1.456.0 → 1.458.0

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 };

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

@@ -0,0 +1,29 @@
+import React, { PropsWithChildren } from 'react';
+import { RadioProps } 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 RadioGroupFilterProps<V> extends FilterProps<V[]> {
+    /**
+     * List of items to select from
+     * @external
+     */
+    data: V[];
+    /**
+     * A function that returns Radio props for rendering each item
+     * @external
+     */
+    renderItem?: (item: V, index: number) => Partial<PropsWithChildren<RadioProps>>;
+}
+declare function _RadioGroupFilter<V>(props: RadioGroupFilterProps<V>): React.JSX.Element;
+declare const RadioGroupFilter: typeof _RadioGroupFilter & {
+    displayName: string;
+};
+
+export { RadioGroupFilter };
+export type { RadioGroupFilterProps };

package/dist/dts-bundle/components/SecondaryActions.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 SecondaryActionsElement = ReactElement<ActionSubitem, typeof SecondaryActions>;
+declare function SecondaryActions({ subItems, ...props }: ActionSubitem): React.JSX.Element;
+
+export { SecondaryActions };
+export type { SecondaryActionsElement };

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

@@ -0,0 +1,262 @@
+import * as React from 'react';
+import React__default, { ReactElement, ReactNode } from 'react';
+import { CardProps, IconElement, Breadcrumbs, BadgeProps, PageProps } from '@wix/design-system';
+import { FieldValues } from 'react-hook-form';
+
+interface ErrorCardProps extends CardProps {
+    /**
+     * Title to display in the error state.
+     */
+    title?: string;
+    /**
+     * Subtitle to display in the error state.
+     */
+    subtitle?: string;
+    /**
+     * Action button to display in the error state.
+     */
+    action?: {
+        /**
+         * Action button text.
+         */
+        text: string;
+        /**
+         * Callback function to run when the action button is clicked.
+         */
+        onClick: () => void;
+        /**
+         * [Icon](https://www.docs.wixdesignsystem.com/?path=/story/foundations-icons--icons) to display on the action button before the text.
+         */
+        prefixIcon?: IconElement;
+    };
+}
+
+interface CardContainerProps extends CardProps {
+    /**
+     * Additional loading flag, if you need to show loader after the main entity is fetched.
+     * Also, if an error occurs on a side request (other than passed to `fetch`), you can use `error` to show the card error state.
+     * Alongside with `error` you also need to pass `errorState.onRetry` callback, which should change the `status` accordingly.
+     */
+    status?: 'idle' | 'loading' | 'error' | 'success';
+    /**
+     * Height of content while loading (not including paddings)
+     */
+    minHeight?: string;
+    /**
+     * Card Error State configuration
+     */
+    errorState?: ErrorCardProps;
+    /**
+     * Identifier of the card.
+     * If you want to open a page and auto-scroll and focus ont his card, pass in the the query params `anchor={yourCardId}`.
+     */
+    id?: string;
+}
+
+interface FormPageCardProps extends CardContainerProps {
+}
+
+interface SettingsPageCardProps extends FormPageCardProps {
+}
+declare function _SettingsPageCard(props: SettingsPageCardProps): React__default.JSX.Element;
+declare namespace _SettingsPageCard {
+    var displayName: string;
+}
+
+/**
+ * `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 {
+}
+
+/**
+ * `MoreActionsItem` — cut here because it has its own bundle.
+ * Look `MoreActionsItem` up in the bundle index for its full shape.
+ */
+interface MoreActionsItem {
+}
+
+interface ExploreAppsModalProps {
+    title: string;
+    subtitle: string;
+    tag: string;
+}
+
+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;
+}
+
+type MoreActionItemFactory = (params: {
+    pageState: CollectionPageState;
+    container: WixPatternsContainer;
+}) => MoreActionsItem;
+type MoreActionsPropItem = MoreActionsItem | MoreActionItemFactory;
+
+interface MoreActionsIconProps extends MoreActionsProps {
+}
+declare function _MoreActionsIcon(params: MoreActionsIconProps): React__default.JSX.Element;
+declare const MoreActionsIcon: typeof _MoreActionsIcon & {
+    displayName: string;
+};
+
+type MoreActionsElement = ReactElement<MoreActionsProps, typeof MoreActionsIcon>;
+
+/**
+ * Props for the PageSubTitle component.
+ * @property {string} text The subtitle text.
+ * @property {Object} [learnMore] An object with a `url` (required) for displaying a link button on the subtitle.
+ * @property {string} learnMore.url where the link should navigate to
+ * @property {string} [learnMore.label ="Learn more"] - the label of the link button. defaults to "Learn More"
+ */
+interface PageSubTitleProps {
+    text: string;
+    learnMore?: {
+        url: string;
+        label?: string;
+    };
+}
+
+interface FormPageHeaderProps {
+    /**
+     * <MoreActions />
+     */
+    moreActions?: MoreActionsElement;
+    /**
+     * Page breadcrumbs
+     */
+    breadcrumbs?: ReactElement<Breadcrumbs>;
+    /**
+     * Page title text and optional badges
+     */
+    title: {
+        text: string;
+        badges?: (Pick<BadgeProps, 'skin' | 'prefixIcon' | 'suffixIcon'> & {
+            text: string;
+        })[];
+    };
+    /**
+     * Page subtitle text
+     */
+    subtitle?: PageSubTitleProps;
+}
+
+interface FormPageMainContentProps {
+    /**
+     * Applies a data-hook HTML attribute that can be used in tests
+     */
+    dataHook?: string;
+    children?: ReactNode;
+}
+
+interface FormPageAdditionalContentProps {
+    /**
+     * Applies a data-hook HTML attribute that can be used in tests
+     */
+    dataHook?: string;
+    children?: ReactNode;
+    /**
+     * Makes the additional content sticky when scrolling
+     */
+    sticky?: boolean;
+}
+
+/**
+ * `SettingsPageState` — you receive this, you don't construct it.
+ * Produced by `useSettingsPage()` (also `useSettingsPageContext()`).
+ */
+declare class SettingsPageState<T, V> {
+}
+
+declare function useSettingsPageHeader(child: SettingsPageHeaderElement): React__default.JSX.Element;
+
+interface SettingsPageHeaderProps extends FormPageHeaderProps {
+}
+type SettingsPageHeaderElement = ReactElement<SettingsPageHeaderProps, typeof SettingsPageHeader>;
+declare function SettingsPageHeader(_props: SettingsPageHeaderProps): null;
+declare namespace SettingsPageHeader {
+    var useSettingsPageHeader: typeof useSettingsPageHeader;
+    var displayName: string;
+}
+
+declare function useSettingsPageContent(child: SettingsPageContentElement, scrollableRef?: HTMLElement | null): React.JSX.Element;
+
+interface SettingsPageContentProps {
+    /**
+     * <SettingsPage.MainContent> and, if needed, <Settings.AdditionalContent> elements
+     */
+    children: ReactNode;
+}
+type SettingsPageContentElement = ReactElement<SettingsPageContentProps, typeof SettingsPageContent>;
+declare function SettingsPageContent(_props: SettingsPageContentProps): null;
+declare namespace SettingsPageContent {
+    var useSettingsPageContent: typeof useSettingsPageContent;
+    var displayName: string;
+}
+
+interface SettingsPageMainContentProps extends FormPageMainContentProps {
+}
+declare function SettingsPageMainContent(props: SettingsPageMainContentProps): React__default.JSX.Element;
+declare namespace SettingsPageMainContent {
+    var displayName: string;
+}
+
+interface SettingsPageAdditionalContentProps extends FormPageAdditionalContentProps {
+}
+declare function SettingsPageAdditionalContent(props: SettingsPageAdditionalContentProps): React__default.JSX.Element;
+declare namespace SettingsPageAdditionalContent {
+    var displayName: string;
+}
+
+interface SettingsPageProps<T, V extends FieldValues = FieldValues> extends PageProps {
+    /**
+     * SettingsPageState instance created with the `useSettingsPage` hook
+     */
+    state: SettingsPageState<T, V>;
+}
+declare function _SettingsPage<T, V extends FieldValues = FieldValues>({ state, ...rest }: SettingsPageProps<T, V>): React__default.JSX.Element;
+declare namespace _SettingsPage {
+    var Header: typeof SettingsPageHeader;
+    var Content: typeof SettingsPageContent;
+    var MainContent: typeof SettingsPageMainContent;
+    var AdditionalContent: typeof SettingsPageAdditionalContent;
+    var Card: typeof _SettingsPageCard & {
+        displayName: string;
+    };
+    var displayName: string;
+}
+declare const SettingsPage: typeof _SettingsPage & {
+    displayName: string;
+};
+
+export { SettingsPage };
+export type { SettingsPageProps };

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

@@ -0,0 +1,107 @@
+import React from 'react';
+import { ListItemSelectSizes, listItemSectionBuilder, DropdownPropsControlled } from '@wix/design-system';
+import { DropdownLayoutOption } from '@wix/design-system/dist/types/DropdownLayout';
+
+/**
+ * `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;
+};
+
+/**
+ * `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;
+}
+
+type DropdownLayoutOptionWithSectionId = DropdownLayoutOption & {
+    sectionId?: string;
+};
+interface BuildSectionOptionsArgs {
+    readonly items: DropdownLayoutOptionWithSectionId[];
+    readonly renderSection?: (sectionId: string) => Parameters<typeof listItemSectionBuilder>[0];
+}
+
+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> {
+}
+
+interface SingleSelectFilterBaseProps<V> extends Omit<Partial<DropdownPropsControlled>, 'onClear'>, FilterProps<V[]> {
+    filter: Filter<V[]>;
+    renderItem?: (item: V, index: number) => ListItem;
+    renderSection?: BuildSectionOptionsArgs['renderSection'];
+    dropdownSelect: DropdownSelectState<V>;
+    placeholder?: string;
+}
+
+interface SingleSelectFilterProps<V, F extends FiltersMap> extends Omit<SingleSelectFilterBaseProps<V>, 'keyedItems' | 'options' | 'dropdownSelect'>, CollectionFilterInitialFetchTimingProps {
+    /**
+     * Collection state object to fetch the items for the dropdown list.<br>
+     * Create 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) extended by `{sectionId?: string}`<br/>
+     * (Optional)
+     * @external
+     */
+    renderItem?: (item: V, index: number) => ListItem;
+    /**
+     * A function that returns  [ListItemSectionProps](https://www.docs.wixdesignsystem.com/?path=/story/components-form-dropdownlistitems--listitemsection) <br/>
+     * According to make it works you need return `sectionId` in `renderItem` method. <br/>
+     * ⚠️ Server should return section items sorted by sections in strict order. Otherwise, when using infinite scrolling the behavior of the sections will be unexpected (see sections example). <br/>
+     * (Optional)
+     * @external
+     */
+    renderSection?: SingleSelectFilterBaseProps<V>['renderSection'];
+}
+declare function SingleSelectFilter<V, F extends FiltersMap>(props: SingleSelectFilterProps<V, F>): React.JSX.Element;
+
+export { SingleSelectFilter };
+export type { SingleSelectFilterProps };

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

@@ -0,0 +1,37 @@
+import React from 'react';
+
+interface SummaryItem {
+    title: string;
+    value: string;
+}
+type SummaryBarStatus = 'loading' | 'error' | 'success';
+type SummaryData = SummaryItem[];
+interface SummaryBarProps {
+    /**
+     * Data to display in the summary bar.
+     * @external
+     */
+    data: SummaryData;
+    /**
+     * Summary bar status.
+     * <br><br>
+     * Supported values:<br>
+     * - `"success"`<br>
+     * - `"loading"`<br>
+     * - `"error"`
+     * @external
+     * @default success
+     */
+    status: SummaryBarStatus;
+    /**
+     * Function that is called every time **Reload** is clicked.
+     * @external
+     */
+    onRetry: () => void | Promise<void>;
+}
+declare const SummaryBar: ((props: SummaryBarProps) => React.JSX.Element) & {
+    displayName: string;
+};
+
+export { SummaryBar };
+export type { SummaryBarProps, SummaryBarStatus, SummaryData, SummaryItem };