@bikdotai/bik-component-library 0.0.788-beta.8 → 0.0.788-beta.9

package/dist/esm/src/components/dropdown/type.d.ts

@@ -0,0 +1,90 @@
+/// <reference types="react" />
+import { Placement, PositioningStrategy } from '@popperjs/core';
+import { ButtonProps, Type } from '../button/model';
+export interface OpenDropdownProps {
+    defaultOptions?: DropdownOption[];
+    options: DropdownOption[];
+    isSearchable?: boolean;
+    error?: string;
+    isMultiSelect?: boolean;
+    maxSelections?: number;
+    dropdownWidth?: string;
+    width?: string;
+    height?: number | string;
+    allowFreeForm?: boolean;
+    onClose?: (selectedData?: DropdownOption | DropdownOption[]) => void;
+    onSelect?: (option: DropdownOption | DropdownOption[]) => void;
+    placement?: Placement;
+    strategy?: PositioningStrategy;
+    onSearch?: (key: string) => Promise<DropdownOption[]>;
+    version?: '1.0' | '2.0';
+    skipSorting?: boolean;
+    headerRef?: any;
+    hideSelectAll?: boolean;
+    primaryButtonText?: string;
+    onInfiniteScroll?: () => void;
+    onMultiSelectClear?: () => void;
+    onDropdownItemClick?: (option: DropdownOption) => void;
+    buttonOptions?: ButtonOptions;
+    isSearchLoading?: boolean;
+    isOptionsLoading?: boolean;
+    optionsErrorState?: {
+        Icon?: React.ReactNode;
+        IconHolderStyle?: React.CSSProperties;
+        actionButton?: ButtonProps;
+        buttonWidth?: number;
+        title?: string;
+        subTitle?: string;
+    };
+    disableSearchOptions?: boolean;
+    disableSearchedOptionExcept?: string[];
+    useDefaultCursor?: boolean;
+    'data-test'?: string;
+    containerStyle?: React.CSSProperties;
+    zeroState?: {
+        Icon?: React.ReactNode;
+        IconHolderStyle?: React.CSSProperties;
+        actionButton?: ButtonProps;
+        buttonWidth?: number;
+        title: string;
+        subTitle?: string;
+    };
+    /** Enable drag-and-drop reordering of options */
+    isDraggable?: boolean;
+    hideClearButton?: boolean;
+    /** Callback when options are reordered via drag-and-drop */
+    onOptionsReorder?: (reorderedOptions: DropdownOption[]) => void;
+    /** z-index of the dropdown popover. Defaults to 3. */
+    dropdownZIndex?: number;
+}
+export type GroupedOption = {
+    label?: string;
+    leadingIcon?: JSX.Element;
+    options: (SingleOption | MultiSelectOption)[];
+};
+export type SingleOption = {
+    label: string;
+    value: string;
+    description?: string | null;
+    selected?: boolean;
+    disabled?: boolean;
+    isFreeForm?: boolean;
+    subText?: string;
+    trailingIcon?: JSX.Element;
+    leadingIcon?: JSX.Element;
+    customComponent?: JSX.Element;
+    searchKey?: string;
+    selectedLabel?: string;
+    children?: SingleOption[];
+    parent?: SingleOption;
+    'data-test'?: string;
+};
+export type MultiSelectOption = SingleOption;
+export type DropdownOption = MultiSelectOption | SingleOption | GroupedOption;
+export interface ButtonOptions {
+    primaryButtonText?: string;
+    primaryButtonType?: Type;
+    secondaryButtonText?: string;
+    secondaryButtonType?: Type;
+}
+export type { Placement };

package/dist/esm/src/components/feature-announcements/types/feature.types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Firestore Timestamp type
+ */
+export interface FirestoreTimestamp {
+    seconds: number;
+    nanoseconds?: number;
+}
+/**
+ * Button styling configuration
+ */
+export interface ButtonStyle {
+    textColor?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+}
+/**
+ * Primary button configuration
+ */
+export interface ButtonConfig {
+    text?: string;
+    action?: 'Play Video' | 'Open link';
+    redirectionUrl?: string;
+    style?: ButtonStyle;
+}
+/**
+ * Secondary button configuration
+ */
+export interface SecondaryButtonConfig {
+    text?: string;
+    action?: 'Open link' | 'Close popup' | '';
+    redirectionUrl?: string;
+    style?: ButtonStyle;
+}
+/**
+ * Feature announcement data model
+ */
+export interface FeatureAnnouncement {
+    id: string;
+    title: string;
+    body: string;
+    content: string;
+    buttonText: string;
+    displayImage: string;
+    featureTag: string;
+    featureUpdateType: 'Major' | 'Minor';
+    image: string;
+    module: string[];
+    pageUrls: string[];
+    productVideo: string;
+    redirectUrl: string;
+    updates: string;
+    visibility: boolean;
+    archived?: boolean;
+    createdAt: FirestoreTimestamp;
+    expirationDate?: FirestoreTimestamp | string | Date;
+    showInFeed?: boolean;
+    primaryButton?: ButtonConfig;
+    secondaryButton?: SecondaryButtonConfig;
+    padding?: string;
+}
+/**
+ * Store feature progress tracking
+ */
+export interface StoreFeatureProgress {
+    storeId: string;
+    viewedFeatures: Record<string, boolean>;
+}
+/**
+ * Feature update types
+ */
+export type FeatureUpdateType = 'Major' | 'Minor';
+/**
+ * Announcement event data (for tracking when announcement is shown)
+ */
+export interface AnnouncementEvent {
+    storeId: string;
+    announcementId: string;
+    announcementTitle: string;
+    imageUrl?: string;
+    videoUrl?: string;
+}
+/**
+ * Announcement interaction event data (for tracking button clicks)
+ */
+export interface AnnouncementInteractionEvent extends AnnouncementEvent {
+    buttonClicked: 'Primary' | 'Secondary' | 'Skip';
+    buttonName: string;
+    buttonUrl?: string;
+}

package/dist/esm/src/components/floating-input-dropdown/FloatingInputDropdown.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { Placement } from "../tooltips";
+import { DropdownOption, OpenDropdownProps } from '../dropdown/type';
+import { FloaterProps } from '../floater/floater';
+import { InputProps } from '../input/Input.model';
+type DropdownProps = OpenDropdownProps & {
+    isLoading?: boolean;
+    children?: React.ReactNode;
+    disabled?: boolean;
+    onDropdownOpen?: () => void;
+    onDropdownVisbilityChange?: (isOpen: boolean) => void;
+    tooltipContent?: string;
+    tooltipDirection?: Placement;
+    showTooltipArrow?: boolean;
+};
+type FloatingInputDropdownProps = {
+    inputProps: InputProps;
+    dropdownProps: DropdownProps;
+    floaterProps: FloaterProps;
+    children?: React.ReactNode;
+    isVisible?: boolean;
+    onDropdownOptionClick?: (option: DropdownOption) => void;
+    onChangeText?: (text: string, event?: Event) => void;
+};
+export declare const FloatingInputDropdown: React.FC<FloatingInputDropdownProps>;
+export {};

package/dist/esm/src/components/image-cropper/BikImageCropper.d.ts

@@ -0,0 +1,4 @@
+import 'react-image-crop/dist/ReactCrop.css';
+import { BikImageCropperProps } from './BikImageCropper.model';
+export declare const BikImageCropper: (props: BikImageCropperProps) => import("react/jsx-runtime").JSX.Element;
+export default BikImageCropper;

package/dist/esm/src/components/image-cropper/BikImageCropper.model.d.ts

@@ -0,0 +1,6 @@
+export interface BikImageCropperProps {
+    aspectRatio?: number;
+    src: string;
+    onCropComplete: (base64String: string, didChange: boolean) => void | Promise<void>;
+    onCancel: () => void;
+}

package/dist/esm/src/components/image-cropper/BikImagePipeline/BikImagePipeline.d.ts

@@ -0,0 +1,33 @@
+import { CompressImageOptions } from "../../image-compress";
+import { BikImageCropperProps } from '../BikImageCropper.model';
+/**
+ * Todos
+ * 	- Add option to pass https url in the src / edit an image
+ */
+export interface BikImagePipelineProps {
+    fileTitle?: string;
+    cropOptions?: Partial<BikImageCropperProps>;
+    compressionOptions?: CompressImageOptions;
+    currentImage: {
+        src?: string;
+    };
+    options: {
+        upload: boolean;
+        crop?: boolean;
+        compress?: boolean;
+        uploadToFirestorage?: boolean;
+    };
+    onCancel: () => void;
+    onFinish: (base64String: string, file?: File, url?: string) => void;
+    fileUploadOptions?: {
+        path: string;
+        uploadProgress: number;
+        uploadFile: (file: File, path: string) => Promise<string>;
+        error?: string;
+        success?: boolean;
+    };
+    loadingStateOptions?: {
+        headerImage?: string;
+    };
+}
+export declare const BikImagePipeline: ({ cropOptions, fileTitle, compressionOptions, currentImage, options, onFinish, onCancel, fileUploadOptions, loadingStateOptions, }: BikImagePipelineProps) => import("react/jsx-runtime").JSX.Element;

package/dist/esm/src/components/input/ChipInput.styled.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const getChipStyle: () => React.CSSProperties;
+export declare const getChipRemoveStyle: () => React.CSSProperties;
+export declare const getContainerStyle: (error?: boolean, height?: number, chipsContainerCustomStyle?: React.CSSProperties, focused?: boolean) => React.CSSProperties;
+export declare const getContainerHoverStyle: () => React.CSSProperties;
+export declare const getInputStyle: (height?: number) => React.CSSProperties;

package/dist/esm/src/components/input/Input-helper.d.ts

@@ -0,0 +1,8 @@
+import { InputTypeI } from './Input.model';
+export declare const isFunction: (fn: any) => boolean;
+export declare const sanitizeUnsafeInput: (input: string) => string;
+export declare const shouldSanitizeForType: (type: InputTypeI) => boolean;
+export declare const validateInput: (inputText: string | number, type: InputTypeI, rangeValidation?: {
+    min?: number;
+    max?: number;
+}) => [boolean, string];

package/dist/esm/src/components/input/Input.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { InputProps } from './Input.model';
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement | HTMLTextAreaElement | null>>;

package/dist/esm/src/components/input/Input.model.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="react" />
+import { ButtonProps } from '../button/model';
+export type InputVariant = 'default' | 'small' | 'x-small';
+export type InputStateI = 'invalid' | 'active' | 'read-only' | 'disabled' | 'disabled-invalid' | 'none';
+export type InputTypeI = 'number' | 'email' | 'text' | 'multiline' | 'url' | 'zip' | 'phonenumber' | 'password';
+export interface InputProps {
+    'data-test'?: string;
+    noErrorHint?: boolean;
+    placeholder?: string;
+    variant?: InputVariant;
+    width?: string;
+    height?: string;
+    leftIcon?: {
+        icon: React.FC;
+        callback?: () => void;
+    };
+    rightIcon?: {
+        icon: React.FC;
+        callback?: () => void;
+    };
+    labelElement?: React.ReactNode;
+    labelText?: string;
+    maxCharLimit?: number;
+    isRequired?: boolean;
+    errorMessage?: string;
+    hintText?: string;
+    state?: InputStateI;
+    type?: InputTypeI;
+    /**
+        validate:  function takes the input and returns boolean + string (error message in case of invalid input)
+     **/
+    validate?: (input?: string | number) => [boolean, string];
+    onChangeText: (input: string, event?: Event) => void;
+    button?: {
+        text: string;
+        onClick?: () => void;
+        buttonProps?: ButtonProps;
+    };
+    suffixText?: string;
+    prefixText?: string;
+    value?: string;
+    reset?: boolean;
+    onBlur?: (e: any) => void;
+    onFocus?: (e: any) => void;
+    onClick?: (e: any) => void;
+    isActive?: boolean;
+    id?: string;
+    onReferenceInit?: (element: HTMLInputElement | HTMLTextAreaElement) => void;
+    rangeValidation?: {
+        min: number;
+        max: number;
+    };
+    noKeyDownChange?: boolean;
+    skipFocus?: boolean;
+    version?: '1.0' | '2.0';
+    textControl?: boolean;
+    noMaxCharCheck?: boolean;
+    tooltipText?: string;
+    autoGrow?: boolean;
+    minHeight?: string;
+    maxHeight?: string;
+    labelTextBold?: boolean;
+    truncateText?: boolean;
+    maxCharLimitPosition?: 'TOP' | 'BOTTOM';
+    hightlightInputColor?: string;
+    onKeyDownEvent?: (e: Event) => void;
+    hideInputHeader?: boolean;
+    hideBorder?: boolean;
+    inputWrapperStyles?: React.CSSProperties;
+    minCharsToTrigger?: number;
+    isDisabled?: boolean;
+    allowUnsafeInput?: boolean;
+}

package/dist/esm/src/components/input/Input.styled.d.ts

@@ -0,0 +1,128 @@
+/// <reference types="react" />
+import { InputStateI, InputTypeI, InputVariant } from './Input.model';
+export declare const InputWrapper: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+} & {
+    width?: string | undefined;
+    height?: string | undefined;
+    isActive?: boolean | undefined;
+    isInvalid?: boolean | undefined;
+    state?: InputStateI | undefined;
+    variant?: InputVariant | undefined;
+    version?: "1.0" | "2.0" | undefined;
+    hightlightInputColor?: string | undefined;
+    hideBorder?: boolean | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const IconHolder: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+} & {
+    isLeft?: boolean | undefined;
+    iconSize?: string | undefined;
+    variant?: InputVariant | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const InputContainer: import("@emotion/styled").StyledComponent<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & {
+    theme?: any;
+} & {
+    as?: string | import("react").ComponentType<any> | undefined;
+    forwardedAs?: string | import("react").ComponentType<any> | undefined;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    height?: string | undefined;
+    type?: InputTypeI | undefined;
+    autoGrow?: boolean | undefined;
+    minHeight?: string | undefined;
+    maxHeight?: string | undefined;
+}, {}, {}>;
+export declare const InputContainerSmall: import("@emotion/styled").StyledComponent<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & {
+    theme?: any;
+} & {
+    as?: string | import("react").ComponentType<any> | undefined;
+    forwardedAs?: string | import("react").ComponentType<any> | undefined;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    height?: string | undefined;
+    type?: InputTypeI | undefined;
+}, {}, {}>;
+export declare const InputHeader: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+} & {
+    invalid?: boolean | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const MaxCharStyle: import("@emotion/styled").StyledComponent<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & {
+    theme?: any;
+} & {
+    as?: string | import("react").ComponentType<any> | undefined;
+    forwardedAs?: string | import("react").ComponentType<any> | undefined;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    position?: string | undefined;
+}, {}, {}>;
+export declare const InputFooter: import("@emotion/styled").StyledComponent<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & {
+    theme?: any;
+} & {
+    as?: string | import("react").ComponentType<any> | undefined;
+    forwardedAs?: string | import("react").ComponentType<any> | undefined;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    invalid?: boolean | undefined;
+}, {}, {}>;
+export declare const RootContainer: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+} & {
+    width?: string | undefined;
+    height?: string | undefined;
+    state?: InputStateI | undefined;
+    type: InputTypeI;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const PrefixHolder: import("@emotion/styled").StyledComponent<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & {
+    theme?: any;
+} & {
+    as?: string | import("react").ComponentType<any> | undefined;
+    forwardedAs?: string | import("react").ComponentType<any> | undefined;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    variant?: InputVariant | undefined;
+}, {}, {}>;
+export declare const SuffixHolder: import("@emotion/styled").StyledComponent<{
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+} & {
+    theme?: any;
+} & {
+    as?: string | import("react").ComponentType<any> | undefined;
+    forwardedAs?: string | import("react").ComponentType<any> | undefined;
+} & {
+    theme?: import("@emotion/react").Theme | undefined;
+} & {
+    variant?: InputVariant | undefined;
+}, {}, {}>;

package/dist/esm/src/components/input-with-vars/InputWithVariables.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import { Variable } from '../add-variableV2/AddVariableV2';
+import { SelectedVariable } from '../add-variableV2/types';
+import { InputTypeI } from '../input/Input.model';
+import { PickerType } from '../variable-picker-v3/model';
+export interface InputWithVariablesProps {
+    type?: InputTypeI;
+    variablesList: any;
+    onChange: (val: SelectedVariable) => void;
+    onBlur?: (e: Event, val?: SelectedVariable | Variable) => void;
+    allowMix: boolean;
+    prevVariable: SelectedVariable;
+    showHelp?: boolean;
+    onlyVariables?: boolean;
+    placeHolder?: string;
+    showAddButton?: boolean;
+    errorMessage?: string;
+    noMaxCharCheck?: boolean;
+    maxCharLimit?: number;
+    labelText?: string;
+    labelElement?: React.ReactNode;
+    isRequired?: boolean;
+    hintText?: string;
+    onEnterPress?: (input: string) => void;
+    pickerType?: PickerType;
+    portalElement?: HTMLElement;
+    showVarHeader?: boolean;
+    varHeaderText?: string;
+    onPickerToggle?: (isOpen: boolean) => void;
+}
+export declare const InputWithVariables: React.FC<InputWithVariablesProps>;

package/dist/esm/src/components/list-item/List.model.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+export type Variant = 'default' | 'selected' | 'inactive' | 'error' | 'readonly' | 'placeholder' | 'separator';
+export interface ListItemElement {
+    label: string;
+    value: string;
+}
+export interface ListItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    variant?: Variant;
+    subText?: string;
+    listItem: ListItemElement;
+    onSelect?: (ListItemElement: any) => void;
+    leadingIcon?: JSX.Element;
+    trailingIcon?: JSX.Element;
+    borderBottom?: string;
+    customComponent?: JSX.Element;
+    customListItemLabel?: JSX.Element;
+    version?: '1.0' | '2.0';
+}

package/dist/esm/src/components/list-item/ListItem.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { ListItemProps } from './List.model';
+export declare const ListItem: import("react").ForwardRefExoticComponent<ListItemProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/esm/src/components/list-item/ListItem.styled.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { Variant } from './List.model';
+export declare const ListItem: import("@emotion/styled").StyledComponent<{
+    theme?: import("@emotion/react").Theme | undefined;
+    as?: import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> | undefined;
+} & {
+    variant: Variant;
+    borderBottom?: string | undefined;
+    version?: "1.0" | "2.0" | undefined;
+}, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/esm/src/components/list-item/themes.d.ts

@@ -0,0 +1,3 @@
+import type { Variant } from './List.model';
+export declare function getColor(variant: Variant): string;
+export declare function getTheme(variant: Variant, version?: '1.0' | '2.0'): import("@emotion/utils").SerializedStyles;

package/dist/esm/src/components/multi-level-dropdown/GroupedMenuList.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { GroupedOption, MultiLevelDropdownOption, RenderNestedMenu } from './type';
+export declare const GroupedMenuList: React.FC<{
+    width: string;
+    onDropdownItemClick?: (option: MultiLevelDropdownOption, parents: MultiLevelDropdownOption[]) => void;
+    option: GroupedOption;
+    parents: MultiLevelDropdownOption[];
+    allowParentSelection?: boolean;
+    maxLevels?: number;
+    hideGroupLabel?: boolean;
+    currentLevel: number;
+    renderNestedMenu: RenderNestedMenu;
+}>;

package/dist/esm/src/components/multi-level-dropdown/MenuItem.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { MultiLevelDropdownOption, RenderNestedMenu, SingleOption } from './type';
+export declare const MenuItem: React.FC<{
+    width: string;
+    onDropdownItemClick?: (option: MultiLevelDropdownOption, parents: MultiLevelDropdownOption[]) => void;
+    option: SingleOption;
+    parents: MultiLevelDropdownOption[];
+    allowParentSelection?: boolean;
+    maxLevels?: number;
+    currentLevel: number;
+    renderNestedMenu: RenderNestedMenu;
+}>;

package/dist/esm/src/components/multi-level-dropdown/MenuList.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { MultiLevelDropdownOption } from './type';
+export declare const MenuList: React.FC<{
+    width: string;
+    onDropdownItemClick?: (option: MultiLevelDropdownOption, parents: MultiLevelDropdownOption[]) => void;
+    options: MultiLevelDropdownOption[];
+    parents: MultiLevelDropdownOption[];
+    allowParentSelection?: boolean;
+    maxLevels?: number;
+    hideGroupLabel?: boolean;
+    currentLevel: number;
+}>;

package/dist/esm/src/components/multi-level-dropdown/type.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+import { FloaterProps } from '../floater/floater';
+export interface MultiLevelDropdownProps extends FloaterProps {
+    options: MultiLevelDropdownOption[];
+    width?: string;
+    isSearchable?: boolean;
+    isDropdownOpen?: boolean;
+    allowParentSelection?: boolean;
+    maxLevels?: number;
+    hideGroupLabel?: boolean;
+    onDropdownOutsideClick?: (isOutsideClick: any) => void;
+    onDropdownItemClick?: (option: MultiLevelDropdownOption, parents: MultiLevelDropdownOption[]) => void;
+}
+export type GroupedOption = {
+    label: string;
+    options: SingleOption[];
+    trailingIcon?: JSX.Element;
+    leadingIcon?: JSX.Element;
+};
+export type SingleOption = {
+    label: string;
+    value: string;
+    subText?: string;
+    trailingIcon?: JSX.Element;
+    leadingIcon?: JSX.Element;
+    customComponent?: JSX.Element;
+    disabled?: boolean;
+    selected?: boolean;
+    children?: SingleOption[];
+};
+export type MultiLevelDropdownOption = SingleOption | GroupedOption;
+export type RenderNestedMenu = (options: MultiLevelDropdownOption[], parents: MultiLevelDropdownOption[], currentLevel: number) => ReactNode;

package/dist/esm/src/components/product-picker-v2/ProductPickerTag.d.ts

@@ -0,0 +1,22 @@
+import type { TagType } from '../tag/model';
+import type { Product, ProductVariant } from './type';
+export type ProductPickerTagType = {
+    isVariant: boolean;
+    data: Product | ProductVariant;
+    tagText?: string;
+    tagType?: TagType;
+};
+/**
+ * Used in Product Screen, Search Screen, Selected Screen and Rearrange Screen.
+ * Wherever product card is shown, we use this component.
+ *
+ * New logic: When product has only one variant and variant name is same as product name,
+ * we consider that a variant and do operations as variant.
+ *
+ * The logic for showing tag is moved to ProductHelper.tsx.
+ *
+ * Note: If there is no Fb rejected tag in the variant, we show a shimmer,
+ * meanwhile hit the API to get FB status.
+ *
+ */
+export declare const ProductPickerTag: (props: ProductPickerTagType) => import("react/jsx-runtime").JSX.Element;