brd-ui-kit 0.1.73 → 0.1.76

package/dist/components/basic-chart/basic-chart.d.ts

@@ -6,7 +6,7 @@ type Props = {
     chartContainer?: React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
         config: ChartConfig;
     };
-    barChart?: CartesianChartProps<any> & {
+    barChart?: CartesianChartProps<Record<string, unknown>> & {
         ref?: React.Ref<SVGSVGElement> | undefined;
     };
     cartesianGrid?: React.ComponentProps<typeof CartesianGrid>;

package/dist/components/basic-table/basic-table.d.ts

@@ -1,9 +1,30 @@
-import { ColumnDef, ColumnFiltersState, PaginationState, SortingState, Updater } from '@tanstack/react-table';
+import { ColumnDef, ColumnFiltersState, PaginationState, Row, RowSelectionState, SortingState, Table as TanStackTable, Updater, VisibilityState } from '@tanstack/react-table';
+import { CSSProperties, ReactNode } from 'react';
+export type DataTableColumnMeta<TData = unknown> = {
+    className?: string;
+    headClassName?: string;
+    cellClassName?: string;
+    style?: CSSProperties;
+    headStyle?: CSSProperties;
+    cellStyle?: CSSProperties;
+    editable?: boolean;
+    editKey?: Extract<keyof TData, string>;
+    editComponent?: "input" | "textarea";
+    editClassName?: string;
+    editPlaceholder?: string;
+    getEditValue?: (row: TData) => string;
+};
 export interface DataTableProps<TData, TValue> {
     columns: ColumnDef<TData, TValue>[];
     data: TData[];
+    emptyState?: ReactNode;
     sorting?: SortingState;
     columnFilters?: ColumnFiltersState;
+    columnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: (updater: Updater<VisibilityState>) => void;
+    rowSelection?: RowSelectionState;
+    onRowSelectionChange?: (updater: Updater<RowSelectionState>) => void;
+    getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
     pagination?: PaginationState;
     globalFilter?: string;
     setGlobalFilter?: (value: string) => void;
@@ -12,13 +33,23 @@ export interface DataTableProps<TData, TValue> {
     onPaginationChange?: (updater: Updater<PaginationState>) => void;
     rowClickable?: boolean;
     onRowClick?: (row: TData) => void;
+    onTableChange?: (table: TanStackTable<TData>) => void;
+    editableRowId?: string | null;
+    editingValues?: Record<string, string>;
+    onEditingValuesChange?: (updater: Updater<Record<string, string>>) => void;
+    autoResetPageIndex?: boolean;
     className?: {
         className?: string;
         tableClassName?: string;
         headerClassName?: string;
         rowClassName?: string;
+        headRowClassName?: string;
+        bodyRowClassName?: string;
+        editingRowClassName?: string;
+        emptyRowClassName?: string;
         cellClassName?: string;
         headCellClassName?: string;
+        emptyCellClassName?: string;
     };
 }
-export declare function BasicTable<TData, TValue>({ columns, data, sorting, columnFilters, pagination, globalFilter, setGlobalFilter, onSortingChange, onColumnFiltersChange, onPaginationChange, rowClickable, onRowClick, className, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export declare function BasicTable<TData, TValue>({ columns, data, emptyState, sorting, columnFilters, columnVisibility, onColumnVisibilityChange, rowSelection, onRowSelectionChange, getRowId, pagination, globalFilter, setGlobalFilter, onSortingChange, onColumnFiltersChange, onPaginationChange, rowClickable, onRowClick, onTableChange, editableRowId, editingValues, onEditingValuesChange, autoResetPageIndex, className, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;

package/dist/components/basic-table/index.d.ts

@@ -1 +1 @@
-export { BasicTable, type DataTableProps } from './basic-table';
+export { BasicTable, type DataTableColumnMeta, type DataTableProps } from './basic-table';

package/dist/components/data-table/data-table-actions-column.d.ts

@@ -0,0 +1,23 @@
+import { ColumnDef, Row } from '@tanstack/react-table';
+import { ReactNode } from 'react';
+import { DropdownMenuConfigNode } from '../ui/dropdown-menu';
+type DataTableActionsColumnOptions<TData> = {
+    id?: string;
+    header?: ColumnDef<TData>["header"];
+    renderCell?: (ctx: {
+        row: Row<TData>;
+        data: TData;
+    }) => ReactNode;
+    trigger?: (ctx: {
+        row: Row<TData>;
+        data: TData;
+    }) => ReactNode;
+    menuItems?: DropdownMenuConfigNode[] | ((ctx: {
+        row: Row<TData>;
+        data: TData;
+    }) => DropdownMenuConfigNode[]);
+    align?: "start" | "center" | "end";
+    ariaLabel?: string;
+};
+export declare function createDataTableActionsColumn<TData>(options?: DataTableActionsColumnOptions<TData>): ColumnDef<TData>;
+export type { DataTableActionsColumnOptions };

package/dist/components/data-table/data-table-bulk-actions.d.ts

@@ -0,0 +1,20 @@
+import { Row, Table } from '@tanstack/react-table';
+import { ReactNode } from 'react';
+import { DropdownMenuConfigNode } from '../ui/dropdown-menu';
+type DataTableBulkActionsContext<TData> = {
+    table: Table<TData>;
+    selectedRows: Row<TData>[];
+    selectedData: TData[];
+    count: number;
+    clearSelection: () => void;
+};
+type DataTableBulkActionsProps<TData> = {
+    table: Table<TData>;
+    children?: (ctx: DataTableBulkActionsContext<TData>) => ReactNode;
+    trigger?: ReactNode | ((ctx: DataTableBulkActionsContext<TData>) => ReactNode);
+    menuItems?: DropdownMenuConfigNode[] | ((ctx: DataTableBulkActionsContext<TData>) => DropdownMenuConfigNode[]);
+    onDeleteSelected?: (ctx: DataTableBulkActionsContext<TData>) => void;
+};
+declare function DataTableBulkActions<TData>({ table, children, trigger, menuItems, onDeleteSelected, }: DataTableBulkActionsProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export { DataTableBulkActions };
+export type { DataTableBulkActionsContext, DataTableBulkActionsProps };

package/dist/components/data-table/data-table-column-visibility.d.ts

@@ -0,0 +1,17 @@
+import { Table, Updater, VisibilityState } from '@tanstack/react-table';
+import { ReactNode } from 'react';
+type DataTableColumnVisibilityProps<TData> = {
+    table: Table<TData>;
+    columnVisibility?: VisibilityState;
+    onColumnVisibilityChange?: (updater: Updater<VisibilityState>) => void;
+    triggerLabel?: string;
+    trigger?: ReactNode;
+    menuLabel?: string;
+    includeColumnIds?: string[];
+    excludeColumnIds?: string[];
+    align?: "start" | "center" | "end";
+    dropdownWidthClassName?: string;
+};
+declare function DataTableColumnVisibility<TData>({ table, columnVisibility, onColumnVisibilityChange, triggerLabel, trigger, menuLabel, includeColumnIds, excludeColumnIds, align, dropdownWidthClassName, }: DataTableColumnVisibilityProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export { DataTableColumnVisibility };
+export type { DataTableColumnVisibilityProps };

package/dist/components/data-table/data-table-editable-column.d.ts

@@ -0,0 +1,12 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { DataTableColumnMeta } from '../basic-table';
+type DataTableEditableColumnOptions<TData> = {
+    editKey?: DataTableColumnMeta<TData>["editKey"];
+    editComponent?: DataTableColumnMeta<TData>["editComponent"];
+    editClassName?: DataTableColumnMeta<TData>["editClassName"];
+    editPlaceholder?: DataTableColumnMeta<TData>["editPlaceholder"];
+    getEditValue?: DataTableColumnMeta<TData>["getEditValue"];
+};
+declare function withDataTableEditableColumn<TData, TValue>(column: ColumnDef<TData, TValue>, options?: DataTableEditableColumnOptions<TData>): ColumnDef<TData, TValue>;
+export { withDataTableEditableColumn };
+export type { DataTableEditableColumnOptions };

package/dist/components/data-table/data-table-filter.d.ts

@@ -0,0 +1,12 @@
+import { Table } from '@tanstack/react-table';
+import { ComponentProps } from 'react';
+import { Input } from '../ui/input';
+type DataTableFilterProps<TData> = {
+    table: Table<TData>;
+    searchableColumnIds?: string[];
+    placeholder?: string;
+    inputProps?: Omit<ComponentProps<typeof Input>, "value" | "onChange">;
+};
+declare function DataTableFilter<TData>({ table, searchableColumnIds, placeholder, inputProps, }: DataTableFilterProps<TData>): import("react/jsx-runtime").JSX.Element;
+export { DataTableFilter };
+export type { DataTableFilterProps };

package/dist/components/data-table/data-table-row-actions-column.d.ts

@@ -0,0 +1,53 @@
+import { ColumnDef, Row } from '@tanstack/react-table';
+import { IconName } from 'phosphor-strokes-icons/by-name';
+import { ReactNode } from 'react';
+type DataTableRowActionContext<TData> = {
+    row: Row<TData>;
+    data: TData;
+};
+type DataTableRowActionBase = {
+    hidden?: boolean;
+    id?: string;
+};
+type DataTableRowActionLabel = DataTableRowActionBase & {
+    label: string;
+    type: "label";
+};
+type DataTableRowActionSeparator = DataTableRowActionBase & {
+    type: "separator";
+};
+type DataTableRowActionItem<TData> = DataTableRowActionBase & {
+    type?: "item";
+    label: string;
+    icon?: ReactNode;
+    iconType?: IconName;
+    shortcut?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    alert?: boolean;
+    children?: DataTableRowActionNode<TData>[];
+    onSelect?: (ctx: DataTableRowActionContext<TData>) => void;
+};
+type DataTableRowActionNode<TData> = DataTableRowActionItem<TData> | DataTableRowActionLabel | DataTableRowActionSeparator;
+type DataTableRowActionsColumnOptions<TData> = {
+    id?: string;
+    header?: ColumnDef<TData>["header"];
+    align?: "start" | "center" | "end";
+    editingRowId?: string | null;
+    trigger?: (ctx: DataTableRowActionContext<TData>) => ReactNode;
+    actions?: DataTableRowActionNode<TData>[] | ((ctx: DataTableRowActionContext<TData>) => DataTableRowActionNode<TData>[]);
+    onStartEdit?: (ctx: DataTableRowActionContext<TData>) => void;
+    onSaveEdit?: (ctx: DataTableRowActionContext<TData>) => void;
+    onCancelEdit?: (ctx: DataTableRowActionContext<TData>) => void;
+    onDelete?: (ctx: DataTableRowActionContext<TData>) => void;
+    includeDefaultActions?: boolean;
+    labels?: {
+        cancelAriaLabel?: string;
+        delete?: string;
+        edit?: string;
+        empty?: string;
+        saveAriaLabel?: string;
+    };
+};
+export declare function createDataTableRowActionsColumn<TData>(options?: DataTableRowActionsColumnOptions<TData>): ColumnDef<TData>;
+export type { DataTableRowActionContext, DataTableRowActionItem, DataTableRowActionLabel, DataTableRowActionNode, DataTableRowActionSeparator, DataTableRowActionsColumnOptions, };

package/dist/components/data-table/data-table-select-column.d.ts

@@ -0,0 +1,2 @@
+import { ColumnDef } from '@tanstack/react-table';
+export declare function createDataTableSelectColumn<TData>(): ColumnDef<TData>;

package/dist/components/data-table/data-table.d.ts

@@ -0,0 +1,2 @@
+import { DataTableProps } from '../basic-table';
+export declare function DataTable<TData, TValue>({ className, ...props }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;

package/dist/components/data-table/data-table.styles.d.ts

@@ -0,0 +1,8 @@
+export declare const dataTableContainerClassName = "w-full overflow-hidden rounded-xl border border-delicate-border bg-primary-bg";
+export declare const dataTableTableClassName = "w-full";
+export declare const dataTableHeadRowClassName = "h-13 border-delicate-border hover:bg-transparent data-[state=selected]:bg-transparent";
+export declare const dataTableBodyRowClassName = "h-15 border-delicate-border hover:bg-transparent data-[state=selected]:bg-transparent";
+export declare const dataTableEditingRowClassName = "h-[7.5rem]";
+export declare const dataTableHeadCellClassName: string;
+export declare const dataTableCellClassName: string;
+export declare const dataTableEmptyCellClassName = "h-24 text-center";

package/dist/components/data-table/index.d.ts

@@ -0,0 +1,17 @@
+export { DataTable } from './data-table';
+export type { DataTableColumnMeta, DataTableProps } from '../basic-table';
+export { createDataTableActionsColumn } from './data-table-actions-column';
+export type { DataTableActionsColumnOptions } from './data-table-actions-column';
+export { withDataTableEditableColumn } from './data-table-editable-column';
+export type { DataTableEditableColumnOptions } from './data-table-editable-column';
+export { createDataTableRowActionsColumn } from './data-table-row-actions-column';
+export type { DataTableRowActionContext, DataTableRowActionItem, DataTableRowActionLabel, DataTableRowActionNode, DataTableRowActionSeparator, DataTableRowActionsColumnOptions, } from './data-table-row-actions-column';
+export { DataTableBulkActions } from './data-table-bulk-actions';
+export type { DataTableBulkActionsContext, DataTableBulkActionsProps, } from './data-table-bulk-actions';
+export { DataTableColumnVisibility } from './data-table-column-visibility';
+export type { DataTableColumnVisibilityProps } from './data-table-column-visibility';
+export { DataTableFilter } from './data-table-filter';
+export type { DataTableFilterProps } from './data-table-filter';
+export { createDataTableSelectColumn } from './data-table-select-column';
+export { useDataTableEditableRows } from './use-data-table-editable-rows';
+export type { DataTableRowDeleteEvent, DataTableRowEditCancelEvent, DataTableRowEditSaveEvent, DataTableRowEditStartEvent, DataTableRowsChangeEvent, EditableRowKey, UseDataTableEditableRowsOptions, } from './use-data-table-editable-rows';

package/dist/components/data-table/use-data-table-editable-rows.d.ts

@@ -0,0 +1,60 @@
+import { Dispatch, SetStateAction } from 'react';
+type EditableRowKey<TData> = Extract<keyof TData, string>;
+type EditableValues = Record<string, string>;
+type DataTableRowEditStartEvent<TData> = {
+    editableKeys: readonly EditableRowKey<TData>[];
+    initialValues: EditableValues;
+    row: TData;
+    rowId: string;
+};
+type DataTableRowEditCancelEvent<TData> = {
+    editingValues: EditableValues;
+    row: TData | null;
+    rowId: string | null;
+};
+type DataTableRowEditSaveEvent<TData> = {
+    editingValues: EditableValues;
+    nextRow: TData;
+    previousRow: TData;
+    rowId: string;
+};
+type DataTableRowDeleteEvent<TData> = {
+    row: TData;
+    rowId: string;
+};
+type DataTableRowsChangeEvent<TData> = ({
+    nextRows: TData[];
+    previousRows: TData[];
+    type: "edit-save";
+} & DataTableRowEditSaveEvent<TData>) | ({
+    nextRows: TData[];
+    previousRows: TData[];
+    type: "delete";
+} & DataTableRowDeleteEvent<TData>);
+type UseDataTableEditableRowsOptions<TData> = {
+    rows: TData[];
+    getRowId: (row: TData) => string;
+    setRows?: Dispatch<SetStateAction<TData[]>>;
+    editingRowId?: string | null;
+    onEditingRowIdChange?: (rowId: string | null) => void;
+    editingValues?: EditableValues;
+    onEditingValuesChange?: Dispatch<SetStateAction<EditableValues>>;
+    onRowDelete?: (event: DataTableRowDeleteEvent<TData>) => void;
+    onRowEditCancel?: (event: DataTableRowEditCancelEvent<TData>) => void;
+    onRowEditSave?: (event: DataTableRowEditSaveEvent<TData>) => void;
+    onRowEditStart?: (event: DataTableRowEditStartEvent<TData>) => void;
+    onRowsChange?: (event: DataTableRowsChangeEvent<TData>) => void;
+};
+declare function useDataTableEditableRows<TData>({ rows, getRowId, setRows, editingRowId: controlledEditingRowId, onEditingRowIdChange, editingValues: controlledEditingValues, onEditingValuesChange, onRowDelete, onRowEditCancel, onRowEditSave, onRowEditStart, onRowsChange, }: UseDataTableEditableRowsOptions<TData>): {
+    autoResetPageIndex: boolean;
+    cancelEditingRow: () => void;
+    deleteRow: (rowId: string) => void;
+    editingRowId: string | null;
+    editingValues: EditableValues;
+    saveEditingRow: (rowId: string) => void;
+    setEditingValues: (updater: SetStateAction<EditableValues>) => void;
+    setEditingRowId: (updater: SetStateAction<string | null>) => void;
+    startEditingRow: (row: TData, editableKeys: readonly EditableRowKey<TData>[], overrides?: Partial<Record<EditableRowKey<TData>, string>>) => void;
+};
+export { useDataTableEditableRows };
+export type { DataTableRowDeleteEvent, DataTableRowEditCancelEvent, DataTableRowEditSaveEvent, DataTableRowEditStartEvent, DataTableRowsChangeEvent, EditableRowKey, UseDataTableEditableRowsOptions, };

package/dist/components/data-table.d.ts

@@ -0,0 +1,2 @@
+export * from './data-table/index'
+export {}

package/dist/components/input-field/input-field.d.ts

@@ -1,8 +1,8 @@
-import { default as React } from 'react';
+import { ComponentPropsWithRef, ReactNode } from 'react';
 export type DateAddon = {
     id: string | number;
     position?: "inline-start" | "inline-end" | "block-start" | "block-end" | null;
-    component: React.ReactNode;
+    component: ReactNode;
 };
 type BaseProps = {
     date?: DateAddon[];
@@ -15,7 +15,7 @@ type BaseProps = {
         field?: string;
     };
 };
-type InputFieldProps = BaseProps & React.ComponentPropsWithRef<"input">;
+type InputFieldProps = BaseProps & ComponentPropsWithRef<"input">;
 export declare const InputField: ({ date, isValid, disabled, label, description, classes, ref, ...rest }: InputFieldProps) => import("react/jsx-runtime").JSX.Element;
 type InputProps = InputFieldProps;
 export type { InputFieldProps, InputProps };

package/dist/components/input-phone/input-phone.d.ts

@@ -1,8 +1,8 @@
-import { default as React } from 'react';
-type InputPhoneProps = Omit<React.ComponentProps<typeof MaskedInputField>, "inputRef">;
-declare const MaskedInputField: React.ForwardRefExoticComponent<Omit<{
+import { ComponentProps, ForwardRefExoticComponent, RefAttributes, ComponentType } from 'react';
+type InputPhoneProps = Omit<ComponentProps<typeof MaskedInputField>, "inputRef">;
+declare const MaskedInputField: ForwardRefExoticComponent<Omit<{
     [x: string]: unknown;
-}, "ref"> & React.RefAttributes<React.ComponentType<{
+}, "ref"> & RefAttributes<ComponentType<{
     [x: string]: unknown;
 }>>>;
 export declare const InputPhone: (props: InputPhoneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/popover-modal/popover-modal.d.ts

@@ -1,13 +1,13 @@
-import { default as React } from 'react';
+import { HTMLAttributes, ReactNode } from 'react';
 export type PopoverBasicProps = {
-    trigger: React.ReactNode;
-    children: React.ReactNode;
+    trigger: ReactNode;
+    children: ReactNode;
     side?: "top" | "right" | "bottom" | "left";
     align?: "start" | "center" | "end";
     className?: string;
     triggerClassName?: string;
     open?: boolean;
     setOpen?: (value: boolean) => void;
-    triggerProps?: React.HTMLAttributes<HTMLElement>;
+    triggerProps?: HTMLAttributes<HTMLElement>;
 };
 export declare function PopoverBasic({ trigger, children, className, triggerClassName, side, align, open, setOpen, triggerProps, }: PopoverBasicProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/select-field/select-field.d.ts

@@ -1,5 +1,5 @@
 import { VariantProps } from 'class-variance-authority';
-import { default as React } from 'react';
+import { ComponentProps } from 'react';
 import { badgeVariants } from '../ui/badge';
 import { ComboboxChipsInput } from '../ui/combobox';
 export type SelectList = {
@@ -18,7 +18,7 @@ type SelectBaseProps = {
     description?: string;
     onChange?: (value: SelectValue) => void;
 };
-type SelectProps = SelectBaseProps & Omit<React.ComponentProps<typeof ComboboxChipsInput>, "list" | "onChange">;
+type SelectProps = SelectBaseProps & Omit<ComponentProps<typeof ComboboxChipsInput>, "list" | "onChange">;
 export declare const SelectField: {
     ({ list, label, multiple, disabled, isValid, description, onChange, ...rest }: SelectProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;

package/dist/components/textarea-field/index.d.ts

@@ -1,2 +1,2 @@
 export { TextareaField } from './textarea-field';
-export type { TextareaFieldProps, } from './textarea-field';
+export type { TextareaFieldProps } from './textarea-field';

package/dist/components/ui/avatar/avatar.d.ts

@@ -1,11 +1,11 @@
 import { Avatar as AvatarPrimitive } from 'radix-ui';
-import * as React from "react";
-declare function Avatar({ className, size, ...props }: React.ComponentProps<typeof AvatarPrimitive.Root> & {
+import { ComponentProps } from 'react';
+declare function Avatar({ className, size, ...props }: ComponentProps<typeof AvatarPrimitive.Root> & {
     size?: "default" | "sm" | "lg";
 }): import("react/jsx-runtime").JSX.Element;
-declare function AvatarImage({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
-declare function AvatarFallback({ className, ...props }: React.ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
-declare function AvatarBadge({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
-declare function AvatarGroup({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
-declare function AvatarGroupCount({ className, ...props }: React.ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarImage({ className, ...props }: ComponentProps<typeof AvatarPrimitive.Image>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarFallback({ className, ...props }: ComponentProps<typeof AvatarPrimitive.Fallback>): import("react/jsx-runtime").JSX.Element;
+declare function AvatarBadge({ className, ...props }: ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroup({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: ComponentProps<"div">): import("react/jsx-runtime").JSX.Element;
 export { Avatar, AvatarBadge, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarImage, };

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

@@ -1,7 +1,7 @@
 import { VariantProps } from 'class-variance-authority';
+import { HTMLAttributes } from 'react';
 import { badgeVariants } from './badge.styles';
-import * as React from "react";
-export interface BadgeProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "className">, VariantProps<typeof badgeVariants> {
+export interface BadgeProps extends Omit<HTMLAttributes<HTMLDivElement>, "className">, VariantProps<typeof badgeVariants> {
     dotPosition?: "left" | "right";
     classNames?: {
         dotClassName?: string;

package/dist/components/ui/button/button.d.ts

@@ -1,9 +1,9 @@
 import { VariantProps } from 'class-variance-authority';
+import { ButtonHTMLAttributes, Ref } from 'react';
 import { buttonVariants } from './button.styles';
-import * as React from "react";
-export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
     asChild?: boolean;
-    ref?: React.Ref<HTMLButtonElement>;
+    ref?: Ref<HTMLButtonElement>;
 }
 declare const Button: {
     ({ className, variant, size, asChild, ref, ...props }: ButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/button/button.styles.d.ts

@@ -1,5 +1,5 @@
 import { ClassProp } from 'class-variance-authority/types';
 export declare const buttonVariants: (props?: ({
-    variant?: "link" | "primary" | "secondary" | "secondaryBorder" | "ghost" | "circle" | "circleGhost" | "square" | null | undefined;
-    size?: "lg" | "md" | "sm" | "xs" | "default" | "icon-lg" | "icon-md" | "icon-sm" | "icon-xs" | null | undefined;
+    variant?: "link" | "primary" | "secondary" | "outlined" | "ghost" | "circle" | "circleGhost" | "square" | "pagination-arrow" | "pagination-page" | null | undefined;
+    size?: "lg" | "md" | "sm" | "xs" | "default" | "icon-lg" | "icon-md" | "icon-sm" | "icon-xs" | "pagination" | null | undefined;
 } & ClassProp) | undefined) => string;

package/dist/components/ui/calendar/calendar.d.ts

@@ -1,19 +1,23 @@
-import { DayPicker, DayButton, Locale, DayPickerLocale } from 'react-day-picker';
+import { ComponentProps, ReactNode } from 'react';
+import { DayPicker, DayButton } from 'react-day-picker';
 import { Button } from '../button';
-import * as React from "react";
-type Props = React.ComponentProps<typeof DayPicker> & {
-    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+type CalendarSize = "sm" | "md" | "lg";
+type CalendarPreset = {
+    text: string;
+    days: number;
+};
+type Props = ComponentProps<typeof DayPicker> & {
+    buttonVariant?: ComponentProps<typeof Button>["variant"];
+    size?: CalendarSize;
     classNameWrapper?: string;
     classNameFooter?: string;
-    footer?: React.ReactNode;
-};
-export declare const localeMode: {
-    ru: DayPickerLocale;
-    es: DayPickerLocale;
+    footer?: ReactNode;
+    appendFooter?: ReactNode;
+    presets?: CalendarPreset[];
+    presetBaseDate?: Date;
+    onPresetClick?: (preset: CalendarPreset, date: Date) => void;
 };
-declare function Calendar({ className, classNames, classNameWrapper, classNameFooter, showOutsideDays, captionLayout, buttonVariant, locale, formatters, components, footer, ...props }: Props): import("react/jsx-runtime").JSX.Element;
-declare function CalendarDayButton({ className, day, modifiers, locale, children, ...props }: React.ComponentProps<typeof DayButton> & {
-    locale?: Partial<Locale>;
-}): import("react/jsx-runtime").JSX.Element;
+declare function Calendar({ className, classNames, classNameWrapper, classNameFooter, showOutsideDays, captionLayout, buttonVariant, size, locale, formatters, components, footer, appendFooter, presets, presetBaseDate, onPresetClick, onDayClick, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, children, ...props }: ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
 export { Calendar, CalendarDayButton };
-export type { Props as CalendarProps };
+export type { CalendarPreset, Props as CalendarProps };

package/dist/components/ui/calendar/calendar.styles.d.ts

@@ -1,4 +1,62 @@
 import { ClassProp } from 'class-variance-authority/types';
-export declare const calendarVariants: (props?: ({
-    rangeType?: "end" | "start" | "none" | "middle" | "single" | null | undefined;
+export declare const calendarTypographyVariantBySize: {
+    readonly sm: "body-xxs-regular";
+    readonly md: "body-xs-regular";
+    readonly lg: "body-md-regular";
+};
+export declare const calendarWrapperClassName = "border-delicate-border !max-w-none hover:bg-transparent rounded-lg border bg-primary-bg !shadow-[0_0.25rem_1.125rem_0_rgb(0_0_0_/_15%)]";
+export declare const calendarContentPaddingVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
 } & ClassProp) | undefined) => string;
+export declare const calendarRootVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarMonthsClassName = "relative flex flex-col gap-8 md:flex-row";
+export declare const calendarMonthClassName = "flex w-full flex-col gap-4";
+export declare const calendarNavClassName = "absolute inset-x-0 top-0 flex w-full items-center justify-between gap-1";
+export declare const calendarNavButtonClassName = "hover:bg-primary-hover-bg size-(--cell-size) p-0 select-none aria-disabled:bg-primary-bg";
+export declare const calendarMonthCaptionClassName = "flex h-(--cell-size) w-full items-center justify-center px-(--cell-size)";
+export declare const calendarDropdownsVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarDropdownRootClassName = "cn-calendar-dropdown-root relative rounded-sm";
+export declare const calendarDropdownClassName = "absolute inset-0 opacity-0";
+export declare const calendarCaptionLabelVariants: (props?: ({
+    layout?: "label" | "dropdown" | null | undefined;
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekdaysVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekdayVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarWeekNumberHeaderClassName = "size-(--cell-size) shrink-0 select-none";
+export declare const calendarWeekNumberVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarDayVariants: (props?: ({
+    showWeekNumber?: boolean | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarRangeStartClassName = "relative isolate z-0 rounded-l-sm after:absolute after:inset-y-0 after:left-full after:w-[calc(var(--calendar-gap-x)/2)] after:bg-tertiary-bg after:content-[''] after:-z-10";
+export declare const calendarRangeMiddleClassName = "relative isolate z-0 rounded-none before:absolute before:inset-y-0 before:right-full before:w-[calc(var(--calendar-gap-x)/2)] before:bg-tertiary-bg before:content-[''] before:-z-10 after:absolute after:inset-y-0 after:left-full after:w-[calc(var(--calendar-gap-x)/2)] after:bg-tertiary-bg after:content-[''] after:-z-10";
+export declare const calendarRangeEndClassName = "relative isolate z-0 rounded-r-sm before:absolute before:inset-y-0 before:right-full before:w-[calc(var(--calendar-gap-x)/2)] before:bg-tertiary-bg before:content-[''] before:-z-10";
+export declare const calendarTodayClassName = "bg-tertiary-bg text-primary-text relative rounded-sm data-[selected=true]:rounded-none";
+export declare const calendarTodayButtonIndicatorClassName = "relative z-0 overflow-visible after:pointer-events-none after:absolute after:bottom-[0.1875rem] after:left-1/2 after:z-[1] after:block after:size-[0.1875rem] after:-translate-x-1/2 after:rounded-full after:bg-primary-text data-[range-start=true]:after:bg-primary-inverse-text data-[range-end=true]:after:bg-primary-inverse-text data-[selected-single=true]:after:bg-primary-inverse-text disabled:after:opacity-40";
+export declare const calendarRangeLastClickedClassName = "data-[last-clicked=true]:[box-shadow:inset_0_0_0_0.125rem_var(--color-inp-default-border)]";
+export declare const calendarOutsideClassName = "text-disabled-text aria-selected:text-disabled-text";
+export declare const calendarDisabledClassName = "text-disabled-text bg-transparent pointer-events-none";
+export declare const calendarHiddenClassName = "invisible";
+export declare const calendarDayButtonClassName = "text-primary-text size-(--cell-size) min-h-(--cell-size)\nmax-h-(--cell-size) min-w-(--cell-size) max-w-(--cell-size) rounded-sm p-0 hover:bg-primary-hover-bg\ndisabled:!bg-transparent disabled:hover:!bg-transparent disabled:text-disabled-text\ndata-[selected-single=true]:bg-primary-inverse-bg\ndata-[selected-single=true]:text-primary-inverse-text\ndata-[range-start=true]:bg-primary-inverse-bg\ndata-[range-start=true]:text-primary-inverse-text\ndata-[range-start=true]:rounded-l-sm\ndata-[range-middle=true]:bg-tertiary-bg\ndata-[range-middle=true]:text-primary-text\ndata-[range-middle=true]:rounded-none\ndata-[range-end=true]:bg-primary-inverse-bg\ndata-[range-end=true]:text-primary-inverse-text\ndata-[range-end=true]:rounded-r-sm";
+export declare const calendarDayTextVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarFooterVariants: (props?: ({
+    size?: "lg" | "md" | "sm" | null | undefined;
+} & ClassProp) | undefined) => string;
+export declare const calendarIconClassName = "text-primary-text cursor-pointer";
+export declare const calendarWeekNumberCellClassName = "flex size-(--cell-size) items-center justify-center text-center";
+export declare const calendarDayTextClassName = "leading-none";

package/dist/components/ui/calendar/index.d.ts

@@ -1,2 +1,3 @@
-export { Calendar, localeMode } from './calendar';
-export type { CalendarProps } from './calendar';
+export { Calendar } from './calendar';
+export { localeMode } from '../../../constants/calendar-locale';
+export type { CalendarPreset, CalendarProps } from './calendar';

package/dist/components/ui/card/card.d.ts

@@ -1,9 +1,9 @@
+import { HTMLAttributes, RefObject } from 'react';
 import { VariantProps } from 'class-variance-authority';
 import { cardVariants } from './card.styles';
-import * as React from "react";
 declare const Card: {
-    ({ ref, className, variant, disabled, active, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, variant, disabled, active, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
         variant?: VariantProps<typeof cardVariants>["variant"];
         disabled?: boolean;
         active?: boolean;
@@ -11,32 +11,32 @@ declare const Card: {
     displayName: string;
 };
 declare const CardHeader: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardTitle: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardDescription: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardContent: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 declare const CardFooter: {
-    ({ ref, className, ...props }: React.HTMLAttributes<HTMLDivElement> & {
-        ref?: React.RefObject<HTMLDivElement | null>;
+    ({ ref, className, ...props }: HTMLAttributes<HTMLDivElement> & {
+        ref?: RefObject<HTMLDivElement | null>;
     }): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };