@juspay/blend-design-system 0.0.36-beta.2 → 0.0.36

package/dist/components/MultiSelectV2/MobileMultiSelectV2.d.ts

@@ -0,0 +1 @@
+export { default } from './mobile/MobileMultiSelectV2';

package/dist/components/MultiSelectV2/MultiSelectV2.d.ts

@@ -0,0 +1,6 @@
+import { MultiSelectV2Props } from './multiSelectV2.types';
+declare const MultiSelectV2: {
+    ({ selectedValues, onChange, items, label, subLabel, helpIconText, required, variant, selectionTagType, slot, hintText, placeholder, size, search, enableSelectAll, selectAllText, maxSelections, customTrigger, usePanelOnMobile, triggerDimensions, menuDimensions, menuPosition, inline, error, showActionButtons, primaryAction, secondaryAction, showItemDividers, showHeaderBorder, enableVirtualization, virtualListItemHeight, virtualListOverscan, onEndReached, endReachedThreshold, hasMore, loadingComponent, skeleton, allowCustomValue, customValueLabel, showClearButton, onClearAllClick, onOpenChange, multiSelectGroupPosition, ...rest }: MultiSelectV2Props): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2;

package/dist/components/MultiSelectV2/MultiSelectV2Menu.d.ts

@@ -0,0 +1,6 @@
+import { MultiSelectV2MenuProps } from './multiSelectV2.types';
+declare const MultiSelectV2Menu: {
+    ({ items, selected, onSelect, trigger, menuDimensions, disabled, search, enableSelectAll, selectAllText, maxSelections, onSelectAll, menuPosition, collisionBoundary, open, onOpenChange, showActionButtons, primaryAction, secondaryAction, enableVirtualization, virtualListItemHeight, virtualListOverscan, onEndReached, endReachedThreshold, hasMore, skeleton, size, variant, allowCustomValue, customValueLabel, menuId, }: MultiSelectV2MenuProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2Menu;

package/dist/components/MultiSelectV2/MultiSelectV2MenuActions.d.ts

@@ -0,0 +1,23 @@
+import { MultiSelectV2TokensType } from './multiSelectV2.tokens';
+export type MultiSelectV2MenuActionsProps = {
+    tokens: MultiSelectV2TokensType;
+    primaryAction?: {
+        text: string;
+        onClick: (selectedValues: string[]) => void;
+        disabled?: boolean;
+        loading?: boolean;
+    };
+    secondaryAction?: {
+        text: string;
+        onClick: () => void;
+        disabled?: boolean;
+        loading?: boolean;
+    };
+    selected: string[];
+    onClose: () => void;
+};
+declare const MultiSelectV2MenuActions: {
+    ({ tokens, primaryAction, secondaryAction, selected, onClose, }: MultiSelectV2MenuActionsProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2MenuActions;

package/dist/components/MultiSelectV2/MultiSelectV2MenuHeader.d.ts

@@ -0,0 +1,25 @@
+import { default as React } from 'react';
+import { MultiSelectV2TokensType } from './multiSelectV2.tokens';
+import { MultiSelectV2GroupType } from './multiSelectV2.types';
+export type MultiSelectV2MenuHeaderProps = {
+    tokens: MultiSelectV2TokensType;
+    showSearch: boolean;
+    itemsCount: number;
+    searchValue: string;
+    searchPlaceholder?: string;
+    searchInputRef: React.RefObject<HTMLInputElement | null>;
+    onSearchChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onSearchArrowKeyToFirst: () => void;
+    showSelectAll: boolean;
+    selected: string[];
+    availableValues: string[];
+    filteredItems: MultiSelectV2GroupType[];
+    onSelectAll?: (selectAll: boolean, filteredItems: MultiSelectV2GroupType[]) => void;
+    selectAllText?: string;
+    disabled?: boolean;
+};
+declare const MultiSelectV2MenuHeader: {
+    ({ tokens, showSearch, itemsCount, searchValue, searchPlaceholder, searchInputRef, onSearchChange, onSearchArrowKeyToFirst, showSelectAll, selected, availableValues, filteredItems, onSelectAll, selectAllText, disabled, }: MultiSelectV2MenuHeaderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2MenuHeader;

package/dist/components/MultiSelectV2/MultiSelectV2MenuItem.d.ts

@@ -0,0 +1,11 @@
+import { MultiSelectV2ItemType } from './multiSelectV2.types';
+type MultiSelectV2MenuItemProps = {
+    item: MultiSelectV2ItemType;
+    onSelect: (value: string) => void;
+    selected: string[];
+    maxSelections?: number;
+    allItems?: MultiSelectV2ItemType[];
+    index?: number;
+};
+declare const MultiSelectV2MenuItem: ({ item, onSelect, selected, maxSelections, allItems, index, }: MultiSelectV2MenuItemProps) => import("react/jsx-runtime").JSX.Element;
+export default MultiSelectV2MenuItem;

package/dist/components/MultiSelectV2/MultiSelectV2MenuItems.d.ts

@@ -0,0 +1,17 @@
+import { MultiSelectV2TokensType } from './multiSelectV2.tokens';
+import { MultiSelectV2Size, MultiSelectV2Variant, MultiSelectV2GroupType, MultiSelectV2ItemType } from './multiSelectV2.types';
+export type MultiSelectV2MenuItemsProps = {
+    filteredItems: MultiSelectV2GroupType[];
+    allItemsFlat: MultiSelectV2ItemType[];
+    selected: string[];
+    onSelect: (value: string) => void;
+    maxSelections?: number;
+    tokens: MultiSelectV2TokensType;
+    size: MultiSelectV2Size;
+    variant: MultiSelectV2Variant;
+};
+declare const MultiSelectV2MenuItems: {
+    ({ filteredItems, allItemsFlat, selected, onSelect, maxSelections, tokens, size, variant, }: MultiSelectV2MenuItemsProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2MenuItems;

package/dist/components/MultiSelectV2/MultiSelectV2MenuSearch.d.ts

@@ -0,0 +1,14 @@
+import { default as React, RefObject } from 'react';
+export type MultiSelectV2MenuSearchProps = {
+    inputRef: RefObject<HTMLInputElement | null>;
+    value: string;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    placeholder?: string;
+    ariaLabel?: string;
+    onArrowKeyToFirstOption?: () => void;
+};
+declare const MultiSelectV2MenuSearch: {
+    ({ inputRef, value, onChange, placeholder, ariaLabel, onArrowKeyToFirstOption, }: MultiSelectV2MenuSearchProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2MenuSearch;

package/dist/components/MultiSelectV2/MultiSelectV2MenuVirtualList.d.ts

@@ -0,0 +1,22 @@
+import { MultiSelectV2TokensType } from './multiSelectV2.tokens';
+import { FlattenedMultiSelectV2Item, MultiSelectV2ItemType } from './multiSelectV2.types';
+export type MultiSelectV2MenuVirtualListProps = {
+    flattenedItems: FlattenedMultiSelectV2Item[];
+    itemIndexMap: Map<string, number>;
+    allItemsFlat: MultiSelectV2ItemType[];
+    selected: string[];
+    onSelect: (value: string) => void;
+    maxSelections?: number;
+    tokens: MultiSelectV2TokensType;
+    height: number;
+    itemHeight: number;
+    overscan?: number;
+    onEndReached?: () => void;
+    endReachedThreshold?: number;
+    hasMore?: boolean;
+};
+declare const MultiSelectV2MenuVirtualList: {
+    ({ flattenedItems, itemIndexMap, allItemsFlat, selected, onSelect, maxSelections, tokens, height, itemHeight, overscan, onEndReached, endReachedThreshold, hasMore, }: MultiSelectV2MenuVirtualListProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2MenuVirtualList;

package/dist/components/MultiSelectV2/MultiSelectV2SelectAllItem.d.ts

@@ -0,0 +1,9 @@
+type MultiSelectV2SelectAllItemProps = {
+    selected: string[];
+    availableValues: string[];
+    onSelectAll: (selectAll: boolean) => void;
+    selectAllText: string;
+    disabled?: boolean;
+};
+declare const MultiSelectV2SelectAllItem: ({ selected, availableValues, onSelectAll, selectAllText, disabled, }: MultiSelectV2SelectAllItemProps) => import("react/jsx-runtime").JSX.Element;
+export default MultiSelectV2SelectAllItem;

package/dist/components/MultiSelectV2/MultiSelectV2Skeleton.d.ts

@@ -0,0 +1,8 @@
+import { MultiSelectV2TokensType } from './multiSelectV2.tokens';
+import { SelectV2SkeletonProps } from '../SelectV2/selectV2.shared.types';
+export type MultiSelectV2SkeletonComponentProps = {
+    multiSelectTokens: MultiSelectV2TokensType;
+    skeleton: SelectV2SkeletonProps;
+};
+declare const MultiSelectV2Skeleton: import('react').ForwardRefExoticComponent<MultiSelectV2SkeletonComponentProps & import('react').RefAttributes<HTMLDivElement>>;
+export default MultiSelectV2Skeleton;

package/dist/components/MultiSelectV2/MultiSelectV2SubMenu.d.ts

@@ -0,0 +1,9 @@
+import { MultiSelectV2ItemType } from './multiSelectV2.types';
+type MultiSelectV2SubMenuProps = {
+    item: MultiSelectV2ItemType;
+    onSelect: (value: string) => void;
+    selected: string[];
+    maxSelections?: number;
+};
+declare const MultiSelectV2SubMenu: ({ item, onSelect, selected, maxSelections, }: MultiSelectV2SubMenuProps) => import("react/jsx-runtime").JSX.Element;
+export default MultiSelectV2SubMenu;

package/dist/components/MultiSelectV2/MultiSelectV2Trigger.d.ts

@@ -0,0 +1,30 @@
+import { default as React } from 'react';
+import { MultiSelectV2SelectionTagType, MultiSelectV2Size, MultiSelectV2Variant, SelectV2TriggerDimensions } from './multiSelectV2.types';
+import { MultiSelectV2TokensType } from './multiSelectV2.tokens';
+export type MultiSelectV2TriggerProps = {
+    selectedValues: string[];
+    slot?: React.ReactNode;
+    variant: MultiSelectV2Variant;
+    size: MultiSelectV2Size;
+    isSmallScreen: boolean;
+    name: string;
+    label: string;
+    placeholder: string;
+    required: boolean;
+    selectionTagType: MultiSelectV2SelectionTagType;
+    valueLabelMap: Record<string, string>;
+    open: boolean;
+    multiSelectTokens: MultiSelectV2TokensType;
+    inline?: boolean;
+    error?: boolean;
+    disabled?: boolean;
+    triggerDimensions?: SelectV2TriggerDimensions;
+    borderRadius: string;
+    borderRight?: string;
+    [key: string]: unknown;
+};
+declare const MultiSelectV2Trigger: {
+    ({ selectedValues, slot, variant, size, isSmallScreen, name, label, placeholder, required, selectionTagType, valueLabelMap, open, multiSelectTokens, inline, error, disabled, triggerDimensions, borderRadius, borderRight, ...rest }: MultiSelectV2TriggerProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export default MultiSelectV2Trigger;

package/dist/components/MultiSelectV2/index.d.ts

@@ -0,0 +1,14 @@
+export { default as MultiSelectV2 } from './MultiSelectV2';
+export { default as MultiSelectV2Skeleton } from './MultiSelectV2Skeleton';
+export { default as MultiSelectV2Menu } from './MultiSelectV2Menu';
+export { default as MultiSelectV2MenuHeader } from './MultiSelectV2MenuHeader';
+export { default as MultiSelectV2MenuSearch } from './MultiSelectV2MenuSearch';
+export { default as MultiSelectV2MenuVirtualList } from './MultiSelectV2MenuVirtualList';
+export { default as MultiSelectV2MenuItems } from './MultiSelectV2MenuItems';
+export { default as MultiSelectV2MenuActions } from './MultiSelectV2MenuActions';
+export { default as MultiSelectV2Trigger } from './MultiSelectV2Trigger';
+export { default as MobileMultiSelectV2 } from './MobileMultiSelectV2';
+export type { MultiSelectV2Props } from './multiSelectV2.types';
+export * from './multiSelectV2.types';
+export * from './multiSelectV2.tokens';
+export * from './utils';

package/dist/components/MultiSelectV2/mobile/MobileMultiSelectV2.d.ts

@@ -0,0 +1,3 @@
+import { MultiSelectV2Props } from '../multiSelectV2.types';
+declare const MobileMultiSelectV2: ({ selectedValues, onChange, items, label, subLabel, helpIconText, required, variant, selectionTagType, slot, hintText, placeholder, size, search, enableSelectAll, selectAllText, maxSelections, customTrigger, error, showActionButtons, primaryAction, secondaryAction, showItemDividers, showHeaderBorder, enableVirtualization, virtualListItemHeight, virtualListOverscan, onEndReached, endReachedThreshold, hasMore, skeleton, allowCustomValue, customValueLabel, onOpenChange, triggerDimensions, inline, disabled, name, ...buttonRest }: MultiSelectV2Props) => import("react/jsx-runtime").JSX.Element;
+export default MobileMultiSelectV2;

package/dist/components/MultiSelectV2/mobile/mobileMultiSelectV2.utils.d.ts

@@ -0,0 +1,8 @@
+import { VirtualListItem } from '../../VirtualList/types';
+import { FlattenedMultiSelectV2Item, MultiSelectV2GroupType } from '../multiSelectV2.types';
+export type FlattenedMobileMultiSelectV2Item = Omit<FlattenedMultiSelectV2Item, 'type'> & {
+    type: FlattenedMultiSelectV2Item['type'] | 'selectAll';
+};
+export declare const flattenMobileMultiSelectV2Groups: (groups: MultiSelectV2GroupType[], enableSelectAll: boolean) => FlattenedMobileMultiSelectV2Item[];
+export declare const isSelectableItem: (value: string, groups: MultiSelectV2GroupType[]) => boolean;
+export declare const toVirtualListItems: (items: FlattenedMobileMultiSelectV2Item[]) => VirtualListItem[];

package/dist/components/MultiSelectV2/multiSelectV2.dark.tokens.d.ts

@@ -0,0 +1,3 @@
+import { FoundationTokenType } from '../../tokens/theme.token';
+import { ResponsiveMultiSelectV2Tokens } from './multiSelectV2.tokens';
+export declare const getMultiSelectV2DarkTokens: (foundationToken: FoundationTokenType) => ResponsiveMultiSelectV2Tokens;

package/dist/components/MultiSelectV2/multiSelectV2.light.tokens.d.ts

@@ -0,0 +1,3 @@
+import { FoundationTokenType } from '../../tokens/theme.token';
+import { ResponsiveMultiSelectV2Tokens } from './multiSelectV2.tokens';
+export declare const getMultiSelectV2LightTokens: (foundationToken: FoundationTokenType) => ResponsiveMultiSelectV2Tokens;

package/dist/components/MultiSelectV2/multiSelectV2.tokens.d.ts

@@ -0,0 +1,216 @@
+import { CSSObject } from 'styled-components';
+import { FoundationTokenType } from '../../tokens/theme.token';
+import { BreakpointType } from '../../breakpoints/breakPoints';
+import { MultiSelectV2Size, MultiSelectV2SelectionTagType, MultiSelectV2Variant } from './multiSelectV2.types';
+import { Theme } from '../../context/theme.enum';
+import { SelectV2ItemStates, SelectV2TriggerStates } from '../SelectV2/selectV2.tokenStates';
+type StateToken<T> = Record<SelectV2ItemStates, T>;
+type TriggerStateToken<T> = Record<SelectV2TriggerStates, T>;
+type VariantToken<T> = Record<MultiSelectV2Variant, T>;
+type SizeToken<T> = Record<MultiSelectV2Size, T>;
+type SelectionTagTypeToken<T> = Record<MultiSelectV2SelectionTagType, T>;
+export type MultiSelectV2TriggerStates = SelectV2TriggerStates;
+export type MultiSelectV2ItemStates = SelectV2ItemStates;
+export type MultiSelectV2TokensType = {
+    gap: CSSObject['gap'];
+    label: {
+        fontSize: CSSObject['fontSize'];
+        fontWeight: CSSObject['fontWeight'];
+        color: StateToken<CSSObject['color']>;
+    };
+    subLabel: {
+        fontSize: CSSObject['fontSize'];
+        fontWeight: CSSObject['fontWeight'];
+        color: StateToken<CSSObject['color']>;
+    };
+    hintText: {
+        fontSize: CSSObject['fontSize'];
+        fontWeight: CSSObject['fontWeight'];
+        color: StateToken<CSSObject['color']>;
+    };
+    errorMessage: {
+        fontSize: CSSObject['fontSize'];
+        fontWeight: CSSObject['fontWeight'];
+        color: CSSObject['color'];
+    };
+    required: {
+        color: CSSObject['color'];
+    };
+    trigger: {
+        height: SizeToken<VariantToken<CSSObject['height']>>;
+        padding: SizeToken<VariantToken<{
+            top: CSSObject['paddingTop'];
+            right: CSSObject['paddingRight'];
+            bottom: CSSObject['paddingBottom'];
+            left: CSSObject['paddingLeft'];
+        }>>;
+        borderRadius: SizeToken<VariantToken<CSSObject['borderRadius']>>;
+        boxShadow: VariantToken<CSSObject['boxShadow']>;
+        backgroundColor: VariantToken<TriggerStateToken<CSSObject['backgroundColor']>>;
+        outline: VariantToken<TriggerStateToken<CSSObject['outline']>>;
+        slot: {
+            gap: CSSObject['gap'];
+            width: CSSObject['width'];
+        };
+        selectionTag: VariantToken<SelectionTagTypeToken<{
+            color: CSSObject['color'];
+            backgroundColor: CSSObject['backgroundColor'];
+            fontWeight: CSSObject['fontWeight'];
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+        }>> & {
+            marginLeft: CSSObject['margin'];
+            borderRadius: CSSObject['borderRadius'];
+        };
+        chevron: {
+            gap: CSSObject['gap'];
+            width: CSSObject['width'];
+            height: CSSObject['height'];
+            iconSize?: number;
+        };
+        clearButton?: {
+            backgroundColor: TriggerStateToken<CSSObject['backgroundColor']>;
+            outline: TriggerStateToken<CSSObject['outline']>;
+            color: CSSObject['color'];
+            width?: CSSObject['width'];
+        };
+        floatingLabel: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+        };
+        placeholder: {
+            color: CSSObject['color'];
+            fontSize: CSSObject['fontSize'];
+            fontWeight: CSSObject['fontWeight'];
+        };
+        selectedValue: {
+            color: CSSObject['color'];
+            fontSize: CSSObject['fontSize'];
+            fontWeight: CSSObject['fontWeight'];
+        };
+    };
+    menu: {
+        backgroundColor: CSSObject['backgroundColor'];
+        border: CSSObject['border'];
+        borderRadius: CSSObject['borderRadius'];
+        padding: SizeToken<VariantToken<{
+            top: CSSObject['paddingTop'];
+            right: CSSObject['paddingRight'];
+            bottom: CSSObject['paddingBottom'];
+            left: CSSObject['paddingLeft'];
+        }>>;
+        minWidth: CSSObject['minWidth'];
+        scroll: {
+            height: CSSObject['height'];
+            maxHeight: CSSObject['maxHeight'];
+        };
+        header: {
+            backgroundColor: CSSObject['backgroundColor'];
+            borderBottom: CSSObject['borderBottom'];
+            selectAllRowPaddingLeft: CSSObject['paddingLeft'];
+            selectAllRowPaddingRight: CSSObject['paddingRight'];
+        };
+        selectAll: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+            borderRadius: CSSObject['borderRadius'];
+        };
+        list: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+        };
+        actions: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+            gap: CSSObject['gap'];
+            backgroundColor: CSSObject['backgroundColor'];
+            borderTop: CSSObject['borderTop'];
+        };
+        item: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+            margin: CSSObject['margin'];
+            borderRadius: CSSObject['borderRadius'];
+            gap: CSSObject['gap'];
+            backgroundColor: StateToken<CSSObject['backgroundColor']>;
+            optionsLabel: {
+                fontSize: CSSObject['fontSize'];
+                fontWeight: CSSObject['fontWeight'];
+                color: StateToken<CSSObject['color']>;
+                paddingTop: CSSObject['paddingTop'];
+                paddingRight: CSSObject['paddingRight'];
+                paddingBottom: CSSObject['paddingBottom'];
+                paddingLeft: CSSObject['paddingLeft'];
+            };
+            option: {
+                fontSize: CSSObject['fontSize'];
+                fontWeight: CSSObject['fontWeight'];
+                color: StateToken<CSSObject['color']>;
+            };
+            description: {
+                fontSize: CSSObject['fontSize'];
+                fontWeight: CSSObject['fontWeight'];
+                color: StateToken<CSSObject['color']>;
+            };
+            seperator: {
+                color: CSSObject['color'];
+                height: CSSObject['height'];
+                margin: CSSObject['margin'];
+            };
+        };
+    };
+    subMenu: {
+        trigger: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+            margin: CSSObject['margin'];
+            borderRadius: CSSObject['borderRadius'];
+        };
+        content: {
+            borderRadius: CSSObject['borderRadius'];
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+        };
+    };
+    drawer: {
+        header: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+            borderBottom: CSSObject['borderBottom'];
+        };
+        search: {
+            paddingTop: CSSObject['paddingTop'];
+            paddingRight: CSSObject['paddingRight'];
+            paddingBottom: CSSObject['paddingBottom'];
+            paddingLeft: CSSObject['paddingLeft'];
+            marginTop: CSSObject['margin'];
+            marginBottom: CSSObject['margin'];
+        };
+        content: {
+            gap: CSSObject['gap'];
+        };
+    };
+};
+export type ResponsiveMultiSelectV2Tokens = {
+    [key in keyof BreakpointType]: MultiSelectV2TokensType;
+};
+export declare const getMultiSelectV2Tokens: (foundationToken: FoundationTokenType, theme?: Theme | string) => ResponsiveMultiSelectV2Tokens;
+export {};

package/dist/components/MultiSelectV2/multiSelectV2.types.d.ts

@@ -0,0 +1,124 @@
+import { ReactNode, ReactElement, ButtonHTMLAttributes } from 'react';
+import { DropdownMenuContentProps } from '@radix-ui/react-dropdown-menu';
+import { SelectV2FlattenedItemBase, SelectV2BaseItemType, SelectV2MenuRootPropsBase, SelectV2SkeletonProps, SelectV2Size, SelectV2Variant } from '../SelectV2/selectV2.shared.types';
+import { SelectV2MenuDimensions, SelectV2TriggerDimensions, SelectV2MenuPosition, SelectV2ErrorState, SelectV2SearchConfig } from '../SingleSelectV2/singleSelectV2.types';
+export { SelectV2Alignment as MultiSelectV2Alignment, SelectV2Variant as MultiSelectV2Variant, SelectV2Size as MultiSelectV2Size, SelectV2Side as MultiSelectV2Side, } from '../SelectV2/selectV2.shared.types';
+export type { SelectV2SkeletonProps as MultiSelectV2SkeletonProps };
+export type { SelectV2MenuDimensions, SelectV2TriggerDimensions, SelectV2MenuPosition, SelectV2ErrorState, SelectV2SearchConfig, };
+export declare enum MultiSelectV2SelectionTagType {
+    COUNT = "count",
+    TEXT = "text"
+}
+export type MultiSelectV2ItemType = SelectV2BaseItemType & {
+    alwaysSelected?: boolean;
+    subMenu?: MultiSelectV2ItemType[];
+};
+export type MultiSelectV2GroupType = {
+    groupLabel?: string;
+    items: MultiSelectV2ItemType[];
+    showSeparator?: boolean;
+};
+export type FlattenedMultiSelectV2Item = SelectV2FlattenedItemBase<MultiSelectV2ItemType>;
+export type MultiSelectV2MenuProps = {
+    items: MultiSelectV2GroupType[];
+    selected: string[];
+    onSelect: (value: string) => void;
+    trigger: ReactElement;
+    menuDimensions?: SelectV2MenuDimensions;
+    disabled?: boolean;
+    search?: SelectV2SearchConfig;
+    enableSelectAll?: boolean;
+    selectAllText?: string;
+    onSelectAll?: (selectAll: boolean, filteredItems: MultiSelectV2GroupType[]) => void;
+    maxSelections?: number;
+    menuPosition?: SelectV2MenuPosition;
+    collisionBoundary?: DropdownMenuContentProps['collisionBoundary'];
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    showActionButtons?: boolean;
+    primaryAction?: {
+        text: string;
+        onClick: (selectedValues: string[]) => void;
+        disabled?: boolean;
+        loading?: boolean;
+    };
+    secondaryAction?: {
+        text: string;
+        onClick: () => void;
+        disabled?: boolean;
+        loading?: boolean;
+    };
+    enableVirtualization?: boolean;
+    virtualListItemHeight?: number;
+    virtualListOverscan?: number;
+    onEndReached?: () => void;
+    endReachedThreshold?: number;
+    hasMore?: boolean;
+    loadingComponent?: ReactNode;
+    skeleton?: SelectV2SkeletonProps;
+    size?: SelectV2Size;
+    variant?: SelectV2Variant;
+    allowCustomValue?: boolean;
+    customValueLabel?: string;
+    menuId?: string;
+};
+export type MenuRootProps = SelectV2MenuRootPropsBase & {
+    onInteractOutside?: (e: Event) => void;
+    onPointerDownOutside?: (e: Event) => void;
+};
+export type MultiSelectV2Props = Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'style' | 'className' | 'onChange' | 'slot'> & {
+    selectedValues: string[];
+    onChange: (value: string | string[]) => void;
+    items?: MultiSelectV2GroupType[];
+    label: string;
+    subLabel?: string;
+    helpIconText?: string;
+    required?: boolean;
+    variant?: SelectV2Variant;
+    selectionTagType?: MultiSelectV2SelectionTagType;
+    slot?: ReactNode;
+    hintText?: string;
+    placeholder: string;
+    size?: SelectV2Size;
+    search?: SelectV2SearchConfig;
+    enableSelectAll?: boolean;
+    selectAllText?: string;
+    maxSelections?: number;
+    customTrigger?: ReactElement;
+    usePanelOnMobile?: boolean;
+    triggerDimensions?: SelectV2TriggerDimensions;
+    menuDimensions?: SelectV2MenuDimensions;
+    menuPosition?: SelectV2MenuPosition;
+    inline?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    error?: SelectV2ErrorState;
+    showActionButtons?: boolean;
+    primaryAction?: {
+        text: string;
+        onClick: (selectedValues: string[]) => void;
+        disabled?: boolean;
+        loading?: boolean;
+    };
+    secondaryAction?: {
+        text: string;
+        onClick: () => void;
+        disabled?: boolean;
+        loading?: boolean;
+    };
+    showItemDividers?: boolean;
+    showHeaderBorder?: boolean;
+    enableVirtualization?: boolean;
+    virtualListItemHeight?: number;
+    virtualListOverscan?: number;
+    itemsToRender?: number;
+    onEndReached?: () => void;
+    endReachedThreshold?: number;
+    hasMore?: boolean;
+    loadingComponent?: ReactNode;
+    skeleton?: SelectV2SkeletonProps;
+    allowCustomValue?: boolean;
+    customValueLabel?: string;
+    showClearButton?: boolean;
+    onClearAllClick?: () => void;
+    multiSelectGroupPosition?: 'center' | 'left' | 'right';
+};

package/dist/components/MultiSelectV2/utils.d.ts

@@ -0,0 +1,23 @@
+import { MultiSelectV2TokensType } from './multiSelectV2.tokens';
+import { MultiSelectV2Size, MultiSelectV2Variant, FlattenedMultiSelectV2Item, MultiSelectV2GroupType, MultiSelectV2ItemType } from './multiSelectV2.types';
+export declare const getSelectAllState: (selected: string[], availableValues: string[]) => {
+    allSelected: boolean;
+    someSelected: boolean;
+};
+export declare const getValueLabelMap: (groups: MultiSelectV2GroupType[]) => Record<string, string>;
+export declare function getMultiSelectBorderRadius(size: MultiSelectV2Size, variant: MultiSelectV2Variant, multiSelectGroupPosition: 'center' | 'left' | 'right' | undefined, tokens: MultiSelectV2TokensType, shouldShowClearButton: boolean): string;
+export declare function getMultiSelectCrossBorderRadius(size: MultiSelectV2Size, variant: MultiSelectV2Variant, multiSelectGroupPosition: 'center' | 'left' | 'right' | undefined, tokens: MultiSelectV2TokensType): {
+    borderRadius: string;
+    borderRight?: string;
+};
+export declare const getFilteredMenuItem: (item: MultiSelectV2ItemType, queryLower: string) => MultiSelectV2ItemType | null;
+export declare const filterMenuGroups: (groups: MultiSelectV2GroupType[], searchText: string) => MultiSelectV2GroupType[];
+export declare const getAllAvailableValues: (groups: MultiSelectV2GroupType[]) => string[];
+export declare const handleSelectAll: (selectAll: boolean, items: MultiSelectV2GroupType[], selectedValues: string[], onChange: (value: string) => void) => void;
+export declare const flattenMenuGroups: (groups: MultiSelectV2GroupType[]) => FlattenedMultiSelectV2Item[];
+export declare const getTriggerLeftPadding: (tokens: MultiSelectV2TokensType, size: MultiSelectV2Size, variant: MultiSelectV2Variant) => number;
+export declare const getTriggerTopPadding: (tokens: MultiSelectV2TokensType, size: MultiSelectV2Size, variant: MultiSelectV2Variant) => number;
+/** @deprecated Use getTriggerLeftPadding */
+export declare const getTriggerHorizontalPadding: (tokens: MultiSelectV2TokensType, size: MultiSelectV2Size, variant: MultiSelectV2Variant) => number;
+/** @deprecated Use getTriggerTopPadding */
+export declare const getTriggerVerticalPadding: (tokens: MultiSelectV2TokensType, size: MultiSelectV2Size, variant: MultiSelectV2Variant) => number;

package/dist/components/PopoverV2/MobilePopoverV2.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { PopoverV2Props } from './popoverV2.types';
+type MobilePopoverV2Props = PopoverV2Props & {
+    useDrawerOnMobile?: boolean;
+};
+declare const MobilePopoverV2: React.FC<MobilePopoverV2Props>;
+export default MobilePopoverV2;

package/dist/components/PopoverV2/PopoverV2.d.ts

@@ -0,0 +1,23 @@
+import { PopoverV2Align, PopoverV2Side, PopoverV2Size } from './popoverV2.types';
+declare const PopoverV2: import('react').ForwardRefExoticComponent<{
+    heading?: string;
+    description?: string;
+    trigger: React.ReactNode;
+    children: React.ReactNode;
+    showCloseButton?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    asModal?: boolean;
+    primaryAction?: import('./popoverV2.types').PopoverV2ActionType;
+    secondaryAction?: import('./popoverV2.types').PopoverV2ActionType;
+    sideOffset?: number;
+    side?: PopoverV2Side;
+    align?: PopoverV2Align;
+    alignOffset?: number;
+    size?: PopoverV2Size;
+    onClose?: () => void;
+    useDrawerOnMobile?: boolean;
+    avoidCollisions?: boolean;
+    skeleton?: import('./popoverV2.types').PopoverV2SkeletonProps;
+} & import('./popoverV2.types').PopoverV2Dimensions & Omit<import('react').HTMLAttributes<HTMLDivElement>, "style" | "className" | "slot"> & import('react').RefAttributes<HTMLDivElement>>;
+export default PopoverV2;

package/dist/components/PopoverV2/PopoverV2Footer.d.ts

@@ -0,0 +1,12 @@
+import { PopoverV2TokenType } from './popoverV2.token';
+import { PopoverV2Props } from './popoverV2.types';
+import { SkeletonVariant } from '../Skeleton';
+declare const PopoverV2Footer: {
+    ({ popoverTokens, primaryAction, secondaryAction, size, showSkeleton, skeletonVariant, }: Pick<PopoverV2Props, "primaryAction" | "secondaryAction" | "size"> & {
+        showSkeleton?: boolean;
+        skeletonVariant?: SkeletonVariant;
+        popoverTokens: PopoverV2TokenType;
+    }): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};
+export default PopoverV2Footer;