@juspay/blend-design-system 0.0.15 → 0.0.16

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

@@ -0,0 +1,86 @@
+import { default as React } from 'react';
+import { CardVariant, CardAlignment } from './types';
+import { CardTokenType } from './card.tokens';
+import { ButtonSubType } from '../Button/types';
+/**
+ * Determines the card variant type
+ */
+export declare const getCardVariant: (variant?: CardVariant) => CardVariant;
+/**
+ * Checks if card is default variant
+ */
+export declare const isDefaultCard: (variant?: CardVariant) => boolean;
+/**
+ * Checks if card is aligned variant
+ */
+export declare const isAlignedCard: (variant?: CardVariant) => boolean;
+/**
+ * Checks if card is custom variant
+ */
+export declare const isCustomCard: (variant?: CardVariant) => boolean;
+/**
+ * Gets header box styles for default card
+ */
+export declare const getHeaderBoxStyles: (cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Gets header title styles
+ */
+export declare const getHeaderTitleStyles: (cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Gets sub header styles
+ */
+export declare const getSubHeaderStyles: (cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Gets body title styles
+ */
+export declare const getBodyTitleStyles: (cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Gets body content styles
+ */
+export declare const getBodyContentStyles: (cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Gets body container styles
+ */
+export declare const getBodyStyles: (cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Gets spacing between header slots
+ */
+export declare const getHeaderSlotSpacing: (cardToken: CardTokenType) => string;
+/**
+ * Gets margin bottom for header based on what follows
+ */
+export declare const getHeaderMarginBottom: (hasSubHeader: boolean, cardToken: CardTokenType) => string;
+/**
+ * Gets margin bottom for sub header
+ */
+export declare const getSubHeaderMarginBottom: (cardToken: CardTokenType) => string;
+/**
+ * Gets margin bottom for body slot 1
+ */
+export declare const getBodySlot1MarginBottom: (hasBodyTitle: boolean, cardToken: CardTokenType) => string;
+/**
+ * Gets margin bottom for body title
+ */
+export declare const getBodyTitleMarginBottom: (hasContent: boolean, cardToken: CardTokenType) => string;
+/**
+ * Gets margin bottom for content
+ */
+export declare const getContentMarginBottom: (hasBodySlot2: boolean, cardToken: CardTokenType) => string;
+/**
+ * Gets margin bottom for body slot 2
+ */
+export declare const getBodySlot2MarginBottom: (hasActionButton: boolean, isInlineButton: boolean, cardToken: CardTokenType) => string;
+/**
+ * Gets alignment styles for aligned cards
+ */
+export declare const getAlignmentStyles: (alignment: CardAlignment, centerAlign: boolean, cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Gets custom card styles (simple wrapper with padding)
+ */
+export declare const getCustomCardStyles: (cardToken: CardTokenType) => React.CSSProperties;
+/**
+ * Determines if action button is inline type
+ */
+export declare const isInlineActionButton: (actionButton?: {
+    subType?: ButtonSubType;
+}) => boolean;

package/dist/components/Charts/types.d.ts

@@ -10,6 +10,11 @@ export type DataPoint = {
     aux?: {
         label: string;
         val: number;
+        type?: AxisType;
+        dateOnly?: boolean;
+        smart?: boolean;
+        timeZone?: string;
+        hour12?: boolean;
     }[];
 };
 export declare enum ChartLegendPosition {

package/dist/components/Checkbox/checkbox.token.d.ts

@@ -1,6 +1,6 @@
 import { CSSObject } from 'styled-components';
 import { ThemeType } from '../../tokens';
-import { CheckboxCheckedState, CheckboxInteractionState, CheckboxSize } from './types';
+import { CheckboxSize, CheckboxInteractionState } from './types';
 import { BreakpointType } from '../../breakpoints/breakPoints';
 export type CheckboxTokensType = {
     gap: CSSObject['gap'];
@@ -14,7 +14,13 @@ export type CheckboxTokensType = {
             };
         };
         background: {
-            [key in CheckboxCheckedState]?: {
+            checked?: {
+                [key in CheckboxInteractionState]?: CSSObject['backgroundColor'];
+            };
+            unchecked?: {
+                [key in CheckboxInteractionState]?: CSSObject['backgroundColor'];
+            };
+            indeterminate?: {
                 [key in CheckboxInteractionState]?: CSSObject['backgroundColor'];
             };
         };
@@ -22,7 +28,13 @@ export type CheckboxTokensType = {
             radius: CSSObject['borderRadius'];
             width: CSSObject['borderWidth'];
             color: {
-                [key in CheckboxCheckedState]?: {
+                checked?: {
+                    [key in CheckboxInteractionState]?: CSSObject['borderColor'];
+                };
+                unchecked?: {
+                    [key in CheckboxInteractionState]?: CSSObject['borderColor'];
+                };
+                indeterminate?: {
                     [key in CheckboxInteractionState]?: CSSObject['borderColor'];
                 };
             };
@@ -36,7 +48,10 @@ export type CheckboxTokensType = {
     };
     icon: {
         color: {
-            [key in Exclude<CheckboxCheckedState, 'unchecked'>]?: {
+            checked?: {
+                [key in Extract<CheckboxInteractionState, 'default' | 'disabled'>]?: CSSObject['color'];
+            };
+            indeterminate?: {
                 [key in Extract<CheckboxInteractionState, 'default' | 'disabled'>]?: CSSObject['color'];
             };
         };

package/dist/components/Checkbox/types.d.ts

@@ -3,8 +3,17 @@ export declare enum CheckboxSize {
     SMALL = "sm",
     MEDIUM = "md"
 }
-export type CheckboxCheckedState = 'checked' | 'unchecked' | 'indeterminate';
-export type CheckboxInteractionState = 'default' | 'hover' | 'disabled' | 'error';
+export declare enum CheckboxCheckedState {
+    CHECKED = "checked",
+    UNCHECKED = "unchecked",
+    INDETERMINATE = "indeterminate"
+}
+export declare enum CheckboxInteractionState {
+    DEFAULT = "default",
+    HOVER = "hover",
+    DISABLED = "disabled",
+    ERROR = "error"
+}
 export type CheckboxProps = {
     id?: string;
     value?: string;

package/dist/components/DateRangePicker/MobileDrawerPresets.d.ts

@@ -1,25 +1,4 @@
 import { default as React } from 'react';
-import { DateRange, DateRangePreset } from './types';
-type MobileDrawerPresetsProps = {
-    drawerOpen: boolean;
-    setDrawerOpen: (open: boolean) => void;
-    renderTrigger: () => React.ReactNode;
-    showPresets: boolean;
-    availablePresets: DateRangePreset[];
-    activePreset: DateRangePreset;
-    selectedRange: DateRange;
-    startTime: string;
-    endTime: string;
-    dateFormat: string;
-    handlePresetSelect: (preset: DateRangePreset) => void;
-    handleStartTimeChange: (time: string) => void;
-    handleEndTimeChange: (time: string) => void;
-    setSelectedRange: (range: DateRange) => void;
-    setStartDate: (date: string) => void;
-    setEndDate: (date: string) => void;
-    handleCancel: () => void;
-    handleApply: () => void;
-    showCustomDropdownOnly?: boolean;
-};
+import { MobileDrawerPresetsProps } from './types';
 declare const MobileDrawerPresets: React.FC<MobileDrawerPresetsProps>;
 export default MobileDrawerPresets;

package/dist/components/DateRangePicker/QuickRangeSelector.d.ts

@@ -8,6 +8,7 @@ type QuickRangeSelectorProps = {
     className?: string;
     disableFutureDates?: boolean;
     disablePastDates?: boolean;
+    isDisabled?: boolean;
 };
 declare const QuickRangeSelector: import('react').ForwardRefExoticComponent<QuickRangeSelectorProps & import('react').RefAttributes<HTMLDivElement>>;
 export default QuickRangeSelector;

package/dist/components/DateRangePicker/components/ActionButtons.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ActionButtonsProps } from '../types';
+declare const ActionButtons: React.FC<ActionButtonsProps>;
+export default ActionButtons;

package/dist/components/DateRangePicker/components/DatePickerComponent.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { DatePickerComponentProps } from '../types';
+declare const DatePickerComponent: React.FC<DatePickerComponentProps>;
+export default DatePickerComponent;

package/dist/components/DateRangePicker/components/PresetItem.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { PresetItemProps } from '../types';
+declare const PresetItem: React.FC<PresetItemProps>;
+export default PresetItem;

package/dist/components/DateRangePicker/components/ScrollablePicker.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ScrollablePickerProps } from '../types';
+declare const ScrollablePicker: React.NamedExoticComponent<ScrollablePickerProps>;
+export default ScrollablePicker;

package/dist/components/DateRangePicker/dateRangePicker.tokens.d.ts

@@ -3,7 +3,6 @@ import { FoundationTokenType } from '../../tokens/theme.token';
 import { BreakpointType } from '../../breakpoints/breakPoints';
 export type CalendarTokenType = {
     quickRange: {
-        width: CSSObject['width'];
         trigger: {
             height: CSSObject['height'];
             borderLeft: CSSObject['borderLeft'];
@@ -20,10 +19,12 @@ export type CalendarTokenType = {
             backgroundColor: CSSObject['backgroundColor'];
             iconSize: CSSObject['iconSize'];
             text: CSSObject;
+            gap: CSSObject['gap'];
         };
         content: {
             padding: CSSObject['padding'];
             width: CSSObject['width'];
+            maxHeight: CSSObject['maxHeight'];
             zIndex: CSSObject['zIndex'];
             backgroundColor: CSSObject['backgroundColor'];
             borderRadius: CSSObject['borderRadius'];

package/dist/components/DateRangePicker/types.d.ts

@@ -20,6 +20,59 @@ export type DateRange = {
     endDate: Date;
     showTimePicker?: boolean;
 };
+/**
+ * Predefined format presets for common date display patterns
+ */
+export declare enum DateFormatPreset {
+    SHORT_RANGE = "short-range",// "Sep 3-5 2025"
+    MEDIUM_RANGE = "medium-range",// "Sep 3 - Sep 5 2025"
+    LONG_RANGE = "long-range",// "Sep 3 2025 - Sep 5 2025"
+    SHORT_SINGLE = "short-single",// "Sep 3 2025"
+    MEDIUM_SINGLE = "medium-single",// "September 3, 2025"
+    LONG_SINGLE = "long-single",// "September 3rd, 2025"
+    ISO_RANGE = "iso-range",// "2025-09-03 - 2025-09-05"
+    US_RANGE = "us-range",// "09/03/2025 - 09/05/2025"
+    CUSTOM = "custom"
+}
+/**
+ * Custom format function type for advanced formatting
+ */
+export type CustomFormatFunction = (range: DateRange, options?: {
+    includeTime?: boolean;
+    includeYear?: boolean;
+    separator?: string;
+    locale?: string;
+}) => string;
+/**
+ * Format configuration for date display
+ */
+export type DateFormatConfig = {
+    preset?: DateFormatPreset;
+    customFormat?: CustomFormatFunction;
+    includeTime?: boolean;
+    includeYear?: boolean;
+    separator?: string;
+    locale?: string;
+    timeFormat?: '12h' | '24h';
+};
+/**
+ * Custom trigger configuration
+ */
+export type TriggerConfig = {
+    element?: ReactNode;
+    placeholder?: string;
+    showIcon?: boolean;
+    icon?: ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    renderTrigger?: (props: {
+        selectedRange: DateRange | undefined;
+        isOpen: boolean;
+        isDisabled: boolean;
+        formattedValue: string;
+        onClick: () => void;
+    }) => ReactNode;
+};
 export type DateRangePickerProps = {
     value?: DateRange;
     onChange?: (range: DateRange) => void;
@@ -37,4 +90,70 @@ export type DateRangePickerProps = {
     triggerElement?: ReactNode;
     useDrawerOnMobile?: boolean;
     skipQuickFiltersOnMobile?: boolean;
+    formatConfig?: DateFormatConfig;
+    triggerConfig?: TriggerConfig;
+};
+/**
+ * Haptic feedback types for different interactions
+ */
+export declare enum HapticFeedbackType {
+    SELECTION = "selection",
+    IMPACT = "impact",
+    NOTIFICATION = "notification"
+}
+export type PresetItemProps = {
+    preset: DateRangePreset;
+    isActive: boolean;
+    isCustomExpanded?: boolean;
+    onPresetSelect: (preset: DateRangePreset) => void;
+    onCustomToggle?: () => void;
+    setDrawerOpen?: (open: boolean) => void;
+    isDisabled?: boolean;
+};
+export type ActionButtonsProps = {
+    onCancel: () => void;
+    onApply: () => void;
+    isDisabled?: boolean;
+};
+export type ScrollablePickerProps = {
+    items: (string | number)[];
+    selectedIndex: number;
+    onSelect: (index: number) => void;
+    isTimeColumn?: boolean;
+    columnId: string;
+    isDisabled?: boolean;
+};
+export type DatePickerComponentProps = {
+    selectedRange: DateRange;
+    startTime: string;
+    endTime: string;
+    dateFormat: string;
+    handleStartTimeChange: (time: string) => void;
+    handleEndTimeChange: (time: string) => void;
+    setSelectedRange: (range: DateRange) => void;
+    setStartDate: (date: string) => void;
+    setEndDate: (date: string) => void;
+    isDisabled?: boolean;
+};
+export type MobileDrawerPresetsProps = {
+    drawerOpen: boolean;
+    setDrawerOpen: (open: boolean) => void;
+    renderTrigger: () => React.ReactNode;
+    showPresets: boolean;
+    availablePresets: DateRangePreset[];
+    activePreset: DateRangePreset;
+    selectedRange: DateRange;
+    startTime: string;
+    endTime: string;
+    dateFormat: string;
+    handlePresetSelect: (preset: DateRangePreset) => void;
+    handleStartTimeChange: (time: string) => void;
+    handleEndTimeChange: (time: string) => void;
+    setSelectedRange: (range: DateRange) => void;
+    setStartDate: (date: string) => void;
+    setEndDate: (date: string) => void;
+    handleCancel: () => void;
+    handleApply: () => void;
+    showCustomDropdownOnly?: boolean;
+    isDisabled?: boolean;
 };

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

@@ -1,4 +1,4 @@
-import { DateRange, DateRangePreset } from './types';
+import { DateRange, DateRangePreset, DateFormatConfig, CustomFormatFunction, HapticFeedbackType } from './types';
 import { CalendarTokenType } from './dateRangePicker.tokens';
 /**
  * Formats a date according to the specified format
@@ -468,26 +468,6 @@ export declare const calculateDayCellProps: (date: Date, selectedRange: DateRang
     textColor: string | unknown;
     showTodayIndicator: boolean;
 };
-/**
- * Constants for mobile date picker
- */
-export declare const MOBILE_PICKER_CONSTANTS: {
-    readonly ITEM_HEIGHT: 44;
-    readonly VISIBLE_ITEMS: 3;
-    readonly SCROLL_DEBOUNCE: 50;
-};
-/**
- * Validates time input - only allows numbers and colon
- * @param input The input string to validate
- * @returns True if input is valid
- */
-export declare const isValidTimeInput: (input: string) => boolean;
-/**
- * Formats time input as HH:MM
- * @param input The input string to format
- * @returns Formatted time string
- */
-export declare const formatTimeInput: (input: string) => string;
 /**
  * Generates picker data for date/time selection
  * @param tabType Whether this is for start or end date
@@ -534,3 +514,145 @@ export declare const createSelectionHandler: (tabType: "start" | "end", type: "y
  * @returns Display label for the preset
  */
 export declare const getPresetDisplayLabel: (preset: DateRangePreset) => string;
+/**
+ * Enhanced date range formatting with preset patterns
+ * @param range The date range to format
+ * @param config Format configuration
+ * @returns Formatted date range string
+ */
+export declare const formatDateRangeWithConfig: (range: DateRange, config?: DateFormatConfig) => string;
+/**
+ * Creates a custom trigger element with enhanced formatting
+ * @param range Current selected date range
+ * @param config Format configuration
+ * @param placeholder Placeholder text when no range is selected
+ * @returns Formatted display string for trigger
+ */
+export declare const formatTriggerDisplay: (range: DateRange | undefined, config?: DateFormatConfig, placeholder?: string) => string;
+/**
+ * Predefined format configurations for common use cases
+ */
+export declare const FORMAT_PRESETS: {
+    readonly COMPACT_NO_TIME: DateFormatConfig;
+    readonly COMPACT_NO_YEAR: DateFormatConfig;
+    readonly MEDIUM_NO_TIME: DateFormatConfig;
+    readonly MEDIUM_WITH_TIME: DateFormatConfig;
+    readonly VERBOSE_NO_TIME: DateFormatConfig;
+    readonly VERBOSE_WITH_TIME: DateFormatConfig;
+    readonly ISO_FORMAT: DateFormatConfig;
+    readonly ISO_WITH_TIME: DateFormatConfig;
+    readonly US_FORMAT: DateFormatConfig;
+    readonly US_WITH_TIME: DateFormatConfig;
+};
+/**
+ * Helper function to create custom format functions
+ * @param formatFn Custom formatting function
+ * @returns DateFormatConfig with custom format
+ */
+export declare const createCustomFormat: (formatFn: CustomFormatFunction) => DateFormatConfig;
+/**
+ * Example custom format functions
+ */
+export declare const CUSTOM_FORMAT_EXAMPLES: {
+    RELATIVE: DateFormatConfig;
+    BUSINESS: DateFormatConfig;
+    MINIMAL: DateFormatConfig;
+};
+/**
+ * Enhanced haptic feedback utility with better error handling
+ * @param type The type of haptic feedback to trigger
+ */
+export declare const triggerHapticFeedback: (type?: HapticFeedbackType) => void;
+/**
+ * Optimized Apple Calendar-style haptic manager
+ */
+export declare class AppleCalendarHapticManager {
+    private lastHapticTime;
+    private lastHapticIndex;
+    private readonly hapticCooldown;
+    private isDestroyed;
+    /**
+     * Triggers haptic feedback when scrolling to a new item
+     * @param currentIndex The current selected index
+     */
+    triggerScrollHaptic(currentIndex: number): void;
+    triggerSelectionHaptic(): void;
+    reset(): void;
+    destroy(): void;
+}
+export declare const APPLE_CALENDAR_CONSTANTS: {
+    readonly SNAP_DURATION: 300;
+    readonly MOMENTUM_THRESHOLD: 0.03;
+    readonly DECELERATION_RATE: 0.95;
+    readonly MIN_VELOCITY: 0.01;
+    readonly MAX_MOMENTUM_DISTANCE: 2;
+    readonly VELOCITY_MULTIPLIER: 0.15;
+    readonly VELOCITY_SMOOTHING: 0.8;
+    readonly SCROLL_RESISTANCE: 0.9;
+    readonly SCALE_SELECTED: 1.02;
+    readonly SCALE_UNSELECTED: 0.98;
+    readonly OPACITY_SELECTED: 1;
+    readonly OPACITY_UNSELECTED: 0.9;
+    readonly TRANSITION_DURATION: "180ms";
+    readonly EASING: "cubic-bezier(0.25, 0.46, 0.45, 0.94)";
+    readonly ANIMATION_FRAME_LIMIT: 60;
+    readonly VELOCITY_HISTORY_SIZE: 3;
+};
+export declare const MOBILE_PICKER_CONSTANTS: {
+    readonly ITEM_HEIGHT: 44;
+    readonly VISIBLE_ITEMS: 3;
+    readonly SCROLL_DEBOUNCE: 80;
+};
+/**
+ * Safely gets an item from an array with comprehensive bounds checking
+ * @param items The array of items
+ * @param index The index to access
+ * @returns The item at the index or empty string if out of bounds
+ */
+export declare const safeGetPickerItem: (items: (string | number)[], index: number) => string;
+/**
+ * Calculates the visible items for the picker with robust bounds checking
+ * @param items The array of items
+ * @param selectedIndex The currently selected index
+ * @returns Object with top, center, and bottom items plus availability flags
+ */
+export declare const getPickerVisibleItems: (items: (string | number)[], selectedIndex: number) => {
+    topItem: string;
+    centerItem: string;
+    bottomItem: string;
+    hasTopItem: boolean;
+    hasBottomItem: boolean;
+};
+/**
+ * Validates and clamps an index to array bounds with safety checks
+ * @param index The index to validate
+ * @param arrayLength The length of the array
+ * @returns Clamped index within bounds
+ */
+export declare const clampPickerIndex: (index: number, arrayLength: number) => number;
+/**
+ * Calculates scroll position for a given index with validation
+ * @param index The target index
+ * @param itemHeight Height of each item
+ * @returns Scroll position in pixels
+ */
+export declare const calculateScrollPosition: (index: number, itemHeight: number) => number;
+/**
+ * Calculates index from scroll position with bounds checking
+ * @param scrollTop Current scroll position
+ * @param itemHeight Height of each item
+ * @returns Calculated index
+ */
+export declare const calculateIndexFromScroll: (scrollTop: number, itemHeight: number) => number;
+/**
+ * Validates time input with comprehensive checks
+ * @param input The input string to validate
+ * @returns True if input is valid
+ */
+export declare const isValidTimeInput: (input: string) => boolean;
+/**
+ * Formats time input with better validation
+ * @param input The input string to format
+ * @returns Formatted time string
+ */
+export declare const formatTimeInput: (input: string) => string;

package/dist/components/KeyValuePair/KeyValuePair.d.ts

@@ -0,0 +1,3 @@
+import { KeyValuePairPropTypes } from './types';
+declare const KeyValuePair: import('react').ForwardRefExoticComponent<KeyValuePairPropTypes & import('react').RefAttributes<HTMLDivElement>>;
+export default KeyValuePair;

package/dist/components/KeyValuePair/KeyValuePair.tokens.d.ts

@@ -0,0 +1,19 @@
+import { CSSObject } from 'styled-components';
+import { BreakpointType } from '../../breakpoints/breakPoints';
+import { FoundationTokenType } from '../../tokens/theme.token';
+import { KeyValuePairSize, KeyValuePairStateType } from './types';
+export type KeyValuePairTokensType = {
+    gap: CSSObject['gap'];
+    keyColor: CSSObject['color'];
+    valueColor: CSSObject['color'];
+    keyFontSize: CSSObject['fontSize'];
+    valueFontSize: {
+        [key in KeyValuePairSize]: {
+            [key in KeyValuePairStateType]: CSSObject['fontSize'];
+        };
+    };
+};
+export type ResponsiveKeyValuePairTokens = {
+    [key in keyof BreakpointType]: KeyValuePairTokensType;
+};
+export declare const getKeyValuePairTokens: (foundationToken: FoundationTokenType) => ResponsiveKeyValuePairTokens;

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

@@ -0,0 +1,2 @@
+export { default as KeyValuePair } from './KeyValuePair';
+export * from './types';

package/dist/components/KeyValuePair/types.d.ts

@@ -0,0 +1,19 @@
+export declare enum KeyValuePairStateType {
+    vertical = 0,
+    horizontal = 1
+}
+export declare enum KeyValuePairSize {
+    SMALL = "sm",
+    MEDIUM = "md",
+    LARGE = "lg"
+}
+export type KeyValuePairPropTypes = {
+    keyString: string;
+    size?: KeyValuePairSize;
+    value?: string;
+    keySlot?: React.ReactNode;
+    valueLeftSlot?: React.ReactNode;
+    valueRightSlot?: React.ReactNode;
+    keyValuePairState?: KeyValuePairStateType;
+    maxWidth?: string;
+};

package/dist/components/Menu/MenuItem.d.ts

@@ -1,8 +1,9 @@
 import { MenuItemV2Type } from './types';
 declare const MenuItem: {
-    ({ item, idx }: {
+    ({ item, idx, maxHeight, }: {
         item: MenuItemV2Type;
         idx: number;
+        maxHeight?: number;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };

package/dist/components/Menu/SubMenu.d.ts

@@ -1,5 +1,6 @@
 import { MenuItemV2Type } from './types';
-export declare const SubMenu: ({ item, idx, }: {
+export declare const SubMenu: ({ item, idx, maxHeight, }: {
     item: MenuItemV2Type;
     idx: number;
+    maxHeight?: number;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Menu/types.d.ts

@@ -48,6 +48,8 @@ export type MenuItemV2Type = {
     disabled?: boolean;
     onClick?: () => void;
     subMenu?: MenuItemV2Type[];
+    enableSubMenuSearch?: boolean;
+    subMenuSearchPlaceholder?: string;
     tooltip?: string | React.ReactNode;
     tooltipProps?: {
         side?: TooltipSide;

package/dist/components/Sidebar/types.d.ts

@@ -1,5 +1,6 @@
 import { ReactNode } from 'react';
 import { DirectoryData } from '../Directory/types';
+import { MerchantInfo } from '../Topbar/types';
 export type LeftPanelItem = {
     label: string;
     icon: ReactNode;
@@ -19,4 +20,6 @@ export type SidebarProps = {
     footer?: ReactNode;
     sidebarTopSlot?: ReactNode;
     sidebarCollapseKey?: string;
+    merchantInfo?: MerchantInfo;
+    rightActions?: ReactNode;
 };

package/dist/components/Skeleton/Skeleton.d.ts

@@ -0,0 +1,8 @@
+declare const Skeleton: import('react').ForwardRefExoticComponent<import('./types').BaseSkeletonProps & Omit<import('../Primitives/Block/Block').BlockProps, "children"> & {
+    children?: import('react').ReactNode;
+    animate?: boolean;
+    width?: string | number;
+    height?: string | number;
+    shape?: import('./skeleton.tokens').SkeletonShape;
+} & import('react').RefAttributes<HTMLDivElement>>;
+export default Skeleton;

package/dist/components/Skeleton/SkeletonAvatar.d.ts

@@ -0,0 +1,5 @@
+declare const SkeletonAvatar: import('react').ForwardRefExoticComponent<import('./types').BaseSkeletonProps & Omit<import('../Primitives/Block/Block').BlockProps, "children"> & {
+    size?: import('./types').SkeletonSize;
+    shape?: "circle" | "square";
+} & import('react').RefAttributes<HTMLDivElement>>;
+export default SkeletonAvatar;