react-18-ui-library 0.1.0

package/dist/components/feedback/ErrorBoundary/ErrorBoundary.d.ts

@@ -0,0 +1,18 @@
+import React, { Component, type ErrorInfo, type ReactNode } from 'react';
+export interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);
+    onError?: (error: Error, errorInfo: ErrorInfo) => void;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+}
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    reset: () => void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};

package/dist/components/feedback/ErrorBoundary/index.d.ts

@@ -0,0 +1,2 @@
+export { ErrorBoundary } from './ErrorBoundary';
+export type { ErrorBoundaryProps } from './ErrorBoundary';

package/dist/components/feedback/FullScreenLoader/FullScreenLoader.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+export interface FullScreenLoaderState {
+    visible: boolean;
+    text?: string;
+    icon?: React.ReactNode;
+    blur?: boolean;
+}
+export interface FullScreenLoaderControls {
+    show: (options?: Partial<Omit<FullScreenLoaderState, 'visible'>>) => void;
+    hide: () => void;
+    update: (options: Partial<Omit<FullScreenLoaderState, 'visible'>>) => void;
+}
+export interface FullScreenLoaderProviderProps {
+    children: React.ReactNode;
+    defaultText?: string;
+    defaultBlur?: boolean;
+}
+export declare function FullScreenLoaderProvider({ children, defaultText, defaultBlur, }: FullScreenLoaderProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useFullScreenLoader(): FullScreenLoaderControls;
+export interface FullScreenLoaderProps {
+    visible?: boolean;
+    text?: string;
+    icon?: React.ReactNode;
+    blur?: boolean;
+    className?: string;
+}
+export declare function FullScreenLoader({ visible, text, icon, blur, className, }: FullScreenLoaderProps): React.ReactPortal | null;

package/dist/components/feedback/ProgressBar/ProgressBar.d.ts

@@ -0,0 +1,15 @@
+export type ProgressVariant = 'primary' | 'success' | 'error' | 'warning' | 'info';
+export type ProgressSize = 'xs' | 'sm' | 'md' | 'lg';
+export interface ProgressBarProps {
+    value?: number;
+    max?: number;
+    variant?: ProgressVariant;
+    size?: ProgressSize;
+    label?: string;
+    showValue?: boolean;
+    striped?: boolean;
+    animated?: boolean;
+    indeterminate?: boolean;
+    className?: string;
+}
+export declare function ProgressBar({ value, max, variant, size, label, showValue, striped, animated, indeterminate, className, }: ProgressBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/feedback/ProgressBar/index.d.ts

@@ -0,0 +1,2 @@
+export { ProgressBar } from './ProgressBar';
+export type { ProgressBarProps, ProgressVariant, ProgressSize } from './ProgressBar';

package/dist/components/feedback/Skeleton/Skeleton.d.ts

@@ -0,0 +1,16 @@
+export type SkeletonVariant = 'text' | 'rect' | 'circle';
+export interface SkeletonProps {
+    variant?: SkeletonVariant;
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+    className?: string;
+    animated?: boolean;
+}
+export declare function Skeleton({ variant, width, height, lines, className, animated, }: SkeletonProps): import("react/jsx-runtime").JSX.Element;
+export interface SkeletonCardProps {
+    showAvatar?: boolean;
+    lines?: number;
+    className?: string;
+}
+export declare function SkeletonCard({ showAvatar, lines, className }: SkeletonCardProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/feedback/Skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { Skeleton, SkeletonCard } from './Skeleton';
+export type { SkeletonProps, SkeletonCardProps, SkeletonVariant } from './Skeleton';

package/dist/components/feedback/Spinner/Spinner.d.ts

@@ -0,0 +1,9 @@
+export type SpinnerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface SpinnerProps {
+    size?: SpinnerSize;
+    color?: 'primary' | 'secondary' | 'white' | 'current';
+    label?: string;
+    overlay?: boolean;
+    className?: string;
+}
+export declare function Spinner({ size, color, label, overlay, className }: SpinnerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/feedback/Spinner/index.d.ts

@@ -0,0 +1,2 @@
+export { Spinner } from './Spinner';
+export type { SpinnerProps, SpinnerSize } from './Spinner';

package/dist/components/feedback/Toast/Toast.d.ts

@@ -0,0 +1,7 @@
+import { type Toast as ToastData, type ToastPosition } from '../../../hooks/useToast';
+export interface ToastProviderProps {
+    toasts: ToastData[];
+    onDismiss: (id: string) => void;
+    position?: ToastPosition;
+}
+export declare function ToastProvider({ toasts, onDismiss, position }: ToastProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/feedback/Toast/index.d.ts

@@ -0,0 +1,2 @@
+export { ToastProvider } from './Toast';
+export type { ToastProviderProps } from './Toast';

package/dist/components/forms/FileUpload/FileUpload.d.ts

@@ -0,0 +1,24 @@
+import { type Accept } from 'react-dropzone';
+export interface UploadedFile {
+    file: File;
+    id: string;
+    preview?: string;
+    progress?: number;
+    error?: string;
+}
+export interface FileUploadProps {
+    accept?: Accept;
+    maxFiles?: number;
+    maxSize?: number;
+    multiple?: boolean;
+    disabled?: boolean;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    files?: UploadedFile[];
+    onFilesChange?: (files: UploadedFile[]) => void;
+    onFileRemove?: (id: string) => void;
+    showPreview?: boolean;
+    className?: string;
+}
+export declare function FileUpload({ accept, maxFiles, maxSize, multiple, disabled, label, helperText, error, files, onFilesChange, onFileRemove, showPreview, className, }: FileUploadProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/forms/FileUpload/index.d.ts

@@ -0,0 +1,2 @@
+export { FileUpload } from './FileUpload';
+export type { FileUploadProps, UploadedFile } from './FileUpload';

package/dist/components/forms/FormField/FormField.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface FormFieldProps {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    required?: boolean;
+    disabled?: boolean;
+    htmlFor?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function FormField({ label, helperText, error, required, disabled, htmlFor, children, className, }: FormFieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/forms/FormField/index.d.ts

@@ -0,0 +1,2 @@
+export { FormField } from './FormField';
+export type { FormFieldProps } from './FormField';

package/dist/components/forms/JSONForm/FormValidator.d.ts

@@ -0,0 +1,157 @@
+import type { RegisterOptions } from 'react-hook-form';
+type ValidateFn = (value: unknown) => boolean | string;
+export interface CompiledRules {
+    required?: RegisterOptions['required'];
+    minLength?: RegisterOptions['minLength'];
+    maxLength?: RegisterOptions['maxLength'];
+    min?: RegisterOptions['min'];
+    max?: RegisterOptions['max'];
+    pattern?: RegisterOptions['pattern'];
+    validate?: Record<string, ValidateFn>;
+}
+declare abstract class BaseValidator<T extends BaseValidator<T>> {
+    protected _required: string | false;
+    protected _validates: Record<string, ValidateFn>;
+    required(message?: string): T;
+    custom(name: string, fn: ValidateFn, message?: string): T;
+    abstract compile(): CompiledRules;
+}
+export declare class StringValidator extends BaseValidator<StringValidator> {
+    private _minLength?;
+    private _maxLength?;
+    private _pattern?;
+    private _mustBeString;
+    mustBe(_type: 'string'): StringValidator;
+    minLength(len: number, message?: string): StringValidator;
+    maxLength(len: number, message?: string): StringValidator;
+    lengthBetween(min: number, max: number, message?: string): StringValidator;
+    length(exact: number, message?: string): StringValidator;
+    shouldMatch(pattern: RegExp, message?: string): StringValidator;
+    shouldBeIn(list: string[], message?: string): StringValidator;
+    notEmpty(message?: string): StringValidator;
+    noSpaces(message?: string): StringValidator;
+    alphanumeric(message?: string): StringValidator;
+    startsWith(prefix: string, message?: string): StringValidator;
+    endsWith(suffix: string, message?: string): StringValidator;
+    compile(): CompiledRules;
+}
+export declare class NumberValidator extends BaseValidator<NumberValidator> {
+    private _min?;
+    private _max?;
+    private _maxLength?;
+    private _mustBeNumber;
+    mustBe(_type: 'number'): NumberValidator;
+    min(value: number, message?: string): NumberValidator;
+    max(value: number, message?: string): NumberValidator;
+    between(min: number, max: number, message?: string): NumberValidator;
+    length(digits: number, message?: string): NumberValidator;
+    positive(message?: string): NumberValidator;
+    integer(message?: string): NumberValidator;
+    nonZero(message?: string): NumberValidator;
+    negative(message?: string): NumberValidator;
+    multipleOf(factor: number, message?: string): NumberValidator;
+    compile(): CompiledRules;
+}
+export declare class EmailValidator extends BaseValidator<EmailValidator> {
+    private static EMAIL_RE;
+    mustBe(_type: 'string'): EmailValidator;
+    shouldMatch(pattern: RegExp, message?: string): EmailValidator;
+    domain(allowedDomains: string[], message?: string): EmailValidator;
+    blockedDomains(blocked: string[], message?: string): EmailValidator;
+    compile(): CompiledRules;
+}
+export declare class UrlValidator extends BaseValidator<UrlValidator> {
+    private static URL_RE;
+    mustBe(_type: 'string'): UrlValidator;
+    httpsOnly(message?: string): UrlValidator;
+    allowedDomains(domains: string[], message?: string): UrlValidator;
+    noTrailingSlash(message?: string): UrlValidator;
+    compile(): CompiledRules;
+}
+export declare class TelValidator extends BaseValidator<TelValidator> {
+    length(digits: number, message?: string): TelValidator;
+    minLength(digits: number, message?: string): TelValidator;
+    maxLength(digits: number, message?: string): TelValidator;
+    shouldMatch(pattern: RegExp, message?: string): TelValidator;
+    compile(): CompiledRules;
+}
+export declare class BooleanValidator extends BaseValidator<BooleanValidator> {
+    mustBeTrue(message?: string): BooleanValidator;
+    compile(): CompiledRules;
+}
+export declare class ArrayValidator extends BaseValidator<ArrayValidator> {
+    private _min?;
+    private _max?;
+    minItems(count: number, message?: string): ArrayValidator;
+    maxItems(count: number, message?: string): ArrayValidator;
+    exactItems(count: number, message?: string): ArrayValidator;
+    noEmpty(message?: string): ArrayValidator;
+    shouldBeIn(list: string[], message?: string): ArrayValidator;
+    compile(): CompiledRules;
+}
+export declare class PasswordValidator extends BaseValidator<PasswordValidator> {
+    private _minLength?;
+    private _maxLength?;
+    minLength(len: number, message?: string): PasswordValidator;
+    maxLength(len: number, message?: string): PasswordValidator;
+    hasUppercase(message?: string): PasswordValidator;
+    hasLowercase(message?: string): PasswordValidator;
+    hasDigit(message?: string): PasswordValidator;
+    hasSpecialChar(message?: string): PasswordValidator;
+    noSpaces(message?: string): PasswordValidator;
+    /** Confirm this field matches another field value — pass a getter for the other field */
+    confirmMatch(getOtherValue: () => unknown, message?: string): PasswordValidator;
+    /** Shorthand: minLength(8) + uppercase + lowercase + digit + special char */
+    strong(message?: string): PasswordValidator;
+    compile(): CompiledRules;
+}
+export declare class DateValidator extends BaseValidator<DateValidator> {
+    private _toDate;
+    validDate(message?: string): DateValidator;
+    minDate(date: Date, message?: string): DateValidator;
+    maxDate(date: Date, message?: string): DateValidator;
+    notInPast(message?: string): DateValidator;
+    notInFuture(message?: string): DateValidator;
+    between(minDate: Date, maxDate: Date, message?: string): DateValidator;
+    compile(): CompiledRules;
+}
+export declare class SelectValidator extends BaseValidator<SelectValidator> {
+    shouldBeIn(list: string[], message?: string): SelectValidator;
+    notEmpty(message?: string): SelectValidator;
+    compile(): CompiledRules;
+}
+export declare class FileValidator extends BaseValidator<FileValidator> {
+    /** Max file size in bytes */
+    maxSize(bytes: number, message?: string): FileValidator;
+    allowedTypes(mimeTypes: string[], message?: string): FileValidator;
+    allowedExtensions(exts: string[], message?: string): FileValidator;
+    maxFiles(count: number, message?: string): FileValidator;
+    minFiles(count: number, message?: string): FileValidator;
+    compile(): CompiledRules;
+}
+export declare const v: {
+    /** text, textarea fields — lengthBetween, shouldMatch, shouldBeIn, noSpaces, alphanumeric */
+    string: () => StringValidator;
+    /** number fields — between, integer, multipleOf, nonZero, length */
+    number: () => NumberValidator;
+    /** password fields — strong(), hasUppercase, hasDigit, hasSpecialChar, confirmMatch */
+    password: () => PasswordValidator;
+    /** email fields — auto email regex, domain whitelist/blacklist */
+    email: () => EmailValidator;
+    /** url fields — httpsOnly, allowedDomains, noTrailingSlash */
+    url: () => UrlValidator;
+    /** tel/phone fields — length, minLength, maxLength, shouldMatch */
+    tel: () => TelValidator;
+    /** DatePicker fields — minDate, maxDate, notInPast, notInFuture */
+    date: () => DateValidator;
+    /** select/radio fields — shouldBeIn, notEmpty */
+    select: () => SelectValidator;
+    /** checkbox/switch fields — mustBeTrue */
+    boolean: () => BooleanValidator;
+    /** multiselect/chipselect/taginput — minItems, maxItems, exactItems, shouldBeIn, noEmpty */
+    array: () => ArrayValidator;
+    /** FileUpload fields — maxSize, allowedTypes, allowedExtensions, maxFiles, minFiles */
+    file: () => FileValidator;
+};
+export type AnyValidator = StringValidator | NumberValidator | PasswordValidator | EmailValidator | UrlValidator | TelValidator | DateValidator | SelectValidator | BooleanValidator | ArrayValidator | FileValidator;
+export {};

package/dist/components/forms/JSONForm/JSONForm.d.ts

@@ -0,0 +1,53 @@
+import React from 'react';
+import { type SubmitHandler } from 'react-hook-form';
+import type { AnyValidator } from './FormValidator';
+export type JSONFieldType = 'text' | 'email' | 'password' | 'number' | 'url' | 'tel' | 'textarea' | 'select' | 'multiselect' | 'searchselect' | 'multisearchselect' | 'chipselect' | 'taginput' | 'checkbox' | 'switch' | 'radio' | 'hidden';
+export interface JSONFormOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export interface JSONFormField {
+    name: string;
+    type: JSONFieldType;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    required?: boolean;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    options?: JSONFormOption[];
+    prefixIcon?: React.ReactNode;
+    prefixImage?: string;
+    prefixText?: string;
+    suffixIcon?: React.ReactNode;
+    suffixImage?: string;
+    suffixText?: string;
+    validation?: {
+        min?: number;
+        max?: number;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: RegExp;
+        validate?: (value: unknown) => boolean | string;
+    };
+    /** Fluent validator built with v.string(), v.number(), v.email() etc. Takes precedence over validation object */
+    validator?: AnyValidator;
+    colSpan?: 1 | 2 | 3;
+    rows?: number;
+    autoResize?: boolean;
+    showCharCount?: boolean;
+}
+export interface JSONFormProps {
+    schema: JSONFormField[];
+    defaultValues?: Record<string, unknown>;
+    onSubmit: SubmitHandler<Record<string, unknown>>;
+    onCancel?: () => void;
+    submitLabel?: string;
+    cancelLabel?: string;
+    loading?: boolean;
+    columns?: 1 | 2 | 3;
+    className?: string;
+    actionsClassName?: string;
+}
+export declare function JSONForm({ schema, defaultValues, onSubmit, onCancel, submitLabel, cancelLabel, loading, columns, className, actionsClassName, }: JSONFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/forms/JSONForm/index.d.ts

@@ -0,0 +1,4 @@
+export { JSONForm } from './JSONForm';
+export type { JSONFormProps, JSONFormField, JSONFormOption, JSONFieldType } from './JSONForm';
+export { v } from './FormValidator';
+export type { AnyValidator, StringValidator, NumberValidator, PasswordValidator, EmailValidator, UrlValidator, TelValidator, DateValidator, SelectValidator, BooleanValidator, ArrayValidator, FileValidator, CompiledRules, } from './FormValidator';

package/dist/components/inputs/Button/Button.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "success" | "primary" | "secondary" | "outline" | "ghost" | "danger" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    loading?: boolean;
+    leftIcon?: React.ReactNode;
+    rightIcon?: React.ReactNode;
+    asChild?: boolean;
+}
+export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { buttonVariants };

package/dist/components/inputs/Button/index.d.ts

@@ -0,0 +1,2 @@
+export { Button, buttonVariants } from './Button';
+export type { ButtonProps } from './Button';

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

@@ -0,0 +1,14 @@
+export interface CheckboxProps {
+    label?: string;
+    description?: string;
+    checked?: boolean | 'indeterminate';
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+    disabled?: boolean;
+    required?: boolean;
+    error?: string;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    id?: string;
+}
+export declare function Checkbox({ label, description, checked, defaultChecked, onCheckedChange, disabled, required, error, size, className, id: externalId, }: CheckboxProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/inputs/Checkbox/index.d.ts

@@ -0,0 +1,2 @@
+export { Checkbox } from './Checkbox';
+export type { CheckboxProps } from './Checkbox';

package/dist/components/inputs/ChipSelect/ChipSelect.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export interface ChipSelectOption {
+    value: string;
+    label: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+export type ChipSelectSize = 'sm' | 'md' | 'lg';
+export interface ChipSelectProps {
+    options: ChipSelectOption[];
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    multiple?: boolean;
+    maxSelect?: number;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    size?: ChipSelectSize;
+    className?: string;
+    fullWidth?: boolean;
+}
+export declare function ChipSelect({ options, value, onChange, multiple, maxSelect, label, helperText, error, disabled, required, size, className, fullWidth, }: ChipSelectProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/inputs/DatePicker/DatePicker.d.ts

@@ -0,0 +1,39 @@
+import { DateRange } from 'react-day-picker';
+export type DatePickerMode = 'single' | 'range';
+export type DatePickerSize = 'sm' | 'md' | 'lg';
+export interface DatePickerSingleProps {
+    mode?: 'single';
+    value?: Date;
+    defaultValue?: Date;
+    onChange?: (date: Date | undefined) => void;
+}
+export interface DatePickerRangeProps {
+    mode: 'range';
+    value?: DateRange;
+    defaultValue?: DateRange;
+    onChange?: (range: DateRange | undefined) => void;
+}
+type DatePickerBaseProps = {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    placeholder?: string;
+    dateFormat?: string;
+    disabled?: boolean;
+    required?: boolean;
+    clearable?: boolean;
+    size?: DatePickerSize;
+    fullWidth?: boolean;
+    minDate?: Date;
+    maxDate?: Date;
+    disabledDates?: Date[];
+    /** How many years before current year to show in the year dropdown (default: 10) */
+    yearRangeBefore?: number;
+    /** How many years after current year to show in the year dropdown (default: 5) */
+    yearRangeAfter?: number;
+    className?: string;
+    containerClassName?: string;
+};
+export type DatePickerProps = DatePickerBaseProps & (DatePickerSingleProps | DatePickerRangeProps);
+export declare function DatePicker(props: DatePickerProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/inputs/DatePicker/index.d.ts

@@ -0,0 +1,2 @@
+export { DatePicker } from './DatePicker';
+export type { DatePickerProps, DatePickerMode, DatePickerSize, DatePickerSingleProps, DatePickerRangeProps } from './DatePicker';

package/dist/components/inputs/IconButton/IconButton.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const iconButtonVariants: (props?: ({
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "danger" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    rounded?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface IconButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof iconButtonVariants> {
+    icon: React.ReactNode;
+    loading?: boolean;
+    'aria-label': string;
+}
+export declare const IconButton: React.ForwardRefExoticComponent<IconButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/inputs/IconButton/index.d.ts

@@ -0,0 +1,2 @@
+export { IconButton } from './IconButton';
+export type { IconButtonProps } from './IconButton';

package/dist/components/inputs/MultiSelect/MultiSelect.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+export interface MultiSelectOption {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+export interface MultiSelectGroup {
+    label: string;
+    options: MultiSelectOption[];
+}
+export interface MultiSelectProps {
+    options?: MultiSelectOption[];
+    groups?: MultiSelectGroup[];
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    maxSelected?: number;
+    maxDisplayed?: number;
+    size?: 'sm' | 'md' | 'lg';
+    fullWidth?: boolean;
+    className?: string;
+    containerClassName?: string;
+}
+export declare function MultiSelect({ options, groups, value: controlledValue, defaultValue, onChange, placeholder, searchPlaceholder, label, helperText, error, disabled, required, searchable, clearable, maxSelected, maxDisplayed, size, fullWidth, className, containerClassName, }: MultiSelectProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/inputs/MultiSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { MultiSelect } from './MultiSelect';
+export type { MultiSelectProps, MultiSelectOption, MultiSelectGroup } from './MultiSelect';

package/dist/components/inputs/NumberInput/NumberInput.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+export type NumberInputSize = 'sm' | 'md' | 'lg';
+export interface NumberInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'value' | 'onChange' | 'type'> {
+    value?: number;
+    defaultValue?: number;
+    onChange?: (value: number | undefined) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    precision?: number;
+    prefix?: string;
+    suffix?: string;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    size?: NumberInputSize;
+    fullWidth?: boolean;
+    hideControls?: boolean;
+    showMaxLength?: boolean;
+    formatValue?: (value: number) => string;
+    containerClassName?: string;
+}
+export declare const NumberInput: React.ForwardRefExoticComponent<NumberInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/inputs/NumberInput/index.d.ts

@@ -0,0 +1,2 @@
+export { NumberInput } from './NumberInput';
+export type { NumberInputProps, NumberInputSize } from './NumberInput';

package/dist/components/inputs/OTPInput/OTPInput.d.ts

@@ -0,0 +1,18 @@
+export type OTPInputSize = 'sm' | 'md' | 'lg';
+export interface OTPInputProps {
+    length?: number;
+    value?: string;
+    onChange?: (value: string) => void;
+    onComplete?: (value: string) => void;
+    size?: OTPInputSize;
+    mask?: boolean;
+    disabled?: boolean;
+    error?: string;
+    label?: string;
+    helperText?: string;
+    separator?: boolean;
+    separatorAt?: number[];
+    autoFocus?: boolean;
+    className?: string;
+}
+export declare function OTPInput({ length, value: controlledValue, onChange, onComplete, size, mask, disabled, error, label, helperText, separator, separatorAt, autoFocus, className, }: OTPInputProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/inputs/OTPInput/index.d.ts

@@ -0,0 +1,2 @@
+export { OTPInput } from './OTPInput';
+export type { OTPInputProps, OTPInputSize } from './OTPInput';

package/dist/components/inputs/PhoneInput/PhoneInput.d.ts

@@ -0,0 +1,35 @@
+import React from 'react';
+export interface CountryCode {
+    code: string;
+    dialCode: string;
+    flag: string;
+    name: string;
+}
+export declare const DEFAULT_COUNTRY_CODES: CountryCode[];
+export type PhoneInputSize = 'sm' | 'md' | 'lg';
+export interface PhoneInputValue {
+    countryCode: CountryCode;
+    number: string;
+    /** Full value e.g. "+91 9876543210" */
+    full: string;
+}
+export interface PhoneInputProps {
+    value?: PhoneInputValue;
+    defaultCountry?: string;
+    onChange?: (value: PhoneInputValue) => void;
+    label?: string;
+    helperText?: string;
+    error?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    size?: PhoneInputSize;
+    fullWidth?: boolean;
+    maxLength?: number;
+    showMaxLength?: boolean;
+    countryCodes?: CountryCode[];
+    className?: string;
+    containerClassName?: string;
+    id?: string;
+}
+export declare const PhoneInput: React.ForwardRefExoticComponent<PhoneInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/inputs/PhoneInput/index.d.ts

@@ -0,0 +1,2 @@
+export { PhoneInput, DEFAULT_COUNTRY_CODES } from './PhoneInput';
+export type { PhoneInputProps, PhoneInputSize, PhoneInputValue, CountryCode } from './PhoneInput';