orizon 0.1.0

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

@@ -0,0 +1,92 @@
+import { ReactNode, CSSProperties, MouseEvent } from 'react';
+import { ButtonProps } from '../button';
+export type ModalType = "confirm" | "info" | "success" | "error" | "warning";
+export interface ModalProps {
+    /** Whether the modal is visible */
+    open?: boolean;
+    /** Callback when OK button is clicked */
+    onOk?: (e: MouseEvent<HTMLButtonElement>) => void;
+    /** Callback when Cancel button or close is triggered */
+    onCancel?: (e: MouseEvent<HTMLButtonElement>) => void;
+    /** Title of the modal */
+    title?: ReactNode;
+    /** Footer content. Pass null to hide footer. */
+    footer?: ReactNode | null | ((originNode: ReactNode, extra: {
+        OkBtn: React.FC;
+        CancelBtn: React.FC;
+    }) => ReactNode);
+    /** Width of the modal */
+    width?: string | number;
+    /** Whether to center the modal vertically */
+    centered?: boolean;
+    /** Whether to show close button */
+    closable?: boolean;
+    /** Custom close icon */
+    closeIcon?: ReactNode;
+    /** Whether OK button shows loading */
+    confirmLoading?: boolean;
+    /** Destroy child elements when closed */
+    destroyOnHidden?: boolean;
+    /** Whether to show mask */
+    mask?: boolean;
+    /** Whether clicking mask closes the modal */
+    maskClosable?: boolean;
+    /** OK button text */
+    okText?: ReactNode;
+    /** Cancel button text */
+    cancelText?: ReactNode;
+    /** OK button type */
+    okType?: ButtonProps["type"];
+    /** OK button extra props */
+    okButtonProps?: Partial<ButtonProps>;
+    /** Cancel button extra props */
+    cancelButtonProps?: Partial<ButtonProps>;
+    /** Callback after close animation */
+    afterClose?: () => void;
+    /** Callback after open/close animation */
+    afterOpenChange?: (open: boolean) => void;
+    /** Whether to support keyboard (Esc to close) */
+    keyboard?: boolean;
+    /** z-index of the modal */
+    zIndex?: number;
+    /** Show loading state */
+    loading?: boolean;
+    /** Custom modal render */
+    modalRender?: (node: ReactNode) => ReactNode;
+    /** Wrapper class name */
+    wrapClassName?: string;
+    /** Children content */
+    children?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+}
+export interface ModalStaticConfig extends Omit<ModalProps, "open"> {
+    /** Content of the modal */
+    content?: ReactNode;
+    /** Type of the modal */
+    type?: ModalType;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Auto focus the OK button */
+    autoFocusButton?: "ok" | "cancel" | null;
+}
+export interface ModalStaticFunctions {
+    confirm: (config: ModalStaticConfig) => ModalReturnType;
+    info: (config: ModalStaticConfig) => ModalReturnType;
+    success: (config: ModalStaticConfig) => ModalReturnType;
+    error: (config: ModalStaticConfig) => ModalReturnType;
+    warning: (config: ModalStaticConfig) => ModalReturnType;
+}
+export interface ModalReturnType {
+    destroy: () => void;
+    update: (config: Partial<ModalStaticConfig>) => void;
+}
+export interface ModalHookAPI {
+    confirm: (config: ModalStaticConfig) => ModalReturnType;
+    info: (config: ModalStaticConfig) => ModalReturnType;
+    success: (config: ModalStaticConfig) => ModalReturnType;
+    error: (config: ModalStaticConfig) => ModalReturnType;
+    warning: (config: ModalStaticConfig) => ModalReturnType;
+}

package/dist/components/modal/useModal.d.ts

@@ -0,0 +1,3 @@
+import { ModalHookAPI } from './types';
+import * as React from "react";
+export declare function useModal(): [ModalHookAPI, React.ReactElement];

package/dist/components/notification/NotificationContainer.d.ts

@@ -0,0 +1,10 @@
+import { NotificationInstance, NotificationPlacement } from './types';
+interface NotificationContainerProps {
+    notifications: NotificationInstance[];
+    placement: NotificationPlacement;
+    top?: number;
+    bottom?: number;
+    onClose: (id: string) => void;
+}
+export declare function NotificationContainer({ notifications, placement, top, bottom, onClose, }: NotificationContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { useNotification } from './useNotification';
+import { NotificationAPI } from './types';
+type NotificationApiWithHook = NotificationAPI & {
+    useNotification: typeof useNotification;
+};
+declare const notification: NotificationApiWithHook;
+export { notification };
+export type { NotificationAPI, NotificationConfig, NotificationGlobalConfig, NotificationType, NotificationPlacement, } from './types';

package/dist/components/notification/notificationManager.d.ts

@@ -0,0 +1,3 @@
+import { NotificationAPI } from './types';
+declare const notificationApi: NotificationAPI;
+export { notificationApi };

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

@@ -0,0 +1,69 @@
+import { ReactNode, CSSProperties } from 'react';
+export type NotificationType = "success" | "error" | "info" | "warning";
+export type NotificationPlacement = "top" | "topLeft" | "topRight" | "bottom" | "bottomLeft" | "bottomRight";
+export interface NotificationConfig {
+    /** Notification title */
+    message?: ReactNode;
+    /** Alias for message */
+    title?: ReactNode;
+    /** Description content */
+    description?: ReactNode;
+    /** Duration in seconds (0 means no auto-close) */
+    duration?: number;
+    /** Placement of the notification */
+    placement?: NotificationPlacement;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Unique key */
+    key?: string | number;
+    /** Action buttons area */
+    actions?: ReactNode;
+    /** Show countdown progress bar */
+    showProgress?: boolean;
+    /** Pause countdown on hover */
+    pauseOnHover?: boolean;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+    /** Click handler */
+    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    /** Called when notification closes */
+    onClose?: () => void;
+    /** Notification type */
+    type?: NotificationType;
+    /** Whether to show close button */
+    closable?: boolean;
+    /** Custom close icon */
+    closeIcon?: ReactNode;
+}
+export interface NotificationGlobalConfig {
+    /** Bottom offset */
+    bottom?: number;
+    /** Top offset */
+    top?: number;
+    /** Default placement */
+    placement?: NotificationPlacement;
+    /** Maximum count */
+    maxCount?: number;
+    /** Stack behavior */
+    stack?: boolean | {
+        threshold?: number;
+    };
+}
+export interface NotificationAPI {
+    success: (config: NotificationConfig) => void;
+    error: (config: NotificationConfig) => void;
+    info: (config: NotificationConfig) => void;
+    warning: (config: NotificationConfig) => void;
+    open: (config: NotificationConfig) => void;
+    destroy: (key?: string | number) => void;
+    config: (options: NotificationGlobalConfig) => void;
+}
+export interface NotificationInstance {
+    id: string;
+    config: NotificationConfig;
+    type?: NotificationType;
+    closing: boolean;
+    createdAt: number;
+}

package/dist/components/notification/useNotification.d.ts

@@ -0,0 +1,3 @@
+import { NotificationAPI } from './types';
+import * as React from "react";
+export declare function useNotification(): [NotificationAPI, React.ReactElement];

package/dist/components/pagination/Pagination.d.ts

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

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

@@ -0,0 +1,2 @@
+export { Pagination } from './Pagination';
+export type { PaginationProps, PaginationSize } from './types';

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

@@ -0,0 +1,34 @@
+import { ReactNode } from 'react';
+export type PaginationSize = "small" | "default";
+export interface PaginationProps {
+    /** Current page number (controlled) */
+    current?: number;
+    /** Default current page (uncontrolled) */
+    defaultCurrent?: number;
+    /** Number of items per page */
+    pageSize?: number;
+    /** Default page size (uncontrolled) */
+    defaultPageSize?: number;
+    /** Total number of data items */
+    total: number;
+    /** Show a page size select */
+    showSizeChanger?: boolean;
+    /** Available page sizes for the size changer */
+    pageSizeOptions?: number[];
+    /** Show a quick jumper input */
+    showQuickJumper?: boolean;
+    /** Show total count; can be a render function */
+    showTotal?: (total: number, range: [number, number]) => ReactNode;
+    /** Simple mode (no page numbers) */
+    simple?: boolean;
+    /** Callback when page or pageSize changes */
+    onChange?: (page: number, pageSize: number) => void;
+    /** Callback when pageSize changes */
+    onShowSizeChange?: (current: number, size: number) => void;
+    /** Whether pagination is disabled */
+    disabled?: boolean;
+    /** Size of pagination */
+    size?: PaginationSize;
+    /** Extra class name */
+    className?: string;
+}

package/dist/components/popconfirm/Popconfirm.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Popconfirm: import('react').ForwardRefExoticComponent<import('./types').PopconfirmProps & import('react').RefAttributes<HTMLButtonElement>>;
+export { Popconfirm };
+export type { PopconfirmProps, PopconfirmPlacement } from './types';

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

@@ -0,0 +1,39 @@
+import { ReactNode } from 'react';
+import { ButtonProps } from '../button';
+export type PopconfirmPlacement = "top" | "topLeft" | "topRight" | "bottom" | "bottomLeft" | "bottomRight" | "left" | "leftTop" | "leftBottom" | "right" | "rightTop" | "rightBottom";
+export interface PopconfirmProps {
+    /** Title of the confirm popup */
+    title: ReactNode | (() => ReactNode);
+    /** Description text */
+    description?: ReactNode | (() => ReactNode);
+    /** Callback when OK is clicked */
+    onConfirm?: (e?: React.MouseEvent<HTMLButtonElement>) => void;
+    /** Callback when Cancel is clicked */
+    onCancel?: (e?: React.MouseEvent<HTMLButtonElement>) => void;
+    /** OK button text */
+    okText?: ReactNode;
+    /** Cancel button text */
+    cancelText?: ReactNode;
+    /** OK button type */
+    okType?: ButtonProps["type"];
+    /** OK button extra props */
+    okButtonProps?: Partial<ButtonProps>;
+    /** Cancel button extra props */
+    cancelButtonProps?: Partial<ButtonProps>;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Whether the popconfirm is disabled */
+    disabled?: boolean;
+    /** Placement of the popup */
+    placement?: PopconfirmPlacement;
+    /** Controlled open state */
+    open?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Whether to show cancel button */
+    showCancel?: boolean;
+    /** Trigger element */
+    children?: ReactNode;
+    /** Extra class name */
+    className?: string;
+}

package/dist/components/popover/Popover.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Popover: import('react').FC<import('./types').PopoverProps>;
+export { Popover };
+export type { PopoverProps, PopoverPlacement, PopoverTrigger } from './types';

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

@@ -0,0 +1,31 @@
+import { ReactNode, CSSProperties } from 'react';
+export type PopoverPlacement = "top" | "topLeft" | "topRight" | "bottom" | "bottomLeft" | "bottomRight" | "left" | "leftTop" | "leftBottom" | "right" | "rightTop" | "rightBottom";
+export type PopoverTrigger = "hover" | "focus" | "click";
+export interface PopoverProps {
+    /** Popover body content */
+    content?: ReactNode | (() => ReactNode);
+    /** Popover title */
+    title?: ReactNode;
+    /** Trigger mode */
+    trigger?: PopoverTrigger;
+    /** Placement */
+    placement?: PopoverPlacement;
+    /** Controlled open state */
+    open?: boolean;
+    /** Default open state */
+    defaultOpen?: boolean;
+    /** Callback when open changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Whether to show arrow */
+    arrow?: boolean;
+    /** Overlay class name */
+    overlayClassName?: string;
+    /** Overlay style */
+    overlayStyle?: CSSProperties;
+    /** Mouse enter delay (seconds) */
+    mouseEnterDelay?: number;
+    /** Mouse leave delay (seconds) */
+    mouseLeaveDelay?: number;
+    /** Children trigger element */
+    children?: ReactNode;
+}

package/dist/components/progress/Progress.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Progress: import('react').ForwardRefExoticComponent<import('./types').ProgressProps & import('react').RefAttributes<HTMLDivElement>>;
+export { Progress };
+export type { ProgressProps, ProgressType, ProgressStatus, ProgressStrokeLinecap, ProgressSuccessConfig, ProgressSize, } from './types';

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

@@ -0,0 +1,39 @@
+import { ReactNode, CSSProperties } from 'react';
+export type ProgressType = "line" | "circle" | "dashboard";
+export type ProgressStatus = "success" | "exception" | "normal" | "active";
+export type ProgressStrokeLinecap = "round" | "butt" | "square";
+export interface ProgressSuccessConfig {
+    percent?: number;
+    strokeColor?: string;
+}
+export type ProgressSize = "small" | "default" | [number, number];
+export interface ProgressProps {
+    /** Completion percentage */
+    percent?: number;
+    /** Type of progress bar */
+    type?: ProgressType;
+    /** Status of the progress */
+    status?: ProgressStatus;
+    /** Stroke color */
+    strokeColor?: string | string[] | Record<string, string>;
+    /** Whether to show info text */
+    showInfo?: boolean;
+    /** Size of the progress */
+    size?: ProgressSize;
+    /** Number of steps (for segmented line) */
+    steps?: number;
+    /** Custom format function */
+    format?: (percent?: number, successPercent?: number) => ReactNode;
+    /** Stroke linecap style */
+    strokeLinecap?: ProgressStrokeLinecap;
+    /** Success segment config */
+    success?: ProgressSuccessConfig;
+    /** Rail (track) color */
+    railColor?: string;
+    /** Stroke width in px */
+    strokeWidth?: number;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+}

package/dist/components/qrcode/QRCode.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const QRCode: import('react').FC<import('./types').QRCodeProps>;
+export { QRCode };
+export type { QRCodeProps, QRCodeErrorLevel, QRCodeStatus, QRCodeType, } from './types';

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

@@ -0,0 +1,32 @@
+import { CSSProperties } from 'react';
+export type QRCodeErrorLevel = "L" | "M" | "Q" | "H";
+export type QRCodeStatus = "active" | "expired" | "loading" | "scanned";
+export type QRCodeType = "canvas" | "svg";
+export interface QRCodeProps {
+    /** The value/URL to encode in the QR code */
+    value: string;
+    /** Size in pixels */
+    size?: number;
+    /** QR code color */
+    color?: string;
+    /** Background color */
+    bgColor?: string;
+    /** Whether to show border */
+    bordered?: boolean;
+    /** Error correction level */
+    errorLevel?: QRCodeErrorLevel;
+    /** Center icon URL */
+    icon?: string;
+    /** Icon size in pixels */
+    iconSize?: number;
+    /** Status of the QR code */
+    status?: QRCodeStatus;
+    /** Render type */
+    type?: QRCodeType;
+    /** Callback when refresh is clicked for expired status */
+    onRefresh?: () => void;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}

package/dist/components/radio/Radio.d.ts

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

package/dist/components/radio/RadioButton.d.ts

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

package/dist/components/radio/RadioGroup.d.ts

@@ -0,0 +1,12 @@
+import { RadioGroupProps, ComponentSize } from './types';
+import * as React from "react";
+export interface RadioGroupContextValue {
+    value: any;
+    disabled: boolean;
+    onChange: (value: any) => void;
+    buttonStyle?: "outline" | "solid";
+    size?: ComponentSize;
+}
+export declare const RadioGroupContext: React.Context<RadioGroupContextValue | null>;
+declare const InternalRadioGroup: React.FC<RadioGroupProps>;
+export { InternalRadioGroup };

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

@@ -0,0 +1,10 @@
+import { InternalRadio } from './Radio';
+import { InternalRadioGroup } from './RadioGroup';
+import { RadioButton } from './RadioButton';
+type RadioComponent = typeof InternalRadio & {
+    Group: typeof InternalRadioGroup;
+    Button: typeof RadioButton;
+};
+declare const Radio: RadioComponent;
+export { Radio };
+export type { RadioProps, RadioGroupProps, RadioButtonProps, RadioChangeEvent, RadioOptionType, } from './types';

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

@@ -0,0 +1,72 @@
+import { ReactNode } from 'react';
+export type ComponentSize = "small" | "middle" | "large";
+export interface RadioChangeEvent {
+    target: {
+        checked: boolean;
+        value: any;
+    };
+    stopPropagation: () => void;
+    preventDefault: () => void;
+    nativeEvent: Event | undefined;
+}
+export interface RadioProps {
+    /** Whether the radio is checked (controlled) */
+    checked?: boolean;
+    /** Default checked state (uncontrolled) */
+    defaultChecked?: boolean;
+    /** Whether the radio is disabled */
+    disabled?: boolean;
+    /** Value of this radio */
+    value?: any;
+    /** Callback when state changes */
+    onChange?: (e: RadioChangeEvent) => void;
+    /** Label content */
+    children?: ReactNode;
+    /** Additional class name */
+    className?: string;
+    /** ID attribute */
+    id?: string;
+    /** Name attribute */
+    name?: string;
+}
+export interface RadioOptionType {
+    label: ReactNode;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface RadioGroupProps {
+    /** Options to render */
+    options?: (string | number | RadioOptionType)[];
+    /** Controlled selected value */
+    value?: any;
+    /** Default selected value */
+    defaultValue?: any;
+    /** Callback when selected value changes */
+    onChange?: (e: RadioChangeEvent) => void;
+    /** Render as button-styled options */
+    optionType?: "default" | "button";
+    /** Button style variant (only when optionType="button") */
+    buttonStyle?: "outline" | "solid";
+    /** Size of the radio group */
+    size?: ComponentSize;
+    /** Disable all radios in the group */
+    disabled?: boolean;
+    /** Whether buttons take full width */
+    block?: boolean;
+    /** Additional class name */
+    className?: string;
+    /** Name attribute for all radios */
+    name?: string;
+    /** Child content (alternative to options prop) */
+    children?: ReactNode;
+}
+export interface RadioButtonProps {
+    /** Value of this radio button */
+    value: any;
+    /** Whether the radio button is disabled */
+    disabled?: boolean;
+    /** Label content */
+    children?: ReactNode;
+    /** Additional class name */
+    className?: string;
+}

package/dist/components/rate/Rate.d.ts

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

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

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

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

@@ -0,0 +1,18 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface RateProps {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number) => void;
+    count?: number;
+    allowHalf?: boolean;
+    allowClear?: boolean;
+    character?: ReactNode | ((info: {
+        index: number;
+        value: number;
+    }) => ReactNode);
+    disabled?: boolean;
+    tooltips?: string[];
+    className?: string;
+    style?: CSSProperties;
+    onHoverChange?: (value: number) => void;
+}

package/dist/components/result/Result.d.ts

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

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

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

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

@@ -0,0 +1,20 @@
+import { ReactNode, CSSProperties } from 'react';
+export type ResultStatus = "success" | "error" | "info" | "warning" | 404 | 403 | 500;
+export interface ResultProps {
+    /** Result status */
+    status?: ResultStatus;
+    /** Title text */
+    title?: ReactNode;
+    /** Sub title text */
+    subTitle?: ReactNode;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Extra action area */
+    extra?: ReactNode;
+    /** Children content */
+    children?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Inline style */
+    style?: CSSProperties;
+}

package/dist/components/segmented/Segmented.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Segmented: import('react').FC<import('./types').SegmentedProps>;
+export { Segmented };
+export type { SegmentedProps, SegmentedOption, SegmentedOptionType, SegmentedSize, } from './types';

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

@@ -0,0 +1,30 @@
+import { ReactNode, CSSProperties } from 'react';
+export type SegmentedSize = "large" | "middle" | "small";
+export interface SegmentedOption {
+    label: ReactNode;
+    value: string | number;
+    icon?: ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+export type SegmentedOptionType = string | number | SegmentedOption;
+export interface SegmentedProps {
+    /** Options for the segmented control */
+    options: SegmentedOptionType[];
+    /** Currently selected value (controlled) */
+    value?: string | number;
+    /** Default selected value */
+    defaultValue?: string | number;
+    /** Callback when selection changes */
+    onChange?: (value: string | number) => void;
+    /** Full width */
+    block?: boolean;
+    /** Disable all options */
+    disabled?: boolean;
+    /** Size */
+    size?: SegmentedSize;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}

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

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