orizon 0.1.0

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

@@ -0,0 +1,76 @@
+import { ReactNode, MouseEventHandler } from 'react';
+export type DropdownTrigger = "hover" | "click" | "contextMenu";
+export type DropdownPlacement = "top" | "topLeft" | "topRight" | "bottom" | "bottomLeft" | "bottomRight";
+export interface DropdownMenuItemType {
+    /** Unique key */
+    key: string;
+    /** Label text or node */
+    label: ReactNode;
+    /** Icon for the item */
+    icon?: ReactNode;
+    /** Whether the item is disabled */
+    disabled?: boolean;
+    /** Whether the item is danger-styled */
+    danger?: boolean;
+    /** Click handler */
+    onClick?: (info: {
+        key: string;
+        domEvent: React.MouseEvent;
+    }) => void;
+    /** Type of item */
+    type?: "divider" | "group";
+    /** Children (for group type) */
+    children?: DropdownMenuItemType[];
+}
+export interface DropdownMenuType {
+    items: DropdownMenuItemType[];
+    onClick?: (info: {
+        key: string;
+        domEvent: React.MouseEvent;
+    }) => void;
+    selectedKeys?: string[];
+}
+export interface DropdownProps {
+    /** Menu configuration */
+    menu?: DropdownMenuType;
+    /** How the dropdown is triggered */
+    trigger?: DropdownTrigger[];
+    /** Placement of the dropdown */
+    placement?: DropdownPlacement;
+    /** Controlled open state */
+    open?: boolean;
+    /** Callback when open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Whether the dropdown is disabled */
+    disabled?: boolean;
+    /** The trigger element */
+    children?: ReactNode;
+    /** Extra class name for the content */
+    overlayClassName?: string;
+    /** Arrow display */
+    arrow?: boolean;
+    /** Destroy popup on hide */
+    destroyPopupOnHide?: boolean;
+    /** Auto-adjust overflow */
+    autoAdjustOverflow?: boolean;
+    /** Extra class name */
+    className?: string;
+}
+export type DropdownButtonType = "primary" | "default" | "dashed" | "link" | "text";
+export type DropdownButtonSize = "small" | "middle" | "large";
+export interface DropdownButtonProps extends Omit<DropdownProps, "children"> {
+    /** Icon for the dropdown trigger button */
+    icon?: ReactNode;
+    /** Size of the buttons */
+    size?: DropdownButtonSize;
+    /** Type of the left button */
+    type?: DropdownButtonType;
+    /** Click handler for the left button */
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+    /** Danger styling */
+    danger?: boolean;
+    /** Loading state */
+    loading?: boolean;
+    /** Content of the left button */
+    children?: ReactNode;
+}

package/dist/components/empty/Empty.d.ts

@@ -0,0 +1,12 @@
+import { EmptyProps } from './types';
+import * as React from "react";
+declare const InternalEmpty: React.ForwardRefExoticComponent<EmptyProps & React.RefAttributes<HTMLDivElement>>;
+declare const PRESENTED_IMAGE_DEFAULT: React.FC<{
+    className?: string;
+    style?: React.CSSProperties;
+}>;
+declare const PRESENTED_IMAGE_SIMPLE: React.FC<{
+    className?: string;
+    style?: React.CSSProperties;
+}>;
+export { InternalEmpty, PRESENTED_IMAGE_DEFAULT, PRESENTED_IMAGE_SIMPLE };

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

@@ -0,0 +1,8 @@
+import { InternalEmpty, PRESENTED_IMAGE_DEFAULT, PRESENTED_IMAGE_SIMPLE } from './Empty';
+type EmptyComponent = typeof InternalEmpty & {
+    PRESENTED_IMAGE_DEFAULT: typeof PRESENTED_IMAGE_DEFAULT;
+    PRESENTED_IMAGE_SIMPLE: typeof PRESENTED_IMAGE_SIMPLE;
+};
+declare const Empty: EmptyComponent;
+export { Empty };
+export type { EmptyProps } from './types';

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

@@ -0,0 +1,15 @@
+import { ReactNode, CSSProperties } from 'react';
+export interface EmptyProps {
+    /** Custom description text */
+    description?: ReactNode;
+    /** Custom image element or string src */
+    image?: ReactNode;
+    /** Image style */
+    imageStyle?: CSSProperties;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+    /** Action area content (e.g., a button) */
+    children?: ReactNode;
+}

package/dist/components/flex/Flex.d.ts

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

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

@@ -0,0 +1,2 @@
+export { Flex } from './Flex';
+export type { FlexProps, FlexGap } from './types';

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

@@ -0,0 +1,21 @@
+import { ReactNode, HTMLAttributes, ElementType } from 'react';
+export type FlexGap = "small" | "middle" | "large" | number | string;
+export interface FlexProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    /** If true, direction is column */
+    vertical?: boolean;
+    /** CSS flex-wrap value */
+    wrap?: boolean | "wrap" | "nowrap" | "wrap-reverse";
+    /** CSS justify-content value */
+    justify?: "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | "space-evenly" | "start" | "end" | "normal";
+    /** CSS align-items value */
+    align?: "flex-start" | "center" | "flex-end" | "stretch" | "baseline" | "start" | "end" | "normal";
+    /** Gap between items - named size or CSS value */
+    gap?: FlexGap;
+    /** Flex value (flex CSS shorthand) */
+    flex?: string | number;
+    /** Render as a different element type */
+    component?: ElementType;
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}

package/dist/components/float-button/BackTop.d.ts

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

package/dist/components/float-button/FloatButton.d.ts

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

package/dist/components/float-button/FloatButtonGroup.d.ts

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

package/dist/components/float-button/index.d.ts

@@ -0,0 +1,10 @@
+import { InternalFloatButton } from './FloatButton';
+import { FloatButtonGroup } from './FloatButtonGroup';
+import { BackTop } from './BackTop';
+type FloatButtonComponent = typeof InternalFloatButton & {
+    Group: typeof FloatButtonGroup;
+    BackTop: typeof BackTop;
+};
+declare const FloatButton: FloatButtonComponent;
+export { FloatButton };
+export type { FloatButtonProps, FloatButtonGroupProps, BackTopProps, FloatButtonShape, FloatButtonType, FloatButtonGroupTrigger, FloatButtonBadge, } from './types';

package/dist/components/float-button/types.d.ts

@@ -0,0 +1,42 @@
+import { CSSProperties, ReactNode } from 'react';
+export type FloatButtonShape = "circle" | "square";
+export type FloatButtonType = "primary" | "default";
+export type FloatButtonGroupTrigger = "click" | "hover";
+export interface FloatButtonBadge {
+    count?: number;
+    dot?: boolean;
+    color?: string;
+}
+export interface FloatButtonProps {
+    icon?: ReactNode;
+    description?: ReactNode;
+    tooltip?: ReactNode;
+    type?: FloatButtonType;
+    shape?: FloatButtonShape;
+    badge?: FloatButtonBadge;
+    href?: string;
+    target?: string;
+    onClick?: (e: React.MouseEvent) => void;
+    className?: string;
+    style?: CSSProperties;
+}
+export interface FloatButtonGroupProps {
+    shape?: FloatButtonShape;
+    trigger?: FloatButtonGroupTrigger;
+    icon?: ReactNode;
+    closeIcon?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export interface BackTopProps {
+    visibilityHeight?: number;
+    target?: () => HTMLElement;
+    duration?: number;
+    onClick?: (e: React.MouseEvent) => void;
+    icon?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/components/form/Form.d.ts

@@ -0,0 +1,7 @@
+import { FieldValues } from 'react-hook-form';
+import { FormProps } from './types';
+declare function InternalForm<TValues extends FieldValues = FieldValues>(props: FormProps<TValues>): import("react/jsx-runtime").JSX.Element;
+declare namespace InternalForm {
+    var displayName: string;
+}
+export { InternalForm };

package/dist/components/form/FormContext.d.ts

@@ -0,0 +1,3 @@
+import { FormContextValue } from './types';
+export declare const FormContext: import('react').Context<FormContextValue>;
+export declare function useFormContext(): FormContextValue;

package/dist/components/form/FormErrorList.d.ts

@@ -0,0 +1,6 @@
+import { FormErrorListProps } from './types';
+declare function FormErrorList({ errors, className }: FormErrorListProps): import("react/jsx-runtime").JSX.Element | null;
+declare namespace FormErrorList {
+    var displayName: string;
+}
+export { FormErrorList };

package/dist/components/form/FormItem.d.ts

@@ -0,0 +1,7 @@
+import { FieldValues } from 'react-hook-form';
+import { FormItemProps } from './types';
+declare function FormItem<TValues extends FieldValues = FieldValues>(props: FormItemProps<TValues>): import("react/jsx-runtime").JSX.Element;
+declare namespace FormItem {
+    var displayName: string;
+}
+export { FormItem };

package/dist/components/form/FormList.d.ts

@@ -0,0 +1,6 @@
+import { FormListProps } from './types';
+declare function FormList({ name, children, initialValue }: FormListProps): import("react/jsx-runtime").JSX.Element;
+declare namespace FormList {
+    var displayName: string;
+}
+export { FormList };

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

@@ -0,0 +1,16 @@
+import { useWatch } from 'react-hook-form';
+import { InternalForm } from './Form';
+import { FormItem } from './FormItem';
+import { FormList } from './FormList';
+import { FormErrorList } from './FormErrorList';
+import { useForm } from './useForm';
+type FormComponent = typeof InternalForm & {
+    Item: typeof FormItem;
+    List: typeof FormList;
+    ErrorList: typeof FormErrorList;
+    useForm: typeof useForm;
+    useWatch: typeof useWatch;
+};
+declare const Form: FormComponent;
+export { Form };
+export type { FormProps, FormItemProps, FormListProps, FormErrorListProps, FormLayout, FormSize, FormVariant, FormRequiredMark, Rule, UseFormOptions, FormContextValue, FormListField, FormListOperation, } from './types';

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

@@ -0,0 +1,148 @@
+import { ReactNode, HTMLAttributes } from 'react';
+import { UseFormReturn, FieldValues, FieldPath } from 'react-hook-form';
+import { ZodType } from 'zod';
+export interface Rule {
+    /** Mark the field as required */
+    required?: boolean;
+    /** Custom error message shown when the rule fails */
+    message?: string | ReactNode;
+    /** Built-in type validation */
+    type?: "string" | "number" | "email" | "url" | "boolean";
+    /** RegExp pattern the value must match */
+    pattern?: RegExp;
+    /** Minimum value (number) or length (string / array) */
+    min?: number;
+    /** Maximum value (number) or length (string / array) */
+    max?: number;
+    /** Exact length the value must be */
+    len?: number;
+    /** If true, a string composed only of whitespace is considered empty */
+    whitespace?: boolean;
+    /** Custom async validator */
+    validator?: (rule: Rule, value: unknown) => Promise<void>;
+    /** If true, the validation message is shown as a warning instead of an error */
+    warningOnly?: boolean;
+}
+export type FormLayout = "horizontal" | "vertical" | "inline";
+export type FormSize = "small" | "middle" | "large";
+export type FormVariant = "outlined" | "borderless" | "filled" | "underlined";
+export type FormRequiredMark = boolean | "optional";
+export interface FormProps<TValues extends FieldValues = FieldValues> extends Omit<HTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    /** react-hook-form instance returned by Form.useForm */
+    form?: UseFormReturn<TValues>;
+    /** Label / field layout direction */
+    layout?: FormLayout;
+    /** Grid column config for labels (horizontal layout) */
+    labelCol?: {
+        span?: number;
+    };
+    /** Grid column config for controls (horizontal layout) */
+    wrapperCol?: {
+        span?: number;
+    };
+    /** Called with validated values on successful submit */
+    onFinish?: (values: TValues) => void | Promise<void>;
+    /** Called when submit validation fails */
+    onFinishFailed?: (errorInfo: {
+        values: TValues;
+        errorFields: {
+            name: (string | number)[];
+            errors: string[];
+        }[];
+    }) => void;
+    /** Called whenever a field value changes */
+    onValuesChange?: (changedValues: Partial<TValues>, allValues: TValues) => void;
+    /** Default field values (only used when no external form instance) */
+    initialValues?: Partial<TValues>;
+    /** Whether to append colon after labels */
+    colon?: boolean;
+    /** Disable all form controls */
+    disabled?: boolean;
+    /** Size of form controls */
+    size?: FormSize;
+    /** Visual variant for all controls */
+    variant?: FormVariant;
+    /** Show required / optional marks next to labels */
+    requiredMark?: FormRequiredMark;
+    /** Additional CSS class */
+    className?: string;
+    children?: ReactNode;
+}
+export interface FormItemProps<TValues extends FieldValues = FieldValues> {
+    /** Field path in the form values object */
+    name?: FieldPath<TValues>;
+    /** Label displayed beside or above the control */
+    label?: ReactNode;
+    /** Antd-style validation rules */
+    rules?: Rule[];
+    /** Shorthand: mark field as required (adds asterisk to label) */
+    required?: boolean;
+    /** Persistent help text below the control */
+    help?: ReactNode;
+    /** Extra hint text below help / error */
+    extra?: ReactNode;
+    /** Tooltip shown next to the label */
+    tooltip?: ReactNode;
+    /** Override parent form layout for this item */
+    layout?: "horizontal" | "vertical";
+    /** Hide the form item (still registers the field) */
+    hidden?: boolean;
+    /** Render only the control without label / error wrapper */
+    noStyle?: boolean;
+    /** Prop name used for the controlled value (default: "value") */
+    valuePropName?: string;
+    /** Prop name used for the change handler (default: "onChange") */
+    trigger?: string;
+    /** When to run validation */
+    validateTrigger?: string | string[];
+    /** Additional CSS class */
+    className?: string;
+    children?: ReactNode;
+}
+export interface FormListOperation {
+    add: (defaultValue?: unknown, insertIndex?: number) => void;
+    remove: (index: number | number[]) => void;
+    move: (from: number, to: number) => void;
+}
+export interface FormListField {
+    name: number;
+    key: number;
+}
+export interface FormListProps {
+    /** Field array name path */
+    name: string;
+    /** Render function receiving fields and operation helpers */
+    children: (fields: FormListField[], operation: FormListOperation, meta: {
+        errors: ReactNode[];
+    }) => ReactNode;
+    /** Initial value when the list is created */
+    initialValue?: unknown[];
+    /** Validation rules for the entire list */
+    rules?: Rule[];
+}
+export interface FormErrorListProps {
+    /** List of error messages to display */
+    errors?: ReactNode[];
+    /** Additional CSS class */
+    className?: string;
+}
+export interface UseFormOptions<TSchema extends ZodType = ZodType> {
+    /** Zod schema for validation. When provided, zodResolver is used automatically. */
+    schema?: TSchema;
+    /** Default values for the form fields */
+    defaultValues?: Record<string, unknown>;
+}
+export interface FormContextValue {
+    layout: FormLayout;
+    labelCol?: {
+        span?: number;
+    };
+    wrapperCol?: {
+        span?: number;
+    };
+    colon: boolean;
+    disabled: boolean;
+    size: FormSize;
+    variant: FormVariant;
+    requiredMark: FormRequiredMark;
+}

package/dist/components/form/useForm.d.ts

@@ -0,0 +1,21 @@
+import { UseFormReturn, FieldValues } from 'react-hook-form';
+import { ZodType } from 'zod';
+interface UseFormOptions {
+    /** Zod schema for automatic validation via zodResolver */
+    schema?: ZodType;
+    /** Default values for all fields */
+    defaultValues?: Record<string, unknown>;
+}
+/**
+ * Creates and returns a react-hook-form instance wrapped in a single-element
+ * tuple to match the antd `Form.useForm()` API:
+ *
+ * ```ts
+ * const [form] = Form.useForm({ schema });
+ * ```
+ *
+ * When a Zod `schema` is provided the form is automatically configured with
+ * `zodResolver`.  Without a schema, plain react-hook-form validation applies.
+ */
+export declare function useForm<TValues extends FieldValues = FieldValues>(options?: UseFormOptions): [UseFormReturn<TValues>];
+export {};

package/dist/components/grid/Col.d.ts

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

package/dist/components/grid/Row.d.ts

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

package/dist/components/grid/RowContext.d.ts

@@ -0,0 +1,4 @@
+export interface RowContextValue {
+    gutter: [number, number];
+}
+export declare const RowContext: import('react').Context<RowContextValue>;

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

@@ -0,0 +1,3 @@
+export { Row } from './Row';
+export { Col } from './Col';
+export type { RowProps, ColProps, ColSpanType, Breakpoint, Gutter } from './types';

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

@@ -0,0 +1,53 @@
+import { ReactNode, HTMLAttributes } from 'react';
+export type Breakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export type Gutter = number | Partial<Record<Breakpoint, number>>;
+export interface RowProps extends HTMLAttributes<HTMLDivElement> {
+    /** Horizontal and optional vertical gutter spacing in px.
+     *  number | [horizontal, vertical] | responsive object */
+    gutter?: Gutter | [Gutter, Gutter];
+    /** Vertical alignment of columns */
+    align?: "top" | "middle" | "bottom" | "stretch";
+    /** Horizontal justification of columns */
+    justify?: "start" | "end" | "center" | "space-around" | "space-between" | "space-evenly";
+    /** Whether columns should wrap */
+    wrap?: boolean;
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}
+export interface ColSpanType {
+    span?: number;
+    offset?: number;
+    push?: number;
+    pull?: number;
+    order?: number;
+}
+export interface ColProps extends HTMLAttributes<HTMLDivElement> {
+    /** Number of cells to occupy (0-24). 0 means display:none */
+    span?: number;
+    /** Number of cells to offset from left */
+    offset?: number;
+    /** Number of cells to move right */
+    push?: number;
+    /** Number of cells to move left */
+    pull?: number;
+    /** Flex order */
+    order?: number;
+    /** Flex grow/shrink/basis */
+    flex?: string | number;
+    /** <576px responsive config */
+    xs?: number | ColSpanType;
+    /** >=576px responsive config */
+    sm?: number | ColSpanType;
+    /** >=768px responsive config */
+    md?: number | ColSpanType;
+    /** >=992px responsive config */
+    lg?: number | ColSpanType;
+    /** >=1200px responsive config */
+    xl?: number | ColSpanType;
+    /** >=1600px responsive config */
+    xxl?: number | ColSpanType;
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}

package/dist/components/image/Image.d.ts

@@ -0,0 +1,5 @@
+import { ImageProps, PreviewGroupProps } from './types';
+import * as React from "react";
+declare const InternalImage: React.ForwardRefExoticComponent<ImageProps & React.RefAttributes<HTMLDivElement>>;
+declare const PreviewGroup: React.FC<PreviewGroupProps>;
+export { InternalImage, PreviewGroup };

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

@@ -0,0 +1,7 @@
+import { InternalImage, PreviewGroup } from './Image';
+type ImageComponent = typeof InternalImage & {
+    PreviewGroup: typeof PreviewGroup;
+};
+declare const Image: ImageComponent;
+export { Image };
+export type { ImageProps, PreviewGroupProps, PreviewConfig } from './types';

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

@@ -0,0 +1,48 @@
+import { ReactNode, CSSProperties, ImgHTMLAttributes } from 'react';
+export interface PreviewConfig {
+    /** Visible state (controlled) */
+    visible?: boolean;
+    /** Callback when visibility changes */
+    onVisibleChange?: (visible: boolean) => void;
+    /** Source for preview (can differ from the displayed image) */
+    src?: string;
+    /** Mask content */
+    mask?: ReactNode;
+    /** Enable zoom controls */
+    scaleStep?: number;
+    /** Min scale */
+    minScale?: number;
+    /** Max scale */
+    maxScale?: number;
+}
+export interface ImageProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, "placeholder"> {
+    /** Image source */
+    src?: string;
+    /** Alt text */
+    alt?: string;
+    /** Width */
+    width?: number | string;
+    /** Height */
+    height?: number | string;
+    /** Preview config or boolean */
+    preview?: boolean | PreviewConfig;
+    /** Fallback image when loading fails */
+    fallback?: string;
+    /** Placeholder content displayed while loading */
+    placeholder?: ReactNode | boolean;
+    /** Root class name */
+    rootClassName?: string;
+    /** Extra class name */
+    className?: string;
+    /** Style */
+    style?: CSSProperties;
+}
+export interface PreviewGroupProps {
+    /** Preview config for the group */
+    preview?: boolean | PreviewConfig;
+    /** Items to preview */
+    items?: string[];
+    /** Extra class name */
+    className?: string;
+    children?: ReactNode;
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { InternalInput } from './Input';
+import { Password } from './Password';
+import { TextArea } from './TextArea';
+import { Search } from './Search';
+import { OTP } from './OTP';
+type InputComponent = typeof InternalInput & {
+    Password: typeof Password;
+    TextArea: typeof TextArea;
+    Search: typeof Search;
+    OTP: typeof OTP;
+};
+declare const Input: InputComponent;
+export { Input };
+export type { InputProps, InputPasswordProps, InputTextAreaProps, InputSearchProps, InputOTPProps, InputSize, InputStatus, InputVariant, AutoSizeConfig, ShowCountInfo, ShowCountFormatter, } from './types';