orizon 0.1.0

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

@@ -0,0 +1,126 @@
+import { ReactNode, InputHTMLAttributes, TextareaHTMLAttributes, KeyboardEventHandler, ChangeEventHandler } from 'react';
+export type InputSize = "small" | "middle" | "large";
+export type InputStatus = "error" | "warning";
+export type InputVariant = "outlined" | "borderless" | "filled" | "underlined";
+export interface ShowCountInfo {
+    value: string;
+    count: number;
+    maxLength?: number;
+}
+export type ShowCountFormatter = (info: ShowCountInfo) => ReactNode;
+export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "prefix" | "onChange"> {
+    /** Controlled value */
+    value?: string;
+    /** Default (uncontrolled) value */
+    defaultValue?: string;
+    /** Change handler – receives the native React ChangeEvent */
+    onChange?: ChangeEventHandler<HTMLInputElement>;
+    /** Component size */
+    size?: InputSize;
+    /** Prefix icon / node rendered inside the input (left) */
+    prefix?: ReactNode;
+    /** Suffix icon / node rendered inside the input (right) */
+    suffix?: ReactNode;
+    /** Addon rendered *before* the input as a separate segment */
+    addonBefore?: ReactNode;
+    /** Addon rendered *after* the input as a separate segment */
+    addonAfter?: ReactNode;
+    /** Show a clear button when the input has value */
+    allowClear?: boolean | {
+        clearIcon?: ReactNode;
+    };
+    /** Validation status */
+    status?: InputStatus;
+    /** Visual variant */
+    variant?: InputVariant;
+    /** Display character count below / after the input */
+    showCount?: boolean | ShowCountFormatter;
+    /** Maximum number of characters */
+    maxLength?: number;
+    /** Whether the input is disabled */
+    disabled?: boolean;
+    /** Whether the input is read-only */
+    readOnly?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Callback fired when Enter is pressed */
+    onPressEnter?: KeyboardEventHandler<HTMLInputElement>;
+    /** Callback fired when the clear button is clicked */
+    onClear?: () => void;
+    /** Extra class name */
+    className?: string;
+}
+export interface InputPasswordProps extends Omit<InputProps, "type"> {
+    /** Whether to show the toggle icon – defaults to true */
+    visibilityToggle?: boolean;
+    /** Controlled visible state */
+    visible?: boolean;
+    /** Callback when visibility changes */
+    onVisibleChange?: (visible: boolean) => void;
+    /** Custom icons: [visible, hidden] */
+    iconRender?: (visible: boolean) => ReactNode;
+}
+export interface AutoSizeConfig {
+    minRows?: number;
+    maxRows?: number;
+}
+export interface InputTextAreaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "onChange"> {
+    /** Controlled value */
+    value?: string;
+    /** Default (uncontrolled) value */
+    defaultValue?: string;
+    /** Change handler */
+    onChange?: ChangeEventHandler<HTMLTextAreaElement>;
+    /** Auto-resize the textarea to fit content */
+    autoSize?: boolean | AutoSizeConfig;
+    /** Display character count */
+    showCount?: boolean | ShowCountFormatter;
+    /** Maximum number of characters */
+    maxLength?: number;
+    /** Component size */
+    size?: InputSize;
+    /** Validation status */
+    status?: InputStatus;
+    /** Visual variant */
+    variant?: InputVariant;
+    /** Callback fired when Enter is pressed */
+    onPressEnter?: KeyboardEventHandler<HTMLTextAreaElement>;
+    /** Callback fired when the clear button is clicked */
+    onClear?: () => void;
+    /** Show a clear button */
+    allowClear?: boolean | {
+        clearIcon?: ReactNode;
+    };
+    /** Extra class name */
+    className?: string;
+}
+export interface InputSearchProps extends InputProps {
+    /** Render a button after the input; `true` renders the default "Search" text */
+    enterButton?: boolean | ReactNode;
+    /** Show a loading spinner */
+    loading?: boolean;
+    /** Callback fired on search (Enter key or button click) */
+    onSearch?: (value: string, event?: React.SyntheticEvent) => void;
+}
+export interface InputOTPProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "defaultValue" | "size"> {
+    /** Number of input fields – defaults to 6 */
+    length?: number;
+    /** Controlled value (full string) */
+    value?: string;
+    /** Default value */
+    defaultValue?: string;
+    /** Fires with the combined value string */
+    onChange?: (value: string) => void;
+    /** Mask character (e.g. "*") – hides entered characters */
+    mask?: boolean | string;
+    /** Component size */
+    size?: InputSize;
+    /** Validation status */
+    status?: InputStatus;
+    /** Whether the input is disabled */
+    disabled?: boolean;
+    /** Auto-focus the first input on mount */
+    autoFocus?: boolean;
+    /** Extra class name for the wrapper */
+    className?: string;
+}

package/dist/components/input-number/InputNumber.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const InputNumber: import('react').ForwardRefExoticComponent<import('./types').InputNumberProps<number> & import('react').RefAttributes<HTMLInputElement>>;
+export { InputNumber };
+export type { InputNumberProps, InputNumberSize, InputNumberStatus, InputNumberVariant, } from './types';

package/dist/components/input-number/types.d.ts

@@ -0,0 +1,42 @@
+import { CSSProperties, ReactNode } from 'react';
+export type InputNumberSize = "small" | "middle" | "large";
+export type InputNumberStatus = "error" | "warning";
+export type InputNumberVariant = "outlined" | "borderless" | "filled";
+export interface InputNumberProps<T = number> {
+    value?: T;
+    defaultValue?: T;
+    onChange?: (value: T | null) => void;
+    min?: T;
+    max?: T;
+    step?: T extends number ? number : never;
+    precision?: number;
+    formatter?: (value: T | undefined, info: {
+        userTyping: boolean;
+        input: string;
+    }) => string;
+    parser?: (displayValue: string | undefined) => T;
+    controls?: boolean | {
+        upIcon?: ReactNode;
+        downIcon?: ReactNode;
+    };
+    addonBefore?: ReactNode;
+    addonAfter?: ReactNode;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    size?: InputNumberSize;
+    status?: InputNumberStatus;
+    variant?: InputNumberVariant;
+    disabled?: boolean;
+    readOnly?: boolean;
+    placeholder?: string;
+    stringMode?: boolean;
+    keyboard?: boolean;
+    changeOnWheel?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    onStep?: (value: number, info: {
+        offset: number;
+        type: "up" | "down";
+    }) => void;
+    onPressEnter?: (e: React.KeyboardEvent) => void;
+}

package/dist/components/layout/Layout.d.ts

@@ -0,0 +1,7 @@
+import { LayoutProps, HeaderProps, ContentProps, FooterProps } from './types';
+import * as React from "react";
+declare const InternalLayout: React.ForwardRefExoticComponent<LayoutProps & React.RefAttributes<HTMLElement>>;
+declare const Header: React.ForwardRefExoticComponent<HeaderProps & React.RefAttributes<HTMLElement>>;
+declare const Content: React.ForwardRefExoticComponent<ContentProps & React.RefAttributes<HTMLElement>>;
+declare const Footer: React.ForwardRefExoticComponent<FooterProps & React.RefAttributes<HTMLElement>>;
+export { InternalLayout, Header, Content, Footer };

package/dist/components/layout/Sider.d.ts

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

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

@@ -0,0 +1,11 @@
+import { InternalLayout, Header, Content, Footer } from './Layout';
+import { Sider } from './Sider';
+type LayoutComponent = typeof InternalLayout & {
+    Header: typeof Header;
+    Sider: typeof Sider;
+    Content: typeof Content;
+    Footer: typeof Footer;
+};
+declare const Layout: LayoutComponent;
+export { Layout };
+export type { LayoutProps, HeaderProps, ContentProps, FooterProps, SiderProps, SiderTheme, SiderBreakpoint, } from './types';

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

@@ -0,0 +1,52 @@
+import { ReactNode, HTMLAttributes, CSSProperties } from 'react';
+export type SiderTheme = "light" | "dark";
+export type SiderBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export interface LayoutProps extends HTMLAttributes<HTMLElement> {
+    /** Whether the layout contains a Sider (auto-detected) */
+    hasSider?: boolean;
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}
+export interface HeaderProps extends HTMLAttributes<HTMLElement> {
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}
+export interface ContentProps extends HTMLAttributes<HTMLElement> {
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}
+export interface FooterProps extends HTMLAttributes<HTMLElement> {
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}
+export interface SiderProps extends HTMLAttributes<HTMLElement> {
+    /** Whether the sider is collapsed */
+    collapsed?: boolean;
+    /** Whether the sider can be collapsed */
+    collapsible?: boolean;
+    /** Width of collapsed sider */
+    collapsedWidth?: number;
+    /** Width of sider */
+    width?: number | string;
+    /** Breakpoint at which to auto-collapse */
+    breakpoint?: SiderBreakpoint;
+    /** Theme of the sider */
+    theme?: SiderTheme;
+    /** Custom trigger element; null hides the default trigger */
+    trigger?: ReactNode | null;
+    /** Callback when collapsed state changes */
+    onCollapse?: (collapsed: boolean, type: "clickTrigger" | "responsive") => void;
+    /** Callback when breakpoint changes */
+    onBreakpoint?: (broken: boolean) => void;
+    /** Reverse arrow direction */
+    reverseArrow?: boolean;
+    /** Zero-width trigger style */
+    zeroWidthTriggerStyle?: CSSProperties;
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}

package/dist/components/list/List.d.ts

@@ -0,0 +1,9 @@
+import { ListProps, ListItemProps, ListItemMetaProps } from './types';
+import * as React from "react";
+declare const ListItemMeta: React.FC<ListItemMetaProps>;
+declare const ListItem: React.ForwardRefExoticComponent<ListItemProps & React.RefAttributes<HTMLDivElement>>;
+declare function InternalList<T = unknown>({ dataSource, renderItem, header, footer, bordered, loading, pagination: paginationProp, size, grid, itemLayout, split, locale, className, style, rowKey, }: ListProps<T>): import("react/jsx-runtime").JSX.Element;
+declare namespace InternalList {
+    var displayName: string;
+}
+export { InternalList, ListItem, ListItemMeta };

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

@@ -0,0 +1,11 @@
+import { InternalList, ListItem as InternalListItem, ListItemMeta } from './List';
+type ListItemComponent = typeof InternalListItem & {
+    Meta: typeof ListItemMeta;
+};
+declare const ListItemWithMeta: ListItemComponent;
+type ListComponent = typeof InternalList & {
+    Item: typeof ListItemWithMeta;
+};
+declare const List: ListComponent;
+export { List };
+export type { ListProps, ListItemProps, ListItemMetaProps, ListSize, ListItemLayout, ListGridConfig, ListPaginationConfig, } from './types';

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

@@ -0,0 +1,83 @@
+import { ReactNode, CSSProperties } from 'react';
+export type ListSize = "default" | "large" | "small";
+export type ListItemLayout = "horizontal" | "vertical";
+export interface ListGridConfig {
+    /** Number of columns */
+    column?: number;
+    /** Gap between items */
+    gutter?: number;
+    /** Responsive columns */
+    xs?: number;
+    sm?: number;
+    md?: number;
+    lg?: number;
+    xl?: number;
+    xxl?: number;
+}
+export interface ListPaginationConfig {
+    current?: number;
+    pageSize?: number;
+    total?: number;
+    onChange?: (page: number, pageSize: number) => void;
+    position?: "top" | "bottom" | "both";
+    align?: "start" | "center" | "end";
+    simple?: boolean;
+    size?: "default" | "small";
+}
+export interface ListProps<T = unknown> {
+    /** Data source */
+    dataSource?: T[];
+    /** Render each item */
+    renderItem?: (item: T, index: number) => ReactNode;
+    /** List header */
+    header?: ReactNode;
+    /** List footer */
+    footer?: ReactNode;
+    /** Show border */
+    bordered?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Pagination config */
+    pagination?: ListPaginationConfig | false;
+    /** Size */
+    size?: ListSize;
+    /** Grid config */
+    grid?: ListGridConfig;
+    /** Item layout direction */
+    itemLayout?: ListItemLayout;
+    /** Show split line between items */
+    split?: boolean;
+    /** Empty text */
+    locale?: {
+        emptyText?: ReactNode;
+    };
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Row key */
+    rowKey?: string | ((item: T) => string);
+}
+export interface ListItemProps {
+    /** Action list */
+    actions?: ReactNode[];
+    /** Extra content */
+    extra?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    children?: ReactNode;
+}
+export interface ListItemMetaProps {
+    /** Avatar or icon */
+    avatar?: ReactNode;
+    /** Title */
+    title?: ReactNode;
+    /** Description */
+    description?: ReactNode;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}

package/dist/components/masonry/Masonry.d.ts

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

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

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

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

@@ -0,0 +1,11 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface MasonryProps {
+    columns?: number | Record<string, number>;
+    gutter?: number | [number, number];
+    items?: ReactNode[];
+    itemRender?: (item: ReactNode, index: number) => ReactNode;
+    sequential?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    children?: ReactNode;
+}

package/dist/components/mentions/Mentions.d.ts

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

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

@@ -0,0 +1,3 @@
+declare const Mentions: import('react').ForwardRefExoticComponent<import('./types').MentionsProps & import('react').RefAttributes<HTMLTextAreaElement>>;
+export { Mentions };
+export type { MentionsProps, MentionOption, MentionsPlacement, MentionsStatus, MentionsVariant, } from './types';

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

@@ -0,0 +1,33 @@
+import { CSSProperties, ReactNode } from 'react';
+export interface MentionOption {
+    value: string;
+    label?: ReactNode;
+    disabled?: boolean;
+}
+export type MentionsPlacement = "top" | "bottom";
+export type MentionsStatus = "error" | "warning";
+export type MentionsVariant = "outlined" | "borderless" | "filled";
+export interface MentionsProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (text: string) => void;
+    onSelect?: (option: MentionOption, prefix: string) => void;
+    onSearch?: (text: string, prefix: string) => void;
+    options?: MentionOption[];
+    prefix?: string | string[];
+    split?: string;
+    placement?: MentionsPlacement;
+    status?: MentionsStatus;
+    variant?: MentionsVariant;
+    disabled?: boolean;
+    readOnly?: boolean;
+    placeholder?: string;
+    allowClear?: boolean;
+    autoSize?: boolean | {
+        minRows?: number;
+        maxRows?: number;
+    };
+    rows?: number;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/menu/Menu.d.ts

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

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

@@ -0,0 +1,2 @@
+export { Menu } from './Menu';
+export type { MenuProps, MenuItemType, MenuInfo, MenuMode, MenuTheme } from './types';

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

@@ -0,0 +1,66 @@
+import { ReactNode, CSSProperties } from 'react';
+export type MenuMode = "horizontal" | "vertical" | "inline";
+export type MenuTheme = "light" | "dark";
+export interface MenuItemType {
+    /** Unique key */
+    key: string;
+    /** Label content */
+    label: ReactNode;
+    /** Icon for the item */
+    icon?: ReactNode;
+    /** Child menu items (creates a submenu) */
+    children?: MenuItemType[];
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Danger styling */
+    danger?: boolean;
+    /** Type of item */
+    type?: "group" | "divider";
+    /** Title for group type */
+    title?: string;
+    /** Extra class name */
+    className?: string;
+}
+export interface MenuInfo {
+    key: string;
+    keyPath: string[];
+    domEvent: React.MouseEvent | React.KeyboardEvent;
+}
+export interface MenuProps {
+    /** Menu mode */
+    mode?: MenuMode;
+    /** Menu items */
+    items?: MenuItemType[];
+    /** Currently selected keys (controlled) */
+    selectedKeys?: string[];
+    /** Default selected keys */
+    defaultSelectedKeys?: string[];
+    /** Currently open submenu keys (controlled) */
+    openKeys?: string[];
+    /** Default open submenu keys */
+    defaultOpenKeys?: string[];
+    /** Callback when an item is clicked */
+    onClick?: (info: MenuInfo) => void;
+    /** Callback when open submenus change */
+    onOpenChange?: (openKeys: string[]) => void;
+    /** Callback when an item is selected */
+    onSelect?: (info: MenuInfo & {
+        selectedKeys: string[];
+    }) => void;
+    /** Callback when an item is deselected */
+    onDeselect?: (info: MenuInfo & {
+        selectedKeys: string[];
+    }) => void;
+    /** Theme */
+    theme?: MenuTheme;
+    /** Allow multiple selection */
+    multiple?: boolean;
+    /** Indent width for inline mode (in px) */
+    inlineIndent?: number;
+    /** Whether to collapse the menu */
+    inlineCollapsed?: boolean;
+    /** Style */
+    style?: CSSProperties;
+    /** Extra class name */
+    className?: string;
+}

package/dist/components/message/MessageContainer.d.ts

@@ -0,0 +1,7 @@
+import { MessageInstance } from './types';
+interface MessageContainerProps {
+    messages: MessageInstance[];
+    top?: number;
+}
+export declare function MessageContainer({ messages, top }: MessageContainerProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,8 @@
+import { useMessage } from './useMessage';
+import { MessageAPI } from './types';
+type MessageApiWithHook = MessageAPI & {
+    useMessage: typeof useMessage;
+};
+declare const message: MessageApiWithHook;
+export { message };
+export type { MessageAPI, MessageConfig, MessageGlobalConfig, MessageType, MessageClosePromise, } from './types';

package/dist/components/message/messageManager.d.ts

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

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

@@ -0,0 +1,52 @@
+import { ReactNode, CSSProperties } from 'react';
+export type MessageType = "success" | "error" | "info" | "warning" | "loading";
+export interface MessageConfig {
+    /** Message content */
+    content: ReactNode;
+    /** Duration in seconds (0 means no auto-close) */
+    duration?: number;
+    /** Custom icon */
+    icon?: ReactNode;
+    /** Unique key for the message */
+    key?: string | number;
+    /** Extra class name */
+    className?: string;
+    /** Click handler */
+    onClick?: (e: React.MouseEvent<HTMLDivElement>) => void;
+    /** Called when message closes */
+    onClose?: () => void;
+    /** Message type */
+    type?: MessageType;
+    /** Inline style */
+    style?: CSSProperties;
+}
+export interface MessageGlobalConfig {
+    /** Top offset */
+    top?: number;
+    /** Default duration in seconds */
+    duration?: number;
+    /** Maximum count of messages */
+    maxCount?: number;
+    /** Mount container */
+    getContainer?: () => HTMLElement;
+}
+export interface MessageAPI {
+    success: (content: ReactNode | MessageConfig, duration?: number, onClose?: () => void) => MessageClosePromise;
+    error: (content: ReactNode | MessageConfig, duration?: number, onClose?: () => void) => MessageClosePromise;
+    info: (content: ReactNode | MessageConfig, duration?: number, onClose?: () => void) => MessageClosePromise;
+    warning: (content: ReactNode | MessageConfig, duration?: number, onClose?: () => void) => MessageClosePromise;
+    loading: (content: ReactNode | MessageConfig, duration?: number, onClose?: () => void) => MessageClosePromise;
+    open: (config: MessageConfig) => MessageClosePromise;
+    destroy: (key?: string | number) => void;
+    config: (options: MessageGlobalConfig) => void;
+}
+export interface MessageClosePromise {
+    (): void;
+    then: (resolve: () => void, reject?: () => void) => Promise<void>;
+}
+export interface MessageInstance {
+    id: string;
+    config: MessageConfig;
+    type: MessageType;
+    closing: boolean;
+}

package/dist/components/message/useMessage.d.ts

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

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

@@ -0,0 +1,7 @@
+import { ModalStaticConfig } from './types';
+interface ConfirmModalProps extends ModalStaticConfig {
+    open: boolean;
+    onInternalClose: () => void;
+}
+export declare function ConfirmModal({ open, onInternalClose, type, title, content, icon, onOk, onCancel, okText, cancelText, okType, okButtonProps, cancelButtonProps, closable, closeIcon, confirmLoading, width, centered, mask, maskClosable, zIndex, className, style, }: ConfirmModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,9 @@
+import { InternalModal } from './Modal';
+import { useModal } from './useModal';
+import { ModalStaticFunctions } from './types';
+type ModalComponent = typeof InternalModal & ModalStaticFunctions & {
+    useModal: typeof useModal;
+};
+declare const Modal: ModalComponent;
+export { Modal };
+export type { ModalProps, ModalStaticConfig, ModalStaticFunctions, ModalReturnType, ModalHookAPI, ModalType, } from './types';

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

@@ -0,0 +1,6 @@
+import { ModalStaticConfig, ModalReturnType } from './types';
+export declare function confirm(config: ModalStaticConfig): ModalReturnType;
+export declare function info(config: ModalStaticConfig): ModalReturnType;
+export declare function success(config: ModalStaticConfig): ModalReturnType;
+export declare function error(config: ModalStaticConfig): ModalReturnType;
+export declare function warning(config: ModalStaticConfig): ModalReturnType;