orizon 0.1.0

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

@@ -0,0 +1,8 @@
+import { InternalCard, CardMeta, CardGrid } from './Card';
+type CardComponent = typeof InternalCard & {
+    Meta: typeof CardMeta;
+    Grid: typeof CardGrid;
+};
+declare const Card: CardComponent;
+export { Card };
+export type { CardProps, CardMetaProps, CardGridProps, CardSize, CardType } from './types';

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

@@ -0,0 +1,53 @@
+import { ReactNode, CSSProperties, HTMLAttributes } from 'react';
+export type CardSize = "default" | "small";
+export type CardType = "inner" | undefined;
+export interface CardProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    /** Card title */
+    title?: ReactNode;
+    /** Content rendered in the top-right corner */
+    extra?: ReactNode;
+    /** Card cover image */
+    cover?: ReactNode;
+    /** Action list rendered at the bottom */
+    actions?: ReactNode[];
+    /** Whether to show border */
+    bordered?: boolean;
+    /** Hover effect */
+    hoverable?: boolean;
+    /** Show loading skeleton */
+    loading?: boolean;
+    /** Size */
+    size?: CardSize;
+    /** Type: inner for nested cards */
+    type?: CardType;
+    /** Body style */
+    bodyStyle?: CSSProperties;
+    /** Head style */
+    headStyle?: CSSProperties;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export interface CardMetaProps {
+    /** Avatar or icon */
+    avatar?: ReactNode;
+    /** Title */
+    title?: ReactNode;
+    /** Description */
+    description?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}
+export interface CardGridProps extends HTMLAttributes<HTMLDivElement> {
+    /** Hoverable effect */
+    hoverable?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}

package/dist/components/carousel/Carousel.d.ts

@@ -0,0 +1,4 @@
+import { CarouselProps, CarouselRef } from './types';
+import * as React from "react";
+declare const InternalCarousel: React.ForwardRefExoticComponent<CarouselProps & React.RefAttributes<CarouselRef>>;
+export { InternalCarousel };

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

@@ -0,0 +1,3 @@
+declare const Carousel: import('react').ForwardRefExoticComponent<import('./types').CarouselProps & import('react').RefAttributes<import('./types').CarouselRef>>;
+export { Carousel };
+export type { CarouselProps, CarouselRef, DotPosition, CarouselEffect, AutoplayConfig, } from './types';

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

@@ -0,0 +1,41 @@
+import { ReactNode, CSSProperties } from 'react';
+export type DotPosition = "top" | "bottom" | "left" | "right";
+export type CarouselEffect = "scrollx" | "fade";
+export interface AutoplayConfig {
+    interval?: number;
+    pauseOnHover?: boolean;
+}
+export interface CarouselProps {
+    /** Auto play config or boolean */
+    autoplay?: boolean | AutoplayConfig;
+    /** Whether to show dots */
+    dots?: boolean | {
+        className?: string;
+    };
+    /** Dot position */
+    dotPosition?: DotPosition;
+    /** Transition effect */
+    effect?: CarouselEffect;
+    /** Number of slides to show */
+    slidesToShow?: number;
+    /** Before change callback */
+    beforeChange?: (current: number, next: number) => void;
+    /** After change callback */
+    afterChange?: (current: number) => void;
+    /** Show navigation arrows */
+    arrows?: boolean;
+    /** Initial slide index */
+    initialSlide?: number;
+    /** Whether to loop */
+    infinite?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export interface CarouselRef {
+    goTo: (slide: number) => void;
+    next: () => void;
+    prev: () => void;
+}

package/dist/components/cascader/Cascader.d.ts

@@ -0,0 +1,4 @@
+import { CascaderProps } from './types';
+import * as React from "react";
+declare const InternalCascader: React.ForwardRefExoticComponent<CascaderProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalCascader };

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

@@ -0,0 +1,3 @@
+declare const Cascader: import('react').ForwardRefExoticComponent<import('./types').CascaderProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Cascader };
+export type { CascaderProps, CascaderOption, CascaderSize, CascaderStatus, CascaderVariant, CascaderExpandTrigger, CascaderPlacement, } from './types';

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

@@ -0,0 +1,42 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface CascaderOption {
+    value: string | number;
+    label?: ReactNode;
+    children?: CascaderOption[];
+    disabled?: boolean;
+    isLeaf?: boolean;
+}
+export type CascaderSize = "small" | "middle" | "large";
+export type CascaderStatus = "error" | "warning";
+export type CascaderVariant = "outlined" | "borderless" | "filled";
+export type CascaderExpandTrigger = "click" | "hover";
+export type CascaderPlacement = "bottomLeft" | "bottomRight" | "topLeft" | "topRight";
+export interface CascaderProps {
+    options?: CascaderOption[];
+    value?: (string | number)[];
+    defaultValue?: (string | number)[];
+    onChange?: (value: (string | number)[], selectedOptions: CascaderOption[]) => void;
+    multiple?: boolean;
+    expandTrigger?: CascaderExpandTrigger;
+    fieldNames?: {
+        label?: string;
+        value?: string;
+        children?: string;
+    };
+    showSearch?: boolean | {
+        filter?: (inputValue: string, path: CascaderOption[]) => boolean;
+    };
+    changeOnSelect?: boolean;
+    displayRender?: (labels: string[], selectedOptions?: CascaderOption[]) => ReactNode;
+    loadData?: (selectedOptions: CascaderOption[]) => void;
+    placeholder?: string;
+    size?: CascaderSize;
+    status?: CascaderStatus;
+    variant?: CascaderVariant;
+    placement?: CascaderPlacement;
+    allowClear?: boolean;
+    disabled?: boolean;
+    maxTagCount?: number | "responsive";
+    className?: string;
+    style?: CSSProperties;
+}

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

@@ -0,0 +1,4 @@
+import { CheckboxProps } from './types';
+import * as React from "react";
+declare const InternalCheckbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLElement>>;
+export { InternalCheckbox };

package/dist/components/checkbox/CheckboxGroup.d.ts

@@ -0,0 +1,10 @@
+import { CheckboxGroupProps } from './types';
+import * as React from "react";
+export interface CheckboxGroupContextValue {
+    value: (string | number)[];
+    disabled: boolean;
+    toggleValue: (val: string | number) => void;
+}
+export declare const CheckboxGroupContext: React.Context<CheckboxGroupContextValue | null>;
+declare const CheckboxGroup: React.FC<CheckboxGroupProps>;
+export { CheckboxGroup };

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

@@ -0,0 +1,8 @@
+import { InternalCheckbox } from './Checkbox';
+import { CheckboxGroup } from './CheckboxGroup';
+type CheckboxComponent = typeof InternalCheckbox & {
+    Group: typeof CheckboxGroup;
+};
+declare const Checkbox: CheckboxComponent;
+export { Checkbox };
+export type { CheckboxProps, CheckboxGroupProps, CheckboxChangeEvent, CheckboxOptionType, } from './types';

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

@@ -0,0 +1,55 @@
+import { ReactNode } from 'react';
+export interface CheckboxChangeEvent {
+    target: {
+        checked: boolean;
+        value?: any;
+    };
+    stopPropagation: () => void;
+    preventDefault: () => void;
+    nativeEvent: Event | undefined;
+}
+export interface CheckboxProps {
+    /** Whether the checkbox is checked (controlled) */
+    checked?: boolean;
+    /** Default checked state (uncontrolled) */
+    defaultChecked?: boolean;
+    /** Whether to show indeterminate state */
+    indeterminate?: boolean;
+    /** Whether the checkbox is disabled */
+    disabled?: boolean;
+    /** Callback when state changes */
+    onChange?: (e: CheckboxChangeEvent) => void;
+    /** Label content rendered beside the checkbox */
+    children?: ReactNode;
+    /** Value used in CheckboxGroup */
+    value?: any;
+    /** Additional class name */
+    className?: string;
+    /** ID attribute */
+    id?: string;
+    /** Name attribute */
+    name?: string;
+}
+export interface CheckboxOptionType {
+    label: ReactNode;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface CheckboxGroupProps {
+    /** List of options or simple values */
+    options?: (string | number | CheckboxOptionType)[];
+    /** Controlled selected values */
+    value?: (string | number)[];
+    /** Default selected values */
+    defaultValue?: (string | number)[];
+    /** Callback when selected values change */
+    onChange?: (checkedValues: (string | number)[]) => void;
+    /** Disable all checkboxes in the group */
+    disabled?: boolean;
+    /** Additional class name */
+    className?: string;
+    /** Name attribute for all checkboxes */
+    name?: string;
+    /** Child content (alternative to options prop) */
+    children?: ReactNode;
+}

package/dist/components/collapse/Collapse.d.ts

@@ -0,0 +1,4 @@
+import { CollapseProps } from './types';
+import * as React from "react";
+declare const InternalCollapse: React.FC<CollapseProps>;
+export { InternalCollapse };

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

@@ -0,0 +1,3 @@
+declare const Collapse: import('react').FC<import('./types').CollapseProps>;
+export { Collapse };
+export type { CollapseProps, CollapseItem, CollapsibleType, ExpandIconPosition, CollapseSize, } from './types';

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

@@ -0,0 +1,58 @@
+import { ReactNode, CSSProperties, Key } from 'react';
+export type CollapsibleType = "header" | "icon" | "disabled";
+export type ExpandIconPosition = "start" | "end";
+export type CollapseSize = "large" | "middle" | "small";
+export interface CollapseItem {
+    /** Unique key */
+    key: Key;
+    /** Panel header */
+    label: ReactNode;
+    /** Panel content */
+    children: ReactNode;
+    /** Extra content at the right of header */
+    extra?: ReactNode;
+    /** Whether to show the expand arrow */
+    showArrow?: boolean;
+    /** Force render hidden panels */
+    forceRender?: boolean;
+    /** Collapsible mode for this item */
+    collapsible?: CollapsibleType;
+    /** Header class name */
+    headerClass?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Class name */
+    className?: string;
+}
+export interface CollapseProps {
+    /** Items config */
+    items?: CollapseItem[];
+    /** Active panel keys (controlled) */
+    activeKey?: Key | Key[];
+    /** Default active panel keys */
+    defaultActiveKey?: Key | Key[];
+    /** Accordion mode (only one panel open) */
+    accordion?: boolean;
+    /** Whether to show border */
+    bordered?: boolean;
+    /** Position of expand icon */
+    expandIconPosition?: ExpandIconPosition;
+    /** Ghost mode (no background) */
+    ghost?: boolean;
+    /** Size */
+    size?: CollapseSize;
+    /** Callback when active panels change */
+    onChange?: (key: Key | Key[]) => void;
+    /** Collapsible trigger mode */
+    collapsible?: CollapsibleType;
+    /** Custom expand icon */
+    expandIcon?: (panelProps: {
+        isActive: boolean;
+    }) => ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Destroy inactive panel content */
+    destroyInactivePanel?: boolean;
+}

package/dist/components/color-picker/ColorPicker.d.ts

@@ -0,0 +1,4 @@
+import { ColorPickerProps } from './types';
+import * as React from "react";
+declare const InternalColorPicker: React.ForwardRefExoticComponent<ColorPickerProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalColorPicker };

package/dist/components/color-picker/index.d.ts

@@ -0,0 +1,3 @@
+declare const ColorPicker: import('react').ForwardRefExoticComponent<import('./types').ColorPickerProps & import('react').RefAttributes<HTMLDivElement>>;
+export { ColorPicker };
+export type { ColorPickerProps, ColorFormat, ColorPickerSize, ColorPickerTrigger, ColorPreset, } from './types';

package/dist/components/color-picker/types.d.ts

@@ -0,0 +1,30 @@
+import { CSSProperties, ReactNode } from 'react';
+export type ColorFormat = "hex" | "rgb" | "hsb";
+export type ColorPickerSize = "small" | "middle" | "large";
+export type ColorPickerTrigger = "click" | "hover";
+export interface ColorPreset {
+    label: ReactNode;
+    colors: string[];
+    defaultOpen?: boolean;
+}
+export interface ColorPickerProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onChangeComplete?: (value: string) => void;
+    format?: ColorFormat;
+    defaultFormat?: ColorFormat;
+    onFormatChange?: (format: ColorFormat) => void;
+    showText?: boolean | ((color: string) => ReactNode);
+    presets?: ColorPreset[];
+    allowClear?: boolean;
+    disabled?: boolean;
+    disabledAlpha?: boolean;
+    size?: ColorPickerSize;
+    trigger?: ColorPickerTrigger;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/date-picker/DatePicker.d.ts

@@ -0,0 +1,9 @@
+import { DatePickerProps } from './types';
+import * as React from "react";
+declare function daysInMonth(year: number, month: number): number;
+declare function startDayOfMonth(year: number, month: number): number;
+declare function isSameDay(a: Date, b: Date): boolean;
+declare function isToday(d: Date): boolean;
+declare function formatDate(date: Date, fmt: string): string;
+declare const InternalDatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalDatePicker, formatDate, isSameDay, isToday, daysInMonth, startDayOfMonth };

package/dist/components/date-picker/RangePicker.d.ts

@@ -0,0 +1,4 @@
+import { RangePickerProps } from './types';
+import * as React from "react";
+declare const RangePicker: React.ForwardRefExoticComponent<RangePickerProps & React.RefAttributes<HTMLDivElement>>;
+export { RangePicker };

package/dist/components/date-picker/index.d.ts

@@ -0,0 +1,8 @@
+import { InternalDatePicker } from './DatePicker';
+import { RangePicker } from './RangePicker';
+type DatePickerComponent = typeof InternalDatePicker & {
+    RangePicker: typeof RangePicker;
+};
+declare const DatePicker: DatePickerComponent;
+export { DatePicker };
+export type { DatePickerProps, RangePickerProps, DatePickerSize, DatePickerStatus, DatePickerVariant, PickerMode, DatePickerPlacement, PresetDate, } from './types';

package/dist/components/date-picker/types.d.ts

@@ -0,0 +1,60 @@
+import { CSSProperties, ReactNode } from 'react';
+export type DatePickerSize = "small" | "middle" | "large";
+export type DatePickerStatus = "error" | "warning";
+export type DatePickerVariant = "outlined" | "borderless" | "filled";
+export type PickerMode = "date" | "week" | "month" | "quarter" | "year";
+export type DatePickerPlacement = "bottomLeft" | "bottomRight" | "topLeft" | "topRight";
+export interface PresetDate {
+    label: ReactNode;
+    value: Date;
+}
+export interface DatePickerProps {
+    value?: Date;
+    defaultValue?: Date;
+    onChange?: (date: Date | null, dateString: string) => void;
+    picker?: PickerMode;
+    format?: string;
+    showTime?: boolean | {
+        format?: string;
+    };
+    showNow?: boolean;
+    showToday?: boolean;
+    disabled?: boolean;
+    disabledDate?: (currentDate: Date) => boolean;
+    placeholder?: string;
+    size?: DatePickerSize;
+    status?: DatePickerStatus;
+    variant?: DatePickerVariant;
+    placement?: DatePickerPlacement;
+    allowClear?: boolean;
+    presets?: PresetDate[];
+    suffixIcon?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    popupClassName?: string;
+    popupStyle?: CSSProperties;
+}
+export interface RangePickerProps {
+    value?: [Date | null, Date | null];
+    defaultValue?: [Date | null, Date | null];
+    onChange?: (dates: [Date | null, Date | null], dateStrings: [string, string]) => void;
+    picker?: PickerMode;
+    format?: string;
+    showTime?: boolean | {
+        format?: string;
+    };
+    disabled?: boolean | [boolean, boolean];
+    disabledDate?: (currentDate: Date) => boolean;
+    placeholder?: [string, string];
+    size?: DatePickerSize;
+    status?: DatePickerStatus;
+    variant?: DatePickerVariant;
+    placement?: DatePickerPlacement;
+    allowClear?: boolean;
+    presets?: PresetDate[];
+    separator?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/descriptions/Descriptions.d.ts

@@ -0,0 +1,4 @@
+import { DescriptionsProps } from './types';
+import * as React from "react";
+declare const InternalDescriptions: React.FC<DescriptionsProps>;
+export { InternalDescriptions };

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

@@ -0,0 +1,3 @@
+declare const Descriptions: import('react').FC<import('./types').DescriptionsProps>;
+export { Descriptions };
+export type { DescriptionsProps, DescriptionsItem, DescriptionsLayout, DescriptionsSize, ResponsiveColumn, } from './types';

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

@@ -0,0 +1,55 @@
+import { ReactNode, CSSProperties, Key } from 'react';
+export type DescriptionsLayout = "horizontal" | "vertical";
+export type DescriptionsSize = "default" | "middle" | "small";
+export interface DescriptionsItem {
+    /** Unique key */
+    key?: Key;
+    /** Label text */
+    label: ReactNode;
+    /** Content */
+    children: ReactNode;
+    /** Number of columns this item spans */
+    span?: number;
+    /** Label style */
+    labelStyle?: CSSProperties;
+    /** Content style */
+    contentStyle?: CSSProperties;
+    /** Label class name */
+    labelClassName?: string;
+    /** Content class name */
+    contentClassName?: string;
+}
+export interface ResponsiveColumn {
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    xxl?: number;
+}
+export interface DescriptionsProps {
+    /** Description items */
+    items?: DescriptionsItem[];
+    /** Whether to show border */
+    bordered?: boolean;
+    /** Number of columns per row */
+    column?: number | ResponsiveColumn;
+    /** Layout direction */
+    layout?: DescriptionsLayout;
+    /** Size */
+    size?: DescriptionsSize;
+    /** Title */
+    title?: ReactNode;
+    /** Extra content in the top-right */
+    extra?: ReactNode;
+    /** Whether to show colon after label */
+    colon?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Label style applied to all items */
+    labelStyle?: CSSProperties;
+    /** Content style applied to all items */
+    contentStyle?: CSSProperties;
+}

package/dist/components/divider/Divider.d.ts

@@ -0,0 +1,4 @@
+import { DividerProps } from './types';
+import * as React from "react";
+declare const Divider: React.ForwardRefExoticComponent<DividerProps & React.RefAttributes<HTMLDivElement>>;
+export { Divider };

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

@@ -0,0 +1,2 @@
+export { Divider } from './Divider';
+export type { DividerProps, DividerType, DividerOrientation } from './types';

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

@@ -0,0 +1,19 @@
+import { ReactNode, HTMLAttributes } from 'react';
+export type DividerType = "horizontal" | "vertical";
+export type DividerOrientation = "left" | "center" | "right";
+export interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Direction of the divider */
+    type?: DividerType;
+    /** Use dashed border style */
+    dashed?: boolean;
+    /** Position of the title text */
+    orientation?: DividerOrientation;
+    /** Custom margin for the orientation title */
+    orientationMargin?: number | string;
+    /** Title text displayed in the divider */
+    children?: ReactNode;
+    /** Use plain text style (no bold) */
+    plain?: boolean;
+    /** Extra class name */
+    className?: string;
+}

package/dist/components/drawer/Drawer.d.ts

@@ -0,0 +1,4 @@
+import { DrawerProps } from './types';
+import * as React from "react";
+declare const InternalDrawer: React.ForwardRefExoticComponent<DrawerProps & React.RefAttributes<HTMLDivElement>>;
+export { InternalDrawer };

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

@@ -0,0 +1,3 @@
+declare const Drawer: import('react').ForwardRefExoticComponent<import('./types').DrawerProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Drawer };
+export type { DrawerProps, DrawerPlacement, DrawerSize } from './types';

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

@@ -0,0 +1,49 @@
+import { ReactNode, CSSProperties } from 'react';
+export type DrawerPlacement = "top" | "right" | "bottom" | "left";
+export type DrawerSize = "default" | "large";
+export interface DrawerProps {
+    /** Whether the drawer is visible */
+    open?: boolean;
+    /** Callback when the drawer is closed */
+    onClose?: (e: React.MouseEvent | React.KeyboardEvent) => void;
+    /** Title of the drawer */
+    title?: ReactNode;
+    /** Placement of the drawer */
+    placement?: DrawerPlacement;
+    /** Width of the drawer (for left/right placement) */
+    width?: string | number;
+    /** Height of the drawer (for top/bottom placement) */
+    height?: string | number;
+    /** Footer content */
+    footer?: ReactNode;
+    /** Extra content in the header */
+    extra?: ReactNode;
+    /** Whether to show close button */
+    closable?: boolean;
+    /** Whether to show mask */
+    mask?: boolean;
+    /** Whether to support keyboard (Esc to close) */
+    keyboard?: boolean;
+    /** Destroy child elements when closed */
+    destroyOnHidden?: boolean;
+    /** Show loading state */
+    loading?: boolean;
+    /** Preset size */
+    size?: DrawerSize;
+    /** Push the content when nested drawers open */
+    push?: boolean | {
+        distance?: number;
+    };
+    /** Callback after open/close animation */
+    afterOpenChange?: (open: boolean) => void;
+    /** Mount container */
+    getContainer?: () => HTMLElement | false;
+    /** z-index of the drawer */
+    zIndex?: number;
+    /** Children content */
+    children?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+}

package/dist/components/dropdown/Dropdown.d.ts

@@ -0,0 +1,4 @@
+import { DropdownProps } from './types';
+import * as React from "react";
+declare const InternalDropdown: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<HTMLButtonElement>>;
+export { InternalDropdown };

package/dist/components/dropdown/DropdownButton.d.ts

@@ -0,0 +1,4 @@
+import { DropdownButtonProps } from './types';
+import * as React from "react";
+declare const DropdownButton: React.ForwardRefExoticComponent<DropdownButtonProps & React.RefAttributes<HTMLDivElement>>;
+export { DropdownButton };

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

@@ -0,0 +1,8 @@
+import { InternalDropdown } from './Dropdown';
+import { DropdownButton } from './DropdownButton';
+type DropdownComponent = typeof InternalDropdown & {
+    Button: typeof DropdownButton;
+};
+declare const Dropdown: DropdownComponent;
+export { Dropdown };
+export type { DropdownProps, DropdownButtonProps, DropdownMenuType, DropdownMenuItemType, DropdownTrigger, DropdownPlacement, DropdownButtonType, DropdownButtonSize, } from './types';