@helloimkostya/konsolpro-custom-ui-mini 0.0.401

package/types/ui/combobox-primitive/types.d.ts

@@ -0,0 +1,74 @@
+import { default as React } from 'react';
+export type ComboboxPrimitiveSize = 'xs' | 'sm' | 'md' | 'lg';
+export interface ComboboxPrimitiveItem<T = any> {
+    value: T;
+    label: string;
+}
+export interface ComboboxPrimitiveProps<T extends object> {
+    children: React.ReactNode;
+    onChange?: (option: T | null) => void;
+    onSearch?: (value: string) => void;
+    onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
+    /** Контролируемое значение поля поиска */
+    inputValue?: string;
+    /** Поведение при выборе: держать меню открытым */
+    keepOpenOnSelect?: boolean;
+    /** Что делать со значением input при выборе элемента */
+    inputValueOnSelect?: 'selectedLabel' | 'clear' | 'preserve';
+    /** Что делать со значением input при закрытии меню */
+    inputValueOnClose?: 'selectedLabel' | 'clear' | 'preserve';
+    /** Кастомная проверка выбранности (для мультиселекта) */
+    isItemSelected?: (option: T) => boolean;
+    /** Есть ли выбранные значения (для отображения кнопки очистки) */
+    hasSelection?: boolean;
+    classNames?: {
+        scrollArea?: string;
+        scrollAreaViewport?: string;
+        menu?: string;
+    };
+    /** Размер селекта поиска */
+    size?: ComboboxPrimitiveSize;
+    /** Растягивать ли селект на всю ширину */
+    fullWidth?: boolean;
+    /** Прозрачный фон */
+    transparent?: boolean;
+    /** Лейбл */
+    label?: string;
+    /** Ошибка */
+    error?: string;
+    /** Подпись */
+    caption?: string;
+    /** Плейсхолдер для поиска */
+    placeholder?: string;
+    /** Отключен ли селект */
+    disabled?: boolean;
+    /** Тест-ид */
+    'data-testid'?: string;
+    /** Значение */
+    value?: T | null | undefined;
+    getLabel?: (value: T) => string;
+    loading?: boolean;
+    isOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+    showErrorMessage?: boolean;
+    clearable?: boolean;
+    onClear?: () => void;
+}
+export interface ListProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export interface ItemProps<T = unknown> {
+    option: T;
+    children: React.ReactNode | ((props: ItemRenderProps) => React.ReactNode);
+    className?: string;
+}
+export interface ItemRenderProps extends React.HTMLAttributes<HTMLDivElement> {
+    isSelected: boolean;
+    className?: string;
+}
+export interface ItemViewProps {
+    children: React.ReactNode | ((props: ItemRenderProps) => React.ReactNode);
+    isSelected: boolean;
+    className?: string;
+}

package/types/ui/combobox-primitive/utils.d.ts

@@ -0,0 +1,25 @@
+import { ComboboxPrimitiveSize } from './types';
+/**
+ * Генерирует CSS классы для элементов списка
+ */
+export declare function getItemClasses(isSelected: boolean, className?: string): string;
+/**
+ * Генерирует CSS классы для input элемента
+ */
+export declare function getInputClasses(size: ComboboxPrimitiveSize, fullWidth: boolean, disabled: boolean): string;
+/**
+ * Генерирует CSS классы для контейнера
+ */
+export declare function getContainerClasses(size: ComboboxPrimitiveSize, fullWidth: boolean, transparent: boolean, disabled: boolean, hasError: boolean): string;
+/**
+ * Генерирует CSS классы для лейбла
+ */
+export declare function getLabelClasses(size: ComboboxPrimitiveSize): string;
+/**
+ * Генерирует CSS классы для floating меню
+ */
+export declare function getFloatingMenuClasses(isMounted: boolean, hasItems: boolean): string;
+/**
+ * Определяет есть ли ошибка
+ */
+export declare function hasError(error?: string): boolean;

package/types/ui/combobox.d.ts

@@ -0,0 +1,34 @@
+import { default as React } from 'react';
+import { ButtonSize } from './button';
+export type ComboboxSize = 'xs' | 'sm' | 'md' | 'lg';
+export interface ComboboxOption {
+    value: string | number;
+    label?: React.ReactNode | string;
+}
+export interface ComboboxProps {
+    /** Элементы списка */
+    options: ComboboxOption[];
+    /** Текущее значение */
+    value: string | number | null;
+    /** Сallback при выборе */
+    onChange: (value: string | number) => void;
+    /** Размер (как в старом Select) */
+    size?: ComboboxSize;
+    /** Лейбл над полем */
+    label?: string;
+    /** Плейсхолдер в поиске */
+    searchPlaceholder?: string;
+    /** Ошибка */
+    error?: string;
+    /** Фулл-ширина */
+    fullWidth?: boolean;
+    /** disabled */
+    disabled?: boolean;
+    /** размер кнопки */
+    sizeButton?: ButtonSize;
+    iconSize?: number;
+    placeholder?: string;
+    dropDownClassName?: string;
+    notFoundText?: string;
+}
+export declare const Combobox: React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLButtonElement>>;

package/types/ui/command.d.ts

@@ -0,0 +1,78 @@
+import { default as React } from 'react';
+declare const Command: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandInput: React.ForwardRefExoticComponent<Omit<Omit<Pick<Pick<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "key" | keyof React.InputHTMLAttributes<HTMLInputElement>> & {
+    ref?: React.Ref<HTMLInputElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.InputHTMLAttributes<HTMLInputElement>>, "type" | "onChange" | "value"> & {
+    value?: string;
+    onValueChange?: (search: string) => void;
+} & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const CommandList: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    label?: string;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandEmpty: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandGroup: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "heading" | "value"> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandSeparator: React.ForwardRefExoticComponent<Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    alwaysRender?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const CommandItem: React.ForwardRefExoticComponent<Omit<{
+    children?: React.ReactNode;
+} & Omit<Pick<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "key" | keyof React.HTMLAttributes<HTMLDivElement>> & {
+    ref?: React.Ref<HTMLDivElement>;
+} & {
+    asChild?: boolean;
+}, "key" | "asChild" | keyof React.HTMLAttributes<HTMLDivElement>>, "onSelect" | "disabled" | "value"> & {
+    disabled?: boolean;
+    onSelect?: (value: string) => void;
+    value?: string;
+    keywords?: string[];
+    forceMount?: boolean;
+} & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare function CommandShortcut({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
+declare namespace CommandShortcut {
+    var displayName: string;
+}
+export { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator, CommandShortcut, };

package/types/ui/customizable-carousel.d.ts

@@ -0,0 +1,148 @@
+import { default as React } from 'react';
+import { EmblaCarouselType, EmblaOptionsType } from 'embla-carousel';
+import { default as useEmblaCarousel } from 'embla-carousel-react';
+export interface IndicatorOptions {
+    show: boolean;
+    position: 'inside' | 'outside';
+    align: 'start' | 'center' | 'end' | 'stretch';
+    className?: string;
+    activeClassName: string;
+    inactiveClassName: string;
+}
+export interface UseCarouselOptions extends EmblaOptionsType {
+    defaultActive?: number;
+    indicators?: Partial<IndicatorOptions>;
+}
+export interface UseCarouselState {
+    active: number;
+    emblaRef: ReturnType<typeof useEmblaCarousel>[0];
+    embla: EmblaCarouselType | undefined;
+    indicatorOptions: IndicatorOptions;
+    next: () => void;
+    prev: () => void;
+    scrollTo: (index: number) => void;
+    onChange: (index: number) => void;
+    canScrollNext: boolean;
+    canScrollPrev: boolean;
+}
+export declare function useCarousel(options?: UseCarouselOptions): UseCarouselState;
+export declare function useCarouselContext(): UseCarouselState;
+interface CarouselProps {
+    children: React.ReactNode;
+    className?: string;
+    options?: UseCarouselOptions;
+}
+declare function CarouselRoot({ children, className, options }: CarouselProps): import("react/jsx-runtime").JSX.Element;
+interface CarouselItemsProps {
+    items: React.ReactNode[];
+    className?: string;
+    slideClassName?: string;
+}
+declare function CarouselItems({ items, className, slideClassName }: CarouselItemsProps): import("react/jsx-runtime").JSX.Element;
+export interface CarouselContentProps {
+    items: Array<{
+        title?: React.ReactNode;
+        text?: React.ReactNode;
+        [key: string]: any;
+    }>;
+    className?: string;
+    titleClassName?: string;
+    textClassName?: string;
+}
+declare function CarouselContent({ items, className, titleClassName, textClassName, }: CarouselContentProps): import("react/jsx-runtime").JSX.Element;
+export interface CarouselContentViewProps {
+    item: {
+        title?: React.ReactNode;
+        text?: React.ReactNode;
+        [key: string]: any;
+    };
+    className?: string;
+    titleClassName?: string;
+    textClassName?: string;
+}
+export declare function CarouselContentView({ item, className, titleClassName, textClassName, }: CarouselContentViewProps): import("react/jsx-runtime").JSX.Element;
+export interface CarouselButtonsProps {
+    prevButton?: React.ReactNode | ((props: {
+        onClick: () => void;
+        disabled: boolean;
+    }) => React.ReactNode);
+    nextButton?: React.ReactNode | ((props: {
+        onClick: () => void;
+        disabled: boolean;
+    }) => React.ReactNode);
+    className?: string;
+    buttonsPosition?: 'inside' | 'outside';
+    buttonsAlign?: 'start' | 'center' | 'end' | 'sides';
+    showOnlyOnHover?: boolean;
+    hideDisabled?: boolean;
+}
+declare function CarouselButtons({ prevButton, nextButton, className, buttonsPosition, buttonsAlign, showOnlyOnHover, hideDisabled, }: CarouselButtonsProps): import("react/jsx-runtime").JSX.Element | null;
+export interface CarouselButtonsViewProps {
+    onPrev: () => void;
+    onNext: () => void;
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+    prevButton?: React.ReactNode | ((props: {
+        onClick: () => void;
+        disabled: boolean;
+    }) => React.ReactNode);
+    nextButton?: React.ReactNode | ((props: {
+        onClick: () => void;
+        disabled: boolean;
+    }) => React.ReactNode);
+    className?: string;
+    buttonsPosition?: 'inside' | 'outside';
+    buttonsAlign?: 'start' | 'center' | 'end' | 'sides';
+    showOnlyOnHover?: boolean;
+    hideDisabled?: boolean;
+}
+export declare function CarouselButtonsView({ onPrev, onNext, canScrollPrev, canScrollNext, prevButton, nextButton, className, buttonsPosition, buttonsAlign, showOnlyOnHover, hideDisabled, }: CarouselButtonsViewProps): import("react/jsx-runtime").JSX.Element | null;
+export interface CarouselDotsViewProps {
+    active: number;
+    count: number;
+    onChange: (index: number) => void;
+    show?: boolean;
+    position?: 'inside' | 'outside';
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    className?: string;
+    activeClassName?: string;
+    inactiveClassName?: string;
+}
+export declare function CarouselDotsView({ active, count, onChange, show, position, align, className, activeClassName, inactiveClassName, }: CarouselDotsViewProps): import("react/jsx-runtime").JSX.Element | null;
+interface CarouselDotsProps {
+    className?: string;
+    count?: number;
+}
+declare function CarouselDots({ className, count }: CarouselDotsProps): import("react/jsx-runtime").JSX.Element;
+export declare const Carousel: {
+    Root: typeof CarouselRoot;
+    Items: typeof CarouselItems;
+    Dots: typeof CarouselDots;
+    DotsView: typeof CarouselDotsView;
+    Content: typeof CarouselContent;
+    ContentView: typeof CarouselContentView;
+    Buttons: typeof CarouselButtons;
+    ButtonsView: typeof CarouselButtonsView;
+};
+export interface DefaultHeadlessCarouselProps<T> extends Omit<React.HTMLAttributes<HTMLDivElement>, 'children'> {
+    items: T[];
+    renderSlide: (item: T, index: number) => React.ReactNode;
+    options?: UseCarouselOptions;
+    slideClassName?: string;
+    prevButton?: React.ReactNode;
+    nextButton?: React.ReactNode;
+    buttonsPosition?: 'inside' | 'outside';
+    buttonsAlign?: 'start' | 'center' | 'end' | 'sides';
+    showButtonsOnlyOnHover?: boolean;
+    hideDisabledButtons?: boolean;
+}
+export declare function DefaultCustomizableCarousel<T>({ items, renderSlide, options, className, slideClassName, prevButton, nextButton, buttonsPosition, buttonsAlign, showButtonsOnlyOnHover, hideDisabledButtons, ...divProps }: DefaultHeadlessCarouselProps<T>): import("react/jsx-runtime").JSX.Element;
+interface HeadlessCarouselProps<T> {
+    items: T[];
+    options?: UseCarouselOptions;
+    renderItems: (state: UseCarouselState, items: T[]) => React.ReactNode;
+    renderControls?: (state: UseCarouselState, items: T[]) => React.ReactNode;
+    className?: string;
+}
+export declare function HeadlessCarousel<T>({ items, options, renderItems, renderControls, className, }: HeadlessCarouselProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/types/ui/date-picker.d.ts

@@ -0,0 +1,37 @@
+import { ButtonSize } from './button';
+type DatePickerSize = Exclude<ButtonSize, 'sm'>;
+interface CalendarDateAfter {
+    after: Date;
+}
+interface CalendarDateBefore {
+    before: Date;
+}
+interface CalendarDateInterval {
+    before: Date;
+    after: Date;
+}
+interface CalendarDateRange {
+    from: Date | undefined;
+    to?: Date | undefined;
+}
+interface CalendarDayOfWeek {
+    dayOfWeek: number[];
+}
+type CalendarDisabledMatcher = boolean | ((date: Date) => boolean) | Date | Date[] | CalendarDateRange | CalendarDateBefore | CalendarDateAfter | CalendarDateInterval | CalendarDayOfWeek;
+export interface DatePickerProps {
+    date?: Date | undefined;
+    onSelect?: (date: Date | undefined) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+    size?: DatePickerSize;
+    error?: string;
+    caption?: string;
+    label?: string;
+    showResetButton?: boolean;
+    onReset?: () => void;
+    disabledDays?: CalendarDisabledMatcher | CalendarDisabledMatcher[];
+    'data-testid'?: string;
+}
+export declare function DatePicker({ date, onSelect, disabled, placeholder, className, size, error, caption, label, showResetButton, onReset, disabledDays, 'data-testid': dataTestId, }: DatePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/types/ui/date-range-picker/constants.d.ts

@@ -0,0 +1,22 @@
+export declare const translations: {
+    ru: {
+        selectPeriod: string;
+        reset: string;
+        placeholder: string;
+    };
+    en: {
+        selectPeriod: string;
+        reset: string;
+        placeholder: string;
+    };
+    uz: {
+        selectPeriod: string;
+        reset: string;
+        placeholder: string;
+    };
+    tg: {
+        selectPeriod: string;
+        reset: string;
+        placeholder: string;
+    };
+};

package/types/ui/date-range-picker/locales.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from 'date-fns';
+export declare const uz: Locale;
+export declare const tg: Locale;

package/types/ui/date-range-picker.d.ts

@@ -0,0 +1,46 @@
+import { default as React } from 'react';
+import { DateRange } from 'react-day-picker';
+import { ButtonSize } from './button';
+type DateRangePickerSize = Exclude<ButtonSize, 'sm'>;
+interface CalendarDateAfter {
+    after: Date;
+}
+interface CalendarDateBefore {
+    before: Date;
+}
+interface CalendarDateInterval {
+    before: Date;
+    after: Date;
+}
+interface CalendarDateRange {
+    from: Date | undefined;
+    to?: Date | undefined;
+}
+interface CalendarDayOfWeek {
+    dayOfWeek: number[];
+}
+type CalendarDisabledMatcher = boolean | ((date: Date) => boolean) | Date | Date[] | CalendarDateRange | CalendarDateBefore | CalendarDateAfter | CalendarDateInterval | CalendarDayOfWeek;
+export interface DateRangeError {
+    from?: string;
+    to?: string;
+}
+export interface DateRangePickerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'value' | 'onDateChange'> {
+    value?: DateRange;
+    size?: DateRangePickerSize;
+    onDateChange?: (date: DateRange | undefined) => void;
+    placeholder?: {
+        from?: string;
+        to?: string;
+    };
+    disabled?: boolean;
+    error?: string | DateRangeError;
+    caption?: string;
+    label?: string;
+    showResetButton?: boolean;
+    onReset?: () => void;
+    locale?: 'ru' | 'en' | 'uz' | 'tg';
+    'data-testid'?: string;
+    disabledDays?: CalendarDisabledMatcher | CalendarDisabledMatcher[];
+}
+export declare function DateRangePicker({ className, value, locale, onDateChange, placeholder, error, caption, label, size, disabled, showResetButton, onReset, disabledDays, 'data-testid': dataTestId, ...props }: DateRangePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/types/ui/dialog/dialog-base/dialog-base.d.ts

@@ -0,0 +1,46 @@
+import { default as React } from 'react';
+import { DialogPrimitiveContainerProps } from '../dialog-primitive';
+export type DialogStatusImage = 'document-approved' | 'document-sign' | 'documents-refresh' | 'status-error' | 'status-success' | 'status-warning' | 'user-add' | 'user-approved' | 'user-question' | 'wallet';
+export type DialogBaseProps = React.PropsWithChildren<DialogPrimitiveContainerProps & {
+    trigger?: React.ReactNode;
+    visibleClose?: boolean;
+    visibleOverlay?: boolean;
+    diableOutsideClick?: boolean;
+    hideFooter?: boolean;
+    statusImage?: DialogStatusImage;
+    classNames?: {
+        container?: string;
+        title?: string;
+        content?: string;
+        header?: string;
+        close?: string;
+        footer?: string;
+        overlay?: string;
+    };
+    baseZIndex?: number;
+    onOpenChange?: (open: boolean) => void;
+}>;
+export declare function DialogBase({ classNames, children, trigger, visibleClose, width: initialWidth, visibleOverlay, diableOutsideClick, disableAutoFocus, hideFooter, baseZIndex, statusImage, dataTestId, ...props }: DialogBaseProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace DialogBase {
+    var displayName: string;
+    var Trigger: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-dialog").DialogTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    var Close: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-dialog").DialogCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+        dataTestId?: string;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    var Footer: (props: {
+        children: React.ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    var Content: (props: {
+        children: React.ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    var Title: (props: {
+        children: React.ReactNode;
+    }) => import("react/jsx-runtime").JSX.Element;
+    var Overlay: React.ForwardRefExoticComponent<Omit<import("@radix-ui/react-dialog").DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+    var Portal: React.FC<import("@radix-ui/react-dialog").DialogPortalProps>;
+    var Dialog: React.FC<import("@radix-ui/react-dialog").DialogProps>;
+    var Container: React.ForwardRefExoticComponent<DialogPrimitiveContainerProps & React.RefAttributes<HTMLDivElement>>;
+    var Header: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+        shadow?: "bottom" | "none";
+    } & React.RefAttributes<HTMLDivElement>>;
+}

package/types/ui/dialog/dialog-base/index.d.ts

@@ -0,0 +1,3 @@
+export { DialogBase } from './dialog-base';
+export type { DialogBaseProps } from './dialog-base';
+export { type BaseDialogContextValue, type BaseDialogProviderProps, useDialogBaseCtx, } from './use-base-dialog';

package/types/ui/dialog/dialog-base/use-base-dialog.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { DialogPrimitiveWidth } from '../dialog-primitive';
+import { DialogStatusImage } from './dialog-base';
+interface UseDialogBaseProps {
+    isVisibleClose: boolean;
+    width: DialogPrimitiveWidth;
+    hideFooter: boolean;
+    baseZIndex: number;
+    statusImage?: DialogStatusImage;
+}
+export interface BaseDialogContextValue {
+    contentElement: React.ElementRef<'div'> | null;
+    shadowFooter: 'top' | 'none';
+    shadowHeader: 'bottom' | 'none';
+    hasOverflow: boolean;
+    scrollStart: boolean;
+    isHideFooter: boolean;
+    isHideTitle: boolean;
+    isVisibleClose: boolean;
+    width: DialogPrimitiveWidth;
+    statusImage?: DialogStatusImage;
+    hideFooter: (hide: boolean) => void;
+    hideTitle: (hide: boolean) => void;
+    visibleClose: (visible: boolean) => void;
+    setContentElement: (element: React.ElementRef<'div'> | null) => void;
+    setWidth: (width: DialogPrimitiveWidth) => void;
+    baseZIndex: number;
+    overlayZIndex: number;
+    containerZIndex: number;
+    nextBaseZIndex: number;
+}
+export declare const BaseDialogContext: React.Context<BaseDialogContextValue | null>;
+export interface BaseDialogProviderProps {
+    children: React.ReactNode;
+}
+export declare function useDialogBaseCtx(): BaseDialogContextValue;
+export declare function useDialogBase(props: UseDialogBaseProps): BaseDialogContextValue;
+export {};

package/types/ui/dialog/dialog-primitive/dialog-primitive.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import * as RadixDialog from '@radix-ui/react-dialog';
+export type DialogPrimitiveWidth = 'sm' | 'md' | 'lg' | 'full';
+export type DialogPrimitivePadding = 'none' | 'md';
+export interface DialogPrimitiveContainerProps {
+    open?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+    width?: DialogPrimitiveWidth;
+    padding?: DialogPrimitivePadding;
+    overflow?: boolean;
+    disableAutoFocus?: boolean;
+    disableOutsideClick?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onOpenAutoFocus?: (event: Event) => void;
+    onInteractOutside?: (event: Event) => void;
+    dataTestId?: string;
+    style?: React.CSSProperties;
+}
+declare const Dialog: React.FC<RadixDialog.DialogProps>;
+declare const Portal: React.FC<RadixDialog.DialogPortalProps>;
+declare const Trigger: React.ForwardRefExoticComponent<Omit<RadixDialog.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const Overlay: React.ForwardRefExoticComponent<Omit<RadixDialog.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Container: React.ForwardRefExoticComponent<DialogPrimitiveContainerProps & React.RefAttributes<HTMLDivElement>>;
+declare const Content: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    dataTestId?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Title: React.ForwardRefExoticComponent<Omit<import('../../typography').TypographyProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    dataTestId?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Footer: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    shadow?: "top" | "none";
+    dataTestId?: string;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const Close: React.ForwardRefExoticComponent<Omit<RadixDialog.DialogCloseProps & React.RefAttributes<HTMLButtonElement>, "ref"> & {
+    dataTestId?: string;
+} & React.RefAttributes<HTMLButtonElement>>;
+export { Close, Container, Content, Dialog, Footer, Overlay, Portal, Title, Trigger, };

package/types/ui/dialog/dialog-primitive/index.d.ts

@@ -0,0 +1,2 @@
+export * as DialogPrimitive from './dialog-primitive';
+export type { DialogPrimitiveContainerProps, DialogPrimitiveWidth } from './dialog-primitive';

package/types/ui/dialog/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dialog-base';
+export * from './dialog-primitive';

package/types/ui/dialog/utils.d.ts

@@ -0,0 +1,6 @@
+export declare const shadowVariants: (props?: ({
+    top?: boolean | null | undefined;
+    bottom?: boolean | null | undefined;
+    none?: boolean | null | undefined;
+    all?: boolean | null | undefined;
+} & import('class-variance-authority/dist/types').ClassProp) | undefined) => string;

package/types/ui/divider.d.ts

@@ -0,0 +1,6 @@
+interface DividerProps {
+    className?: string;
+}
+declare function Divider({ className }: DividerProps): import("react/jsx-runtime").JSX.Element;
+export { Divider };
+export type { DividerProps };