@lite-code/aui-react 0.0.1

package/dist/input/index.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import "./input.css";
+export type InputSize = "sm" | "md" | "lg";
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "prefix"> {
+    size?: InputSize;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    trim?: boolean;
+    clearable?: boolean;
+    showCount?: boolean;
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/input-number/index.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import type { InputSize } from "../input";
+import "./input-number.css";
+export interface InputNumberProps {
+    value?: number | null;
+    defaultValue?: number | null;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    disabled?: boolean;
+    size?: InputSize;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    placeholder?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    onChange?: (value: number | null) => void;
+    onBlur?: (e: React.FocusEvent<HTMLInputElement>) => void;
+    formatter?: (value: number | null) => string;
+    parser?: (displayValue: string) => number | null;
+}
+export declare const InputNumber: React.ForwardRefExoticComponent<InputNumberProps & React.RefAttributes<HTMLInputElement>>;

package/dist/layer/index.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "./layer.css";
+export interface LayerProps {
+    open: boolean;
+    triggerRef: React.RefObject<HTMLElement | null>;
+    children: React.ReactNode;
+    /** vertical gap between trigger bottom and layer top, default 4 */
+    offset?: number;
+    /** stretch layer width to match the trigger, default true */
+    matchWidth?: boolean;
+    /** override z-index, e.g. 2001 when used inside a Modal */
+    zIndex?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    onClickOutside?: () => void;
+    onEscape?: () => void;
+}
+export declare function Layer({ open, triggerRef, children, offset, matchWidth, zIndex, className, style, onClickOutside, onEscape, }: LayerProps): React.ReactPortal | null;

package/dist/menu/index.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+import "./menu.css";
+export type MenuMode = "vertical" | "horizontal" | "inline";
+export interface MenuItemType {
+    key: string;
+    label: React.ReactNode;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    children?: MenuItemType[];
+}
+export interface MenuProps {
+    items: MenuItemType[];
+    selectedKey?: string;
+    defaultSelectedKey?: string;
+    openKeys?: string[];
+    defaultOpenKeys?: string[];
+    onSelect?: (key: string) => void;
+    onOpenChange?: (openKeys: string[]) => void;
+    mode?: MenuMode;
+    collapsed?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Menu({ items, selectedKey, defaultSelectedKey, openKeys, defaultOpenKeys, onSelect, onOpenChange, mode, collapsed, style, className, }: MenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/message/index.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "./message.css";
+export type MessageType = "success" | "error" | "warning" | "info" | "loading";
+export interface MessageOptions {
+    duration?: number;
+    key?: string;
+    closable?: boolean;
+}
+declare function closeAll(): void;
+export declare const message: {
+    success: (content: React.ReactNode, options?: number | MessageOptions) => () => void;
+    error: (content: React.ReactNode, options?: number | MessageOptions) => () => void;
+    warning: (content: React.ReactNode, options?: number | MessageOptions) => () => void;
+    info: (content: React.ReactNode, options?: number | MessageOptions) => () => void;
+    loading: (content: React.ReactNode, options?: number | MessageOptions) => () => void;
+    closeAll: typeof closeAll;
+};
+export {};

package/dist/modal/index.d.ts

@@ -0,0 +1,42 @@
+import React from "react";
+import "./modal.css";
+export interface ModalProps {
+    open: boolean;
+    onClose?: () => void;
+    title?: React.ReactNode;
+    children?: React.ReactNode;
+    footer?: React.ReactNode | null;
+    width?: number | string;
+    closable?: boolean;
+    mask?: boolean | {
+        blur?: boolean;
+    };
+}
+export declare function Modal({ open, onClose, title, children, footer, width, closable, mask, }: ModalProps): React.ReactPortal | null;
+export declare namespace Modal {
+    var show: (options: StaticModalOptions) => void;
+    var info: (options: StaticModalOptions) => void;
+    var success: (options: StaticModalOptions) => void;
+    var error: (options: StaticModalOptions) => void;
+    var warning: (options: StaticModalOptions) => void;
+    var confirm: (options: ConfirmModalOptions) => void;
+}
+export type StaticModalType = "info" | "success" | "error" | "warning";
+export interface StaticModalOptions {
+    title?: React.ReactNode;
+    content?: React.ReactNode;
+    width?: number | string;
+    okText?: string;
+    onClose?: () => void;
+}
+export interface ConfirmModalOptions {
+    title?: React.ReactNode;
+    content?: React.ReactNode;
+    width?: number | string;
+    text?: {
+        ok?: string;
+        cancel?: string;
+    };
+    onOk?: () => void | Promise<void>;
+    onClose?: () => void | Promise<void>;
+}

package/dist/pagination/index.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import "./pagination.css";
+export interface PaginationProps {
+    total: number;
+    current?: number;
+    defaultCurrent?: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: number[];
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean;
+    showTotal?: (total: number, range: [number, number]) => React.ReactNode;
+    onChange?: (page: number, pageSize: number) => void;
+    disabled?: boolean;
+    size?: "sm" | "md";
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Pagination({ total, current: controlledPage, defaultCurrent, pageSize: controlledPageSize, defaultPageSize, pageSizeOptions, showSizeChanger, showQuickJumper, showTotal, onChange, disabled, size, style, className, }: PaginationProps): import("react/jsx-runtime").JSX.Element;

package/dist/popover/index.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "./popover.css";
+export type PopoverPlacement = "top" | "bottom" | "left" | "right";
+export type PopoverTrigger = "click" | "hover";
+export interface PopoverProps {
+    children: React.ReactElement;
+    title?: React.ReactNode;
+    content?: React.ReactNode;
+    placement?: PopoverPlacement;
+    trigger?: PopoverTrigger;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    offset?: number;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Popover({ children, title, content, placement, trigger, open: openProp, defaultOpen, onOpenChange, offset, style, className, }: PopoverProps): import("react/jsx-runtime").JSX.Element;

package/dist/popover/util.d.ts

@@ -0,0 +1,28 @@
+export type BasePlacement = "top" | "bottom" | "left" | "right";
+/** Flip a base direction */
+export declare function flipBase(p: string): BasePlacement;
+/** Flip a placement preserving the variant suffix */
+export declare function flipPlacement(p: string): string;
+/**
+ * Check if the tooltip/popover overflows the viewport in its primary axis.
+ * `pos` must be the raw (unclamped) top/left values.
+ */
+export declare function isOverflowing(p: string, top: number, left: number, fW: number, fH: number): boolean;
+/** Clamp top/left so the floating element stays within the viewport */
+export declare function clampToViewport(top: number, left: number, fW: number, fH: number, margin?: number): {
+    top: number;
+    left: number;
+};
+/**
+ * Resolve the effective placement with auto-flip.
+ * Tries `preferred`, flips to opposite if it overflows.
+ * Returns the final placement and clamped position.
+ */
+export declare function resolvePlacement<T extends string>(preferred: T, triggerRect: DOMRect, fW: number, fH: number, offset: number, compute: (p: T, tRect: DOMRect, fW: number, fH: number, offset: number) => {
+    top: number;
+    left: number;
+}): {
+    placement: T;
+    top: number;
+    left: number;
+};

package/dist/progress/index.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import "./progress.css";
+export type ProgressType = "line" | "line-inner" | "circle" | "dashboard";
+export type ProgressStatus = "normal" | "success" | "error" | "warning" | "active";
+export type ProgressSize = "sm" | "md" | "lg";
+export interface ProgressProps {
+    percent?: number;
+    type?: ProgressType;
+    status?: ProgressStatus;
+    strokeWidth?: number;
+    showInfo?: boolean;
+    format?: (percent: number) => React.ReactNode;
+    size?: ProgressSize;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Progress({ percent, type, status, strokeWidth, showInfo, format, size, style, className, }: ProgressProps): import("react/jsx-runtime").JSX.Element;

package/dist/radio/index.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+import "./radio.css";
+export type RadioSize = "sm" | "md" | "lg";
+export interface RadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "onChange" | "checked" | "defaultChecked" | "value"> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean, e: React.ChangeEvent<HTMLInputElement>) => void;
+    size?: RadioSize;
+    children?: React.ReactNode;
+    value?: string | number;
+}
+export interface RadioOption {
+    label: React.ReactNode;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface RadioGroupProps {
+    value?: string | number;
+    defaultValue?: string | number;
+    onChange?: (value: string | number) => void;
+    options?: RadioOption[];
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function RadioGroup({ value, defaultValue, onChange, options, disabled, children, className, }: RadioGroupProps): import("react/jsx-runtime").JSX.Element;
+export declare function Radio({ checked, defaultChecked, onChange, size, disabled, children, value, className, ...rest }: RadioProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Radio {
+    var Group: typeof RadioGroup;
+    var displayName: string;
+}
+export {};

package/dist/rate/index.d.ts

@@ -0,0 +1,20 @@
+import React from "react";
+import "./rate.css";
+export type RateSize = "sm" | "md" | "lg";
+export interface RateProps {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    count?: number;
+    allowHalf?: boolean;
+    allowClear?: boolean;
+    disabled?: boolean;
+    character?: React.ReactNode;
+    size?: RateSize;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Rate({ value, defaultValue, onChange, count, allowHalf, allowClear, disabled, character, size, style, className, }: RateProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Rate {
+    var displayName: string;
+}

package/dist/select/index.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import "./select.css";
+export interface SelectOption {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+export type SelectValue = string | number | (string | number)[];
+export interface SelectProps {
+    options?: SelectOption[];
+    value?: SelectValue;
+    onChange?: (value: SelectValue) => void;
+    multiple?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+    clearable?: boolean;
+    searchable?: boolean;
+    maxTagCount?: number;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Select({ options, value, onChange, multiple, placeholder, disabled, size, clearable, searchable, maxTagCount, style, className, }: SelectProps): import("react/jsx-runtime").JSX.Element;

package/dist/slider/index.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import "./slider.css";
+export interface SliderProps {
+    value?: number | [number, number];
+    defaultValue?: number | [number, number];
+    onChange?: (value: number | [number, number]) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    marks?: Record<number, React.ReactNode>;
+    range?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Slider({ value, defaultValue, onChange, min, max, step, disabled, marks, range, style, className, }: SliderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Slider {
+    var displayName: string;
+}

package/dist/space/index.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface SpaceProps {
+    direction?: "horizontal" | "vertical";
+    gap?: number | string;
+    align?: "start" | "center" | "end" | "baseline";
+    wrap?: boolean;
+    style?: React.CSSProperties;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare function Space({ direction, gap, align, wrap, style, className, children, }: SpaceProps): import("react/jsx-runtime").JSX.Element;

package/dist/spin/index.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import "./spin.css";
+export type SpinSize = "sm" | "md" | "lg";
+export interface SpinProps {
+    spinning?: boolean;
+    size?: SpinSize;
+    tip?: string;
+    children?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Spin({ spinning, size, tip, children, style, className, }: SpinProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/steps/index.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import "./steps.css";
+export type StepStatus = "wait" | "process" | "finish" | "error";
+export type StepsDirection = "horizontal" | "vertical";
+export type StepsType = "default" | "dot" | "navigation";
+export type StepsSize = "sm" | "md";
+export interface StepItem {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    icon?: React.ReactNode;
+    status?: StepStatus;
+    disabled?: boolean;
+}
+export interface StepsProps {
+    current?: number;
+    items: StepItem[];
+    direction?: StepsDirection;
+    type?: StepsType;
+    size?: StepsSize;
+    status?: StepStatus;
+    onChange?: (index: number) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Steps({ current, items, direction, type, size, status, onChange, className, style, }: StepsProps): import("react/jsx-runtime").JSX.Element;

package/dist/switch/index.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import "./switch.css";
+export type SwitchSize = "sm" | "md" | "lg";
+export interface SwitchProps {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    size?: SwitchSize;
+    checkedChildren?: React.ReactNode;
+    uncheckedChildren?: React.ReactNode;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Switch({ checked, defaultChecked, onChange, disabled, size, checkedChildren, uncheckedChildren, style, className, }: SwitchProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Switch {
+    var displayName: string;
+}

package/dist/table/checkbox.d.ts

@@ -0,0 +1,14 @@
+interface TableCheckboxProps {
+    checked: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    onChange?: (checked: boolean) => void;
+}
+interface TableRadioProps {
+    checked: boolean;
+    disabled?: boolean;
+    onChange?: () => void;
+}
+export declare function TableRadio({ checked, disabled, onChange }: TableRadioProps): import("react/jsx-runtime").JSX.Element;
+export declare function TableCheckbox({ checked, indeterminate, disabled, onChange, }: TableCheckboxProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/table/empty.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+export declare function EmptyState({ content }: {
+    content?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function LoadingOverlay(): import("react/jsx-runtime").JSX.Element;

package/dist/table/index.d.ts

@@ -0,0 +1,2 @@
+export type { TablePaginationConfig, TableColumn, TableRowSelection, TableToolItem, TableToolbarApi, TableRowOperations, RowMenuItem, RowMenuApi, TableProps, SummaryCell, } from "./types";
+export { Table } from "./table";

package/dist/table/row-operation-cell.d.ts

@@ -0,0 +1,9 @@
+import type { RowMenuItem } from "./types";
+interface RowOperationCellProps<T> {
+    record: T;
+    menus: RowMenuItem<T>[];
+    maxCount: number;
+    search?: () => void | Promise<void>;
+}
+export declare function RowOperationCell<T>({ record, menus, maxCount, search, }: RowOperationCellProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/table/table.d.ts

@@ -0,0 +1,3 @@
+import "./table.css";
+import type { TableProps } from "./types";
+export declare function Table<T extends Record<string, any> = any>({ columns, dataSource, rowKey, bordered, striped, size, scroll, loading, empty, rowSelection, virtual, pagination, title, tools, rowOperations, onRefresh, summary, childrenColumnName, expandedRowKeys, defaultExpandedRowKeys, onExpand, indentSize, style, className, }: TableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/table/toolbar.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { ButtonSize } from "../button";
+import type { TableToolItem, TableToolbarApi } from "./types";
+interface ToolbarProps<T> {
+    title?: React.ReactNode;
+    tools?: TableToolItem<T>[];
+    onRefresh?: () => void | Promise<void>;
+    toolbarApi: TableToolbarApi<T>;
+    btnSize: ButtonSize;
+}
+export declare function Toolbar<T>({ title, tools, onRefresh, toolbarApi, btnSize, }: ToolbarProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/table/types.d.ts

@@ -0,0 +1,84 @@
+import type { ReactNode, CSSProperties } from "react";
+import type { PaginationProps } from "../pagination";
+import type { ButtonVariant } from "../button";
+import type { IconName } from "../icon";
+export type SummaryCell = {
+    render: () => ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+};
+export type TablePaginationConfig = Omit<PaginationProps, "total" | "style" | "className">;
+export interface TableColumn<T = any> {
+    key: string;
+    title: ReactNode;
+    dataIndex?: string;
+    width?: number | string;
+    align?: "left" | "center" | "right";
+    fixed?: "left" | "right";
+    group?: string;
+    render?: (value: any, record: T, index: number) => ReactNode;
+}
+export interface TableRowSelection<T = any> {
+    selectedRowKeys?: (string | number)[];
+    onChange?: (keys: (string | number)[], rows: T[]) => void;
+    type?: "checkbox" | "radio";
+    getCheckboxProps?: (record: T) => {
+        disabled?: boolean;
+    };
+}
+export interface TableToolbarApi<T = any> {
+    data: T[];
+}
+export interface TableToolItem<T = any> {
+    label?: ReactNode;
+    icon?: IconName;
+    type?: ButtonVariant;
+    disabled?: boolean | ((api: TableToolbarApi<T>) => boolean);
+    onClick?: (api: TableToolbarApi<T>) => void;
+}
+export interface RowMenuApi<T = any> {
+    record: T;
+    search?: () => void | Promise<void>;
+}
+export interface RowMenuItem<T = any> {
+    label: ReactNode;
+    confirm?: string;
+    disabled?: boolean | ((api: RowMenuApi<T>) => boolean);
+    visible?: boolean | ((api: RowMenuApi<T>) => boolean);
+    onClick?: (api: RowMenuApi<T>) => void | Promise<void>;
+}
+export interface TableRowOperations<T = any> {
+    width?: number;
+    maxCount?: number;
+    menus?: RowMenuItem<T>[];
+}
+export interface TableProps<T extends Record<string, any> = any> {
+    columns: TableColumn<T>[];
+    dataSource?: T[];
+    rowKey?: string | ((record: T) => string | number);
+    bordered?: boolean;
+    striped?: boolean;
+    size?: "sm" | "md" | "lg";
+    scroll?: {
+        x?: number | string;
+        y?: number | string;
+    };
+    loading?: boolean;
+    empty?: ReactNode;
+    rowSelection?: TableRowSelection<T>;
+    /** 开启虚拟滚动（需同时设置 scroll.y 为数字） */
+    virtual?: boolean;
+    pagination?: TablePaginationConfig | false;
+    title?: ReactNode;
+    tools?: TableToolItem<T>[];
+    rowOperations?: TableRowOperations<T>;
+    onRefresh?: () => void | Promise<void>;
+    summary?: SummaryCell[][];
+    childrenColumnName?: string;
+    expandedRowKeys?: (string | number)[];
+    defaultExpandedRowKeys?: (string | number)[];
+    onExpand?: (expanded: boolean, record: T) => void;
+    indentSize?: number;
+    style?: CSSProperties;
+    className?: string;
+}

package/dist/table/utils.d.ts

@@ -0,0 +1,19 @@
+import type { TableColumn, TableProps } from "./types";
+export type HeaderSegment<T> = {
+    type: "leaf";
+    col: TableColumn<T>;
+} | {
+    type: "group";
+    label: string;
+    cols: TableColumn<T>[];
+};
+export declare function buildHeaderSegments<T>(columns: TableColumn<T>[]): HeaderSegment<T>[];
+export declare function getRowKey<T extends Record<string, any>>(record: T, index: number, rowKey?: TableProps<T>["rowKey"]): string;
+export declare function getCellValue<T extends Record<string, any>>(record: T, col: TableColumn<T>): any;
+export declare function computeStickyOffsets(columns: TableColumn[]): {
+    left: Record<string, number>;
+    right: Record<string, number>;
+    lastLeftKey: string | null;
+    firstRightKey: string | null;
+};
+export declare const ROW_HEIGHT: Record<"sm" | "md" | "lg", number>;

package/dist/tabs/index.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import "./tabs.css";
+export interface TabItem {
+    key: string;
+    label: React.ReactNode;
+    children?: React.ReactNode;
+    disabled?: boolean;
+    icon?: React.ReactNode;
+}
+export type TabsType = "line" | "segment";
+export type TabsPosition = "top" | "left";
+export interface TabsProps {
+    items: TabItem[];
+    activeKey?: string;
+    defaultActiveKey?: string;
+    onChange?: (key: string) => void;
+    type?: TabsType;
+    position?: TabsPosition;
+    style?: React.CSSProperties;
+    className?: string;
+}
+export declare function Tabs({ items, activeKey: activeKeyProp, defaultActiveKey, onChange, type, position, style, className, }: TabsProps): import("react/jsx-runtime").JSX.Element;

package/dist/textarea/index.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import "./textarea.css";
+export type TextareaSize = "sm" | "md" | "lg";
+export interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+    size?: TextareaSize;
+    autoSize?: boolean;
+    showCount?: boolean;
+    clearable?: boolean;
+}
+export declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;

package/dist/theme/theme-provider.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+export type Theme = "light" | "dark";
+export type AccentColor = string;
+interface ThemeContextValue {
+    theme: Theme;
+    accentColor: AccentColor;
+    setTheme: (t: Theme) => void;
+    setAccentColor: (c: AccentColor) => void;
+}
+export declare const ACCENT_PRESETS: {
+    label: string;
+    value: string;
+}[];
+interface ThemeProviderProps {
+    children: React.ReactNode;
+    defaultTheme?: Theme;
+    defaultAccentColor?: AccentColor;
+}
+export declare function ThemeProvider({ children, defaultTheme, defaultAccentColor, }: ThemeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTheme(): ThemeContextValue;
+export {};

package/dist/timepicker/index.d.ts

@@ -0,0 +1,12 @@
+import type { TimePickerProps, TimeRangePickerProps } from "./types";
+import "./timepicker.css";
+export type { TimePickerSize, TimePickerProps, TimeRangePickerProps, TimeValue, } from "./types";
+declare function TimePickerBase({ value: controlledValue, defaultValue, onChange, format: fmtProp, use12Hours, hourStep, minuteStep, secondStep, disabledHours, disabledMinutes, disabledSeconds, clearable, disabled, size, placeholder, style, className, }: TimePickerProps): import("react/jsx-runtime").JSX.Element;
+declare function RangePicker({ value: controlledValue, defaultValue, onChange, format: fmtProp, use12Hours, hourStep, minuteStep, secondStep, clearable, disabled, size, placeholder, style, className, }: TimeRangePickerProps): import("react/jsx-runtime").JSX.Element;
+declare namespace RangePicker {
+    var displayName: string;
+}
+export declare const TimePicker: typeof TimePickerBase & {
+    RangePicker: typeof RangePicker;
+    displayName: string;
+};

package/dist/timepicker/scroll-column.d.ts

@@ -0,0 +1,13 @@
+export interface ScrollColumnProps {
+    values: number[];
+    selected: number;
+    disabledValues?: number[];
+    onSelect: (val: number) => void;
+    label?: string;
+}
+export declare function ScrollColumn({ values, selected, disabledValues, onSelect, label, }: ScrollColumnProps): import("react/jsx-runtime").JSX.Element;
+export interface AmPmColumnProps {
+    value: "AM" | "PM";
+    onSelect: (v: "AM" | "PM") => void;
+}
+export declare function AmPmColumn({ value, onSelect }: AmPmColumnProps): import("react/jsx-runtime").JSX.Element;