prometeo-design-system 3.1.5 → 3.1.6

package/dist/components/RecurrentDatePicker/CustomFrequencySettings.d.ts

@@ -0,0 +1,40 @@
+import { weekDay } from './WeekdaysSelector';
+import { default as React } from 'react';
+type CustomFrequency = "weekly" | "monthly";
+export type CustomFrequencySettingsValue = {
+    interval: number;
+    frequency: CustomFrequency;
+    weekdays?: weekDay[];
+    dayOfMonth?: string;
+};
+type CustomFrequencySettingsValueDeltaBase = {
+    kind: "setInterval" | "setFrequency" | "setWeekdays" | "setDayOfMonth";
+};
+type CustomFrequencySettingsValueDeltaInterval = CustomFrequencySettingsValueDeltaBase & {
+    kind: "setInterval";
+    interval: number;
+};
+type CustomFrequencySettingsValueDeltaFrequency = CustomFrequencySettingsValueDeltaBase & {
+    kind: "setFrequency";
+    frequency: CustomFrequency;
+};
+type CustomFrequencySettingsValueDeltaWeekdays = CustomFrequencySettingsValueDeltaBase & {
+    kind: "setWeekdays";
+    weekdays: weekDay[];
+};
+type CustomFrequencySettingsValueDeltaDayOfMonth = CustomFrequencySettingsValueDeltaBase & {
+    kind: "setDayOfMonth";
+    dayOfMonth: string;
+};
+export type CustomFrequencySettingsValueDelta = CustomFrequencySettingsValueDeltaInterval | CustomFrequencySettingsValueDeltaFrequency | CustomFrequencySettingsValueDeltaWeekdays | CustomFrequencySettingsValueDeltaDayOfMonth;
+interface CustomSettingsProps {
+    value?: CustomFrequencySettingsValue;
+    onChange: (delta: CustomFrequencySettingsValueDelta) => void;
+    errors?: {
+        interval?: string;
+        weekdays?: string;
+        dayOfMonth?: string;
+    };
+}
+declare const CustomFrequencySettings: React.MemoExoticComponent<({ value, onChange, errors }: CustomSettingsProps) => import("react/jsx-runtime").JSX.Element>;
+export default CustomFrequencySettings;

package/dist/components/RecurrentDatePicker/FrequencySettings.d.ts

@@ -0,0 +1,13 @@
+import { CustomFrequencySettingsValue } from './CustomFrequencySettings';
+import { MonthlySettingsValue } from './MonthlyFrequencySettings';
+import { FrequencySettingsErrors, FrequencySettingsValue, RecurrenceFrequencyType } from './RecurrentDatePicker';
+import { WeeklyFrequencySettingsValue } from './WeeklyFrequencySetting';
+import { YearlyFrequencySettingsValue } from './YearlyFrequencySettings';
+export interface IFrequencySettingsProps {
+    frequency: RecurrenceFrequencyType;
+    frequencySettings?: MonthlySettingsValue | WeeklyFrequencySettingsValue | YearlyFrequencySettingsValue | CustomFrequencySettingsValue;
+    onChange: (cb: ((pv: FrequencySettingsValue) => FrequencySettingsValue) | FrequencySettingsValue) => void;
+    errors?: FrequencySettingsErrors;
+}
+declare const FrequencySettings: import('react').MemoExoticComponent<(props: IFrequencySettingsProps) => import("react/jsx-runtime").JSX.Element>;
+export default FrequencySettings;

package/dist/components/RecurrentDatePicker/MonthlyFrequencySettings.d.ts

@@ -0,0 +1,35 @@
+type dayOrderType = 'first' | 'second' | 'third' | 'fourth' | 'last';
+type weekDay = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+export type MonthlySettingsValue = {
+    type: 'relative';
+    dayOrder: dayOrderType;
+    weekDay: weekDay;
+} | {
+    type: 'absolute';
+    dayOfMonth: string;
+};
+export type MonthlySettingsDelta = {
+    kind: 'setType';
+    newType: 'relative' | 'absolute';
+} | {
+    kind: 'setRelativeDayOrder';
+    newDayOrder: dayOrderType;
+} | {
+    kind: 'setRelativeWeekDay';
+    newWeekDay: weekDay;
+} | {
+    kind: 'setAbsoluteDayOfMonth';
+    newDayOfMonth: string;
+};
+export type MonthlySettingsErrors = {
+    dayOrder?: string;
+    weekDay?: string;
+    dayOfMonth?: string;
+};
+interface MonthlySettingsProps {
+    value?: MonthlySettingsValue;
+    onChange: (delta: MonthlySettingsDelta) => void;
+    errors?: MonthlySettingsErrors;
+}
+declare const MonthlyFrequencySettings: import('react').MemoExoticComponent<({ value, onChange, errors }: MonthlySettingsProps) => import("react/jsx-runtime").JSX.Element>;
+export default MonthlyFrequencySettings;

package/dist/components/RecurrentDatePicker/PreviewCalendar.d.ts

@@ -0,0 +1,5 @@
+type PreviewCalendarProps = {
+    selected: Date[];
+};
+declare const PreviewCalendar: (props: PreviewCalendarProps) => import("react/jsx-runtime").JSX.Element;
+export default PreviewCalendar;

package/dist/components/RecurrentDatePicker/RecurrentDatePicker.d.ts

@@ -0,0 +1,39 @@
+import { WeeklyFrequencySettingsValue } from './WeeklyFrequencySetting';
+import { MonthlySettingsValue } from './MonthlyFrequencySettings';
+import { YearlyFrequencySettingsValue } from './YearlyFrequencySettings';
+import { CustomFrequencySettingsValue } from './CustomFrequencySettings';
+export type RecurrenceFrequencyType = "custom" | "weekly" | "monthly" | "yearly";
+export declare const RecurrenceFrecuencyOptions: {
+    label: string;
+    value: string;
+}[];
+export interface RecurrenceConfig {
+    frequency: RecurrenceFrequencyType;
+    startDate: Date;
+    frequencySettings: FrequencySettingsValue;
+}
+export type FrequencySettingsValue = WeeklyFrequencySettingsValue | MonthlySettingsValue | YearlyFrequencySettingsValue | CustomFrequencySettingsValue;
+export interface FrequencyFieldErrors {
+    weeklyWeekdays?: string;
+    monthlyDayOrder?: string;
+    monthlyWeekDay?: string;
+    monthlyDayOfMonth?: string;
+    yearlyMonth?: string;
+    yearlyDay?: string;
+    customInterval?: string;
+    customWeekdays?: string;
+    customDayOfMonth?: string;
+}
+export type FrequencySettingsErrors = FrequencyFieldErrors;
+export interface RecurrentDatePickerErrors {
+    startDate?: string;
+    frequencySettings?: FrequencySettingsErrors;
+}
+export type RecurrentDatePickerProps = {
+    value?: RecurrenceConfig;
+    defaultValue?: RecurrenceConfig;
+    onChange?: (value: RecurrenceConfig) => void;
+    errors?: RecurrentDatePickerErrors;
+};
+declare const RecurrentDatePicker: import('react').MemoExoticComponent<(props: RecurrentDatePickerProps) => import("react/jsx-runtime").JSX.Element>;
+export default RecurrentDatePicker;

package/dist/components/RecurrentDatePicker/RecurrentDatePickerRRule.d.ts

@@ -0,0 +1,13 @@
+import { RecurrenceConfig, RecurrentDatePickerErrors } from './RecurrentDatePicker';
+export type RecurrentDatePickerRRuleProps = {
+    value?: RecurrenceConfig;
+    defaultValue?: RecurrenceConfig;
+    onChange?: (value: RecurrenceConfig) => void;
+    errors?: RecurrentDatePickerErrors;
+    onRRuleChange?: (rrule: string) => void;
+    showPreview?: boolean;
+    previewCount?: number;
+    previewUntil?: Date;
+};
+declare const RecurrentDatePickerRRule: import('react').MemoExoticComponent<(props: RecurrentDatePickerRRuleProps) => import("react/jsx-runtime").JSX.Element>;
+export default RecurrentDatePickerRRule;

package/dist/components/RecurrentDatePicker/WeekdaysSelector.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+export type weekDay = 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday' | 'sunday';
+type WeekdaySelectorProps = {
+    options?: weekDay[];
+    labelVariant?: 'short' | 'large';
+    value?: weekDay[];
+    onChange: (newValue: weekDay[]) => void;
+    label?: string;
+    required?: boolean;
+    error?: string;
+};
+declare const WeekdaysSelector: React.MemoExoticComponent<(props: WeekdaySelectorProps) => import("react/jsx-runtime").JSX.Element>;
+export default WeekdaysSelector;

package/dist/components/RecurrentDatePicker/WeeklyFrequencySetting.d.ts

@@ -0,0 +1,9 @@
+import { weekDay } from './WeekdaysSelector';
+export type WeeklyFrequencySettingsValue = weekDay[];
+interface WeeklyFrequencySettingsProps {
+    value?: WeeklyFrequencySettingsValue;
+    onChange: (value: WeeklyFrequencySettingsValue) => void;
+    error?: string;
+}
+declare const WeeklyFrequencySettings: import('react').MemoExoticComponent<({ value, onChange, error }: WeeklyFrequencySettingsProps) => import("react/jsx-runtime").JSX.Element>;
+export default WeeklyFrequencySettings;

package/dist/components/RecurrentDatePicker/YearlyFrequencySettings.d.ts

@@ -0,0 +1,21 @@
+type monthValue = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+export interface YearlyFrequencySettingsValue {
+    month: number;
+    day?: number;
+}
+export interface YearlyFrequencySettingsErrors {
+    month?: string;
+    day?: string;
+}
+interface YearlyFrequencySettingsProps {
+    value?: YearlyFrequencySettingsValue;
+    onChange: (delta: YearlyFequencyValueDelta) => void;
+    errors?: YearlyFrequencySettingsErrors;
+}
+export interface YearlyFequencyValueDelta {
+    kind: 'setMonth' | 'setDay';
+    newMonth?: monthValue;
+    newDay?: number;
+}
+declare const YearlyFrequencySettings: import('react').MemoExoticComponent<({ value, onChange, errors }: YearlyFrequencySettingsProps) => import("react/jsx-runtime").JSX.Element>;
+export default YearlyFrequencySettings;

package/dist/components/RecurrentDatePicker/recurrentDatePicker.validations.d.ts

@@ -0,0 +1,69 @@
+import { RecurrenceConfig, RecurrentDatePickerErrors } from './RecurrentDatePicker';
+export declare const dataValidations: {
+    weekly: {
+        weekDay: {
+            required: boolean;
+            type: string;
+            enum: string[];
+            minLength: number;
+            maxLength: number;
+        };
+    };
+    monthly: {
+        type: {
+            relative: {
+                dayOrder: {
+                    required: boolean;
+                    type: string;
+                    enum: string[];
+                };
+                weekDay: {
+                    required: boolean;
+                    type: string;
+                    enum: string[];
+                };
+            };
+            absolute: {
+                day: {
+                    required: boolean;
+                    type: string;
+                };
+            };
+        };
+    };
+    yearly: {
+        month: {
+            required: boolean;
+            type: string;
+            min: number;
+            max: number;
+        };
+        day: {
+            required: boolean;
+            type: string;
+        };
+    };
+    custom: {
+        frequency: {
+            monthly: {
+                dayOfMonth: {
+                    required: boolean;
+                    type: string;
+                };
+            };
+            weekly: {
+                weekDays: {
+                    required: boolean;
+                    type: string;
+                    enum: string[];
+                };
+            };
+        };
+        interval: {
+            required: boolean;
+            type: string;
+        };
+    };
+};
+export declare const validateRecurrentDatePickerValue: (value: RecurrenceConfig) => RecurrentDatePickerErrors;
+export declare const isRecurrentDatePickerValid: (value: RecurrenceConfig) => boolean;

package/dist/components/Scrollable/Scrollable.d.ts

@@ -0,0 +1,31 @@
+import { default as React } from 'react';
+type IndicatorType = 'icon' | 'shadow';
+type IndicatorProps = {
+    show?: boolean;
+    className?: string;
+    type?: IndicatorType;
+    behavior?: 'scroll-on-click' | 'scroll-on-hover' | 'none';
+};
+interface IndicatorsProps {
+    top?: IndicatorProps;
+    bottom?: IndicatorProps;
+    left?: IndicatorProps;
+    right?: IndicatorProps;
+}
+type scrollableAxis = "x" | "y" | "both";
+type ScrollbarProps = {
+    hide?: boolean;
+    size?: "small" | 'medium';
+};
+export interface ScrollableProps {
+    debugMode?: boolean;
+    className?: string;
+    indicators?: IndicatorsProps;
+    axis?: scrollableAxis;
+    children?: React.ReactNode;
+    scrollbarProps?: ScrollbarProps;
+    disableMouseScroll?: boolean;
+    defaultBehavior?: 'scroll-on-click' | 'scroll-on-hover' | 'none';
+}
+declare const Scrollable: (props: ScrollableProps) => import("react/jsx-runtime").JSX.Element;
+export default Scrollable;

package/dist/components/SegmentedButton/SegmentedButton.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+type SegmentedButtonOption = {
+    label: string;
+    value: string | number;
+};
+export interface SegmentedButtonProps {
+    name: string;
+    size?: 'small' | 'medium' | 'large';
+    color?: 'default' | 'success' | 'danger' | 'warning';
+    options: SegmentedButtonOption[];
+    value: string | number;
+    onChange?: (name: string, value: string | number) => void;
+    icon?: React.ReactElement<{
+        className: string;
+    }>;
+    allowExpand?: boolean;
+    disabled?: boolean;
+}
+declare const SegmentedButton: (props: SegmentedButtonProps) => import("react/jsx-runtime").JSX.Element;
+export default SegmentedButton;

package/dist/components/Select/Select.d.ts

@@ -0,0 +1,123 @@
+import { ComponentType, JSX, default as React } from 'react';
+import { ComponentVariant, LabelVariant, OptionAccessor } from '../Shared/types';
+import { InputProps } from '../Input/Input';
+export type SelectDisplayMode = "compact" | "chips";
+export type SelectOptionType = {
+    label: string;
+    value: string | number;
+    id: string | number;
+    isGroupHeader?: boolean;
+    groupLabelNode?: React.ReactNode;
+    groupData?: unknown;
+    originalOption?: unknown;
+};
+export type CustomSelectionDisplayProps<T> = {
+    selectedOptions: T[];
+    placeholder?: string;
+    multiple: boolean;
+    onRemoveOption: (optionId: string | number) => void;
+    disabled?: boolean;
+};
+interface SelectOptionRendererProps<T = unknown> {
+    option: SelectOptionType | T;
+    isSelected: boolean;
+    onSelect: (option: SelectOptionType) => void;
+    multiple: boolean;
+    disabled?: boolean;
+    isLoading?: boolean;
+}
+export interface CustomSelectOptionRendererProps<T, TContext = unknown> extends Omit<SelectOptionRendererProps<T>, "onSelect"> {
+    option: T;
+    onSelect: (closeOnSelect?: boolean) => void;
+    disabled?: boolean;
+    isLoading?: boolean;
+    renderContext?: TContext;
+}
+export interface CustomSelectOptionGroupHeaderProps<T, TContext = unknown> {
+    group: T;
+    label: React.ReactNode | string;
+    groupOptions: T[];
+    groupSelectedIds: string[];
+    multiple: boolean;
+    disabled?: boolean;
+    expanded: boolean;
+    toggleGroup: (nextExpanded?: boolean) => void;
+    selectGroup: (mode?: "toggle" | "select" | "deselect") => void;
+    renderContext?: TContext;
+}
+export type SelectVariant = "default" | "error" | "success";
+export type SelectControlsHandler = {
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    handleOptionSelect: (option: SelectOptionType, closeOnSelect: boolean) => void;
+    subscribeOpenChange: (cb: (open: boolean) => void) => () => void;
+    searchInputRef: React.RefObject<HTMLInputElement | null>;
+};
+export type SelectControlsRef = React.RefObject<SelectControlsHandler | null>;
+export interface DropdownOptionsProps {
+    hideSearchBar?: boolean;
+    inputProps?: Partial<InputProps>;
+    dropdownHeight?: string;
+    controledSearchValue?: string;
+    onSearchValueChange?: (value: string) => void;
+    onSearchClear?: () => void;
+    inputSearchPlaceholder?: string;
+    isLoading?: boolean;
+    footer?: React.ReactNode;
+    loadingComponent?: React.ReactNode;
+    enableGroupToggle?: boolean;
+}
+export interface BaseSelectProps<T, TContext = unknown> {
+    id?: string;
+    name?: string;
+    label: string;
+    options: T[];
+    optionLabel: OptionAccessor<T, string>;
+    optionValue: OptionAccessor<T, string | number>;
+    renderOption?: ComponentType<CustomSelectOptionRendererProps<T, TContext>>;
+    renderOptionGroupHeader?: ComponentType<CustomSelectOptionGroupHeaderProps<T, TContext>>;
+    renderSelection?: ComponentType<CustomSelectionDisplayProps<T>>;
+    renderOptionContext?: TContext;
+    disabled?: boolean;
+    className?: string;
+    isLoading?: boolean;
+    emptyMessage?: string;
+    placeholder?: string;
+    errorComponent?: React.ReactNode;
+    helperComponent?: React.ReactNode;
+    variant?: ComponentVariant;
+    overflow?: "wrap" | "scroll";
+    containerClassName?: string;
+    buttonClassName?: string;
+    dropdownClassName?: string;
+    width?: string;
+    height?: string;
+    controls?: SelectControlsRef;
+    labelVariant?: LabelVariant;
+    attachToParent?: boolean;
+    disableOpenOnFocus?: boolean;
+    onClose?: () => void;
+    onClear?: () => void;
+    onRemoveOption?: (option: T) => void;
+    onOptionClick?: (option: SelectOptionType, name?: string) => void;
+    dropdownOptions?: DropdownOptionsProps;
+}
+export interface MultipleSelectProps<T, TContext = unknown> extends BaseSelectProps<T, TContext> {
+    multiple: true;
+    value: (string | number)[];
+    onChange?: (newValue: SelectOptionType[], name?: string) => void;
+    displayMode?: "compact" | "chips";
+}
+export interface SingleSelectProps<T, TContext = unknown> extends BaseSelectProps<T, TContext> {
+    multiple?: false;
+    value: string | number | undefined;
+    onChange?: (newValue: SelectOptionType | undefined, name?: string) => void;
+    displayMode?: "compact";
+}
+export type SelectProps<T = unknown, TContext = unknown> = MultipleSelectProps<T, TContext> | SingleSelectProps<T, TContext>;
+declare const SelectWithOverloads: {
+    <T, TContext = unknown>(props: MultipleSelectProps<T, TContext>): JSX.Element;
+    <T, TContext = unknown>(props: SingleSelectProps<T, TContext>): JSX.Element;
+};
+export default SelectWithOverloads;

package/dist/components/SelectSearch/SelectSearch.d.ts

@@ -0,0 +1,40 @@
+import { ComponentType, RefObject } from 'react';
+import { CustomSelectionDisplayProps, CustomSelectOptionRendererProps, SelectControlsHandler, SelectProps } from '../Select/Select';
+import { OptionAccessor } from '../Shared/types';
+export interface SelectSearchControlsHandler extends SelectControlsHandler {
+    cleanOptions: () => void;
+}
+export type SelectSearchControlsRef = RefObject<SelectSearchControlsHandler | SelectControlsHandler | null>;
+interface SimpleSelectSearchProps<T extends object> extends BaseSelectSearchProps<T> {
+    multiple?: false;
+    value?: T | undefined;
+    onChange?: (newValue: T, name?: string) => void;
+}
+interface MultipleSelectSearchProps<T extends object> extends BaseSelectSearchProps<T> {
+    multiple: true;
+    value?: T[];
+    onChange?: (newValue: T[], name?: string) => void;
+}
+export interface BaseSelectSearchProps<T extends object> {
+    label?: string;
+    placeholder?: string;
+    name?: string;
+    options?: T[];
+    optionValue: OptionAccessor<T, string | number>;
+    optionLabel: OptionAccessor<T, string>;
+    fetcher?: (input?: string) => Promise<T[]>;
+    asyncMode?: 'fetch_in_open' | 'fetch_on_type';
+    debounceDelay?: number;
+    minCharacters?: number;
+    inputSearchPlaceholder?: string;
+    labelVariant?: 'static' | 'default';
+    disabled?: boolean;
+    className?: string;
+    renderOption?: ComponentType<CustomSelectOptionRendererProps<T>>;
+    renderSelection?: ComponentType<CustomSelectionDisplayProps<T>>;
+    controls?: SelectSearchControlsRef;
+    selectComponentProps?: Partial<Omit<SelectProps<T>, 'controls'>>;
+}
+export type SelectSearchProps<T extends object> = SimpleSelectSearchProps<T> | MultipleSelectSearchProps<T>;
+declare const SelectSearch: <T extends object>(props: SelectSearchProps<T>) => import("react/jsx-runtime").JSX.Element;
+export default SelectSearch;

package/dist/components/Shared/Chip.d.ts

@@ -0,0 +1,15 @@
+import { ComponentVariant } from './types';
+type ChipProps = {
+    id: string | number;
+    label: string;
+    onRemove?: (optionId: string | number) => void;
+    className?: string;
+    disabled?: boolean;
+    variant?: ComponentVariant;
+    tabIndex?: number;
+};
+declare const _default: import('react').MemoExoticComponent<{
+    ({ id, label, onRemove, className, disabled, variant, tabIndex }: ChipProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}>;
+export default _default;

package/dist/components/Shared/HelperComponent.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { ComponentVariant } from './types';
+export interface HelperTextProps {
+    ref?: React.RefObject<HTMLDivElement | null>;
+    children: React.ReactNode | string;
+    variant: ComponentVariant;
+    className?: string;
+}
+declare const _default: React.MemoExoticComponent<{
+    (props: HelperTextProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}>;
+export default _default;

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

@@ -0,0 +1,32 @@
+import { ReactNode } from 'react';
+export interface SecondaryBarRootProps {
+    children: ReactNode;
+    isOpen?: boolean;
+    className?: string;
+    width?: string;
+    action?: string;
+    primarySidebarCollapsed?: boolean;
+    onClose?: () => void;
+}
+export interface HeaderProps {
+    children: ReactNode;
+    className?: string;
+}
+export interface ContentProps {
+    children: ReactNode;
+    className?: string;
+}
+export interface FooterProps {
+    children: ReactNode;
+    className?: string;
+}
+export interface SpacerProps {
+    className?: string;
+}
+export declare const SecondaryBar: (({ children, isOpen, className, width, action, primarySidebarCollapsed, onClose, }: SecondaryBarRootProps) => import("react/jsx-runtime").JSX.Element) & {
+    Root: ({ children, isOpen, className, width, action, primarySidebarCollapsed, onClose, }: SecondaryBarRootProps) => import("react/jsx-runtime").JSX.Element;
+    Header: ({ children, className }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ children, className }: ContentProps) => import("react/jsx-runtime").JSX.Element;
+    Footer: ({ children, className }: FooterProps) => import("react/jsx-runtime").JSX.Element;
+    Spacer: ({ className }: SpacerProps) => import("react/jsx-runtime").JSX.Element;
+};

package/dist/components/Sidebar/SecondaryBar/hooks/useSecondaryBarAnimation.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare const useSecondaryBarAnimation: (secondaryBarRef: RefObject<HTMLDivElement | null>, isOpen: boolean) => void;

package/dist/components/Sidebar/SecondaryBar/index.d.ts

@@ -0,0 +1 @@
+export { SecondaryBar } from './SecondaryBar';

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

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+import { TabSwitchElement } from '../TabSwitch/TabSwitch';
+interface SidebarRootProps {
+    children: ReactNode;
+    isCollapsed?: boolean;
+    className?: string;
+    tabs?: TabSwitchElement[];
+    currentTabName?: string;
+}
+interface CollapseButtonProps {
+    isCollapsed: boolean;
+    onToggleCollapse: () => void;
+}
+export declare const CollapseButton: ({ isCollapsed, onToggleCollapse }: CollapseButtonProps) => import("react/jsx-runtime").JSX.Element;
+interface HeaderProps {
+    children: ReactNode;
+    className: string;
+}
+interface DividerProps {
+    className?: string;
+}
+interface ContentProps {
+    children: ReactNode;
+    className: string;
+}
+interface SpacerProps {
+    size?: 'auto' | 'small' | 'medium' | 'large' | string;
+    className?: string;
+}
+interface FooterProps {
+    children: ReactNode;
+    className?: string;
+}
+export declare const Sidebar: import('react').ForwardRefExoticComponent<SidebarRootProps & import('react').RefAttributes<HTMLDivElement>> & {
+    Root: import('react').ForwardRefExoticComponent<SidebarRootProps & import('react').RefAttributes<HTMLDivElement>>;
+    CollapseButton: ({ isCollapsed, onToggleCollapse }: CollapseButtonProps) => import("react/jsx-runtime").JSX.Element;
+    Header: ({ children, className }: HeaderProps) => import("react/jsx-runtime").JSX.Element;
+    Divider: ({ className }: DividerProps) => import("react/jsx-runtime").JSX.Element;
+    Content: ({ children, className }: ContentProps) => import("react/jsx-runtime").JSX.Element;
+    Spacer: ({ className, size }: SpacerProps) => import("react/jsx-runtime").JSX.Element;
+    Footer: ({ children, className }: FooterProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

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

@@ -0,0 +1,11 @@
+interface NavigationLinkProps {
+    children: React.ReactNode;
+    icon?: React.ReactNode;
+    label?: string;
+    href?: string;
+    onClick?: () => void;
+    isActive?: boolean;
+    className?: string;
+}
+export declare const NavigationLink: ({ children, icon, label, href, onClick, isActive, className }: NavigationLinkProps) => import("react/jsx-runtime").JSX.Element;
+export default NavigationLink;

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

@@ -0,0 +1,10 @@
+export type BadgeProps = {
+    count: number;
+    maxCount?: number;
+    className?: string;
+    size?: 'small' | 'medium' | 'large';
+    variant?: 'primary' | 'secondary' | 'success' | 'warning' | 'danger';
+    showZero?: boolean;
+    disabled?: boolean;
+};
+export declare const Badge: ({ count, maxCount, className, size, variant, showZero, disabled }: BadgeProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Sidebar/components/changue-account.d.ts

@@ -0,0 +1,5 @@
+import { ISessionLocalStorage } from '../../CardProfile/CardProfile';
+export default function ChangeAccount({ sessions, handleTokenLogin, }: {
+    readonly sessions?: ISessionLocalStorage[];
+    readonly handleTokenLogin?: (token: string) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Sidebar/components/collapse-button.d.ts

@@ -0,0 +1,5 @@
+export interface NavbarCollapseButtonProps {
+    isCollapsed: boolean;
+    onToggle: () => void;
+}
+export declare const NavbarCollapseButton: ({ isCollapsed, onToggle, }: NavbarCollapseButtonProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Sidebar/components/company-logo.d.ts

@@ -0,0 +1,5 @@
+export interface CompanyLogoProps {
+    logoUrl: string;
+    companyName?: string;
+}
+export declare const CompanyLogo: ({ logoUrl, companyName }: CompanyLogoProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/Sidebar/components/nav-actions.d.ts

@@ -0,0 +1,7 @@
+import { INavAction } from '../hooks/useNavLinks';
+export interface INavbarActionsProps {
+    linkActions: INavAction[];
+    onClick?: (actionName: string) => void;
+    activeAction?: string;
+}
+export declare const NavBarActions: ({ linkActions, onClick, activeAction, }: INavbarActionsProps) => import("react/jsx-runtime").JSX.Element;