@sfperusacdev/sf-ui 0.1.11

package/dist/types/src/components/display/RecordList.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { BadgeVariant } from '../cards/types';
+export type RecordListIconTone = "info" | "warning" | "success" | "neutral";
+export type RecordListItemProps = {
+    id?: string;
+    icon?: ReactNode;
+    iconTone?: RecordListIconTone;
+    title: ReactNode;
+    subtitle?: ReactNode;
+    badge?: {
+        label: string;
+        variant?: BadgeVariant;
+        dot?: boolean;
+    };
+    actions?: ReactNode;
+    className?: string;
+};
+export type RecordListProps = {
+    title?: ReactNode;
+    action?: ReactNode;
+    items: RecordListItemProps[];
+    className?: string;
+    ariaLabel?: string;
+};
+export declare const RecordListItem: ({ icon, iconTone, title, subtitle, badge, actions, className, }: RecordListItemProps) => import("react").JSX.Element;
+export declare const RecordList: ({ title, action, items, className, ariaLabel }: RecordListProps) => import("react").JSX.Element;

package/dist/types/src/components/display/Timeline.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+export type TimelineStatus = "default" | "success" | "warning" | "danger" | "info";
+export type TimelineItem = {
+    id?: string;
+    title: ReactNode;
+    description?: ReactNode;
+    time?: ReactNode;
+    status?: TimelineStatus;
+    icon?: ReactNode;
+};
+export type TimelineProps = {
+    items: TimelineItem[];
+    ariaLabel?: string;
+    emptyMessage?: string;
+    className?: string;
+};
+export declare const Timeline: ({ items, ariaLabel, emptyMessage, className }: TimelineProps) => import("react").JSX.Element;

package/dist/types/src/components/display/index.d.ts

@@ -0,0 +1,16 @@
+export { Avatar, AvatarGroup } from './Avatar';
+export type { AvatarProps, AvatarGroupProps, AvatarSize, AvatarVariant, AvatarShape } from './Avatar';
+export { AuditTimeline } from './AuditTimeline';
+export type { AuditEventType, AuditTimelineItem, AuditTimelineProps } from './AuditTimeline';
+export { RecordList, RecordListItem } from './RecordList';
+export type { RecordListIconTone, RecordListItemProps, RecordListProps } from './RecordList';
+export { LiveChip } from './LiveChip';
+export type { LiveChipProps } from './LiveChip';
+export { LiveStatusBar } from './LiveStatusBar';
+export type { LiveStatusBarProps, LiveStatusMetric } from './LiveStatusBar';
+export { PassengerBoardCard } from './PassengerBoardCard';
+export type { PassengerBoardCardProps } from './PassengerBoardCard';
+export { Timeline } from './Timeline';
+export type { TimelineItem, TimelineProps, TimelineStatus } from './Timeline';
+export { Carousel } from './Carousel';
+export type { CarouselProps } from './Carousel';

package/dist/types/src/components/document-inputs/CurrencyInput.d.ts

@@ -0,0 +1,21 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { CurrencyCode } from './documentUtils';
+type CurrencyInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    placeholder?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    currency?: CurrencyCode;
+    decimals?: number;
+    allowNegative?: boolean;
+    suffix?: string;
+    onChange?: (value: string) => void;
+};
+export declare const CurrencyInput: <TFormValues extends FieldValues>({ form, name, label, info, required, placeholder, readOnly, disabled, small, className, currency, decimals, allowNegative, suffix, onChange, }: CurrencyInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/document-inputs/DniInput.d.ts

@@ -0,0 +1,17 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type DniInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    placeholder?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    validateOnComplete?: boolean;
+    onChange?: (value: string) => void;
+};
+export declare const DniInput: <TFormValues extends FieldValues>({ form, name, label, info, required, placeholder, readOnly, disabled, small, className, validateOnComplete, onChange, }: DniInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/document-inputs/DocumentInputs.fuzz.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/components/document-inputs/OtpInput.d.ts

@@ -0,0 +1,15 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type OtpInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    length?: number;
+    onChange?: (value: string) => void;
+};
+export declare const OtpInput: <TFormValues extends FieldValues>({ form, name, label, info, required, disabled, small, className, length, onChange, }: OtpInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/document-inputs/PhoneInput.d.ts

@@ -0,0 +1,18 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type PhoneInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    placeholder?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    defaultCountry?: string;
+    onChange?: (value: string) => void;
+    onCountryChange?: (countryCode: string) => void;
+};
+export declare const PhoneInput: <TFormValues extends FieldValues>({ form, name, label, info, required, placeholder, readOnly, disabled, small, className, defaultCountry, onChange, onCountryChange, }: PhoneInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/document-inputs/RucInput.d.ts

@@ -0,0 +1,17 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type RucInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    placeholder?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    validateOnComplete?: boolean;
+    onChange?: (value: string) => void;
+};
+export declare const RucInput: <TFormValues extends FieldValues>({ form, name, label, info, required, placeholder, readOnly, disabled, small, className, validateOnComplete, onChange, }: RucInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/document-inputs/documentUtils.d.ts

@@ -0,0 +1,11 @@
+export type CurrencyCode = "PEN" | "USD" | "EUR" | "CLP";
+export type CountryDialCode = {
+    code: string;
+    label: string;
+    prefix: string;
+};
+export declare const CURRENCY_SYMBOLS: Record<CurrencyCode, string>;
+export declare const COUNTRY_DIAL_CODES: CountryDialCode[];
+export declare const sanitizeDigits: (value: string, maxLength?: number) => string;
+export declare const validateRuc: (ruc: string) => string | null;
+export declare const validateDni: (dni: string) => string | null;

package/dist/types/src/components/document-inputs/index.d.ts

@@ -0,0 +1,7 @@
+export { RucInput } from './RucInput';
+export { DniInput } from './DniInput';
+export { PhoneInput } from './PhoneInput';
+export { CurrencyInput } from './CurrencyInput';
+export { OtpInput } from './OtpInput';
+export { CURRENCY_SYMBOLS, COUNTRY_DIAL_CODES, sanitizeDigits, validateRuc, validateDni, } from './documentUtils';
+export type { CurrencyCode, CountryDialCode } from './documentUtils';

package/dist/types/src/components/feedback/AccessDenied.d.ts

@@ -0,0 +1,8 @@
+export type AccessDeniedProps = {
+    title?: string;
+    message?: string;
+    onBack?: () => void;
+    backLabel?: string;
+    className?: string;
+};
+export declare const AccessDenied: ({ title, message, onBack, backLabel, className, }: AccessDeniedProps) => import("react").JSX.Element;

package/dist/types/src/components/feedback/Alert.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+export type AlertVariant = "info" | "success" | "warning" | "danger";
+type AlertProps = {
+    variant?: AlertVariant;
+    title?: string;
+    message: ReactNode;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    icon?: ReactNode;
+    className?: string;
+};
+export declare const Alert: ({ variant, title, message, dismissible, onDismiss, icon, className, }: AlertProps) => import("react").JSX.Element | null;
+export {};

package/dist/types/src/components/feedback/EmptyState.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+type EmptyStateProps = {
+    message?: string;
+    actionLabel?: string;
+    onAction?: () => void;
+    icon?: ReactNode;
+};
+export declare const EmptyState: ({ message, actionLabel, onAction, icon, }: EmptyStateProps) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/feedback/ErrorView.d.ts

@@ -0,0 +1,8 @@
+type ErrorViewProps = {
+    error?: unknown;
+    message?: string;
+    onRetry?: () => void;
+    retryLabel?: string;
+};
+export declare const ErrorView: ({ error, message, onRetry, retryLabel }: ErrorViewProps) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/feedback/LoadingView.d.ts

@@ -0,0 +1,5 @@
+type LoadingViewProps = {
+    message?: string;
+};
+export declare const LoadingView: ({ message }: LoadingViewProps) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/feedback/RetryBlock.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+type RetryBlockProps = {
+    children: ReactNode;
+    isError?: boolean;
+    isLoading?: boolean;
+    error?: Error | null;
+    onRetry?: () => void;
+    className?: string;
+};
+export declare const RetryBlock: ({ children, isError, isLoading, error, onRetry, className, }: RetryBlockProps) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { CSSProperties } from 'react';
+export type SkeletonVariant = "text" | "block" | "circle";
+export type SkeletonProps = {
+    variant?: SkeletonVariant;
+    width?: CSSProperties["width"];
+    height?: CSSProperties["height"];
+    className?: string;
+};
+export declare const Skeleton: ({ variant, width, height, className }: SkeletonProps) => import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+type SpinnerProps = {
+    size?: "xs" | "sm" | "md" | "lg";
+    className?: string;
+};
+export declare const Spinner: ({ size, className }: SpinnerProps) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+export type ToastVariant = "default" | "info" | "success" | "warning" | "danger";
+export type ToastPosition = "top-right" | "top-left" | "bottom-right" | "bottom-left";
+export type ToastAction = {
+    label: string;
+    onClick: () => void;
+};
+export type ToastInput = {
+    id?: string;
+    title?: string;
+    message?: ReactNode;
+    variant?: ToastVariant;
+    duration?: number;
+    action?: ToastAction;
+};
+type ToastContextValue = {
+    toast: (input: ToastInput) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+};
+type ToastProviderProps = {
+    children: ReactNode;
+    position?: ToastPosition;
+};
+export declare const ToastProvider: ({ children, position }: ToastProviderProps) => import("react").JSX.Element;
+export declare const useToast: () => ToastContextValue;
+export {};

package/dist/types/src/components/feedback/index.d.ts

@@ -0,0 +1,13 @@
+export { Alert } from './Alert';
+export type { AlertVariant } from './Alert';
+export { EmptyState } from './EmptyState';
+export { ErrorView } from './ErrorView';
+export { LoadingView } from './LoadingView';
+export { RetryBlock } from './RetryBlock';
+export { Spinner } from './Spinner';
+export { AccessDenied } from './AccessDenied';
+export type { AccessDeniedProps } from './AccessDenied';
+export { Skeleton } from './Skeleton';
+export type { SkeletonProps, SkeletonVariant } from './Skeleton';
+export { ToastProvider, useToast } from './Toast';
+export type { ToastAction, ToastInput, ToastPosition, ToastVariant, } from './Toast';

package/dist/types/src/components/icons/SyncIcon.d.ts

@@ -0,0 +1,4 @@
+export type SyncIconProps = {
+    className?: string;
+};
+export declare const SyncIcon: ({ className }: SyncIconProps) => import("react").JSX.Element;

package/dist/types/src/components/icons/index.d.ts

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

package/dist/types/src/components/inputs/AsyncCardSelect.d.ts

@@ -0,0 +1,17 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { SelectOption } from './SelectOption';
+type AsyncCardSelectProps<TFormValues extends FieldValues, TOption extends SelectOption = SelectOption> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    loadOptions: () => Promise<TOption[]>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    multiple?: boolean;
+    readOnly?: boolean;
+    onChange?: (value: string | string[]) => void;
+    className?: string;
+    loadOnMount?: boolean;
+};
+export declare const AsyncCardSelect: <TFormValues extends FieldValues, TOption extends SelectOption = SelectOption>({ form, name, loadOptions, label, info, required, multiple, readOnly, onChange, className, loadOnMount, }: AsyncCardSelectProps<TFormValues, TOption>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/AsyncSearchSelect.d.ts

@@ -0,0 +1,20 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { SelectOption } from './SelectOption';
+type AsyncSearchSelectProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    loadOptions: () => Promise<SelectOption[]>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    multiple?: boolean;
+    className?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    readOnly?: boolean;
+    small?: boolean;
+    onChange?: (value: string | string[]) => void;
+};
+export declare const AsyncSearchSelect: <TFormValues extends FieldValues>({ form, name, loadOptions, label, info, required, multiple, className, placeholder, searchPlaceholder, emptyMessage, readOnly, small, onChange, }: AsyncSearchSelectProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/AsyncSearchTableSelect.d.ts

@@ -0,0 +1,21 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { ColumnDef } from '@tanstack/react-table';
+import { SelectOption } from './SelectOption';
+type AsyncSearchTableSelectProps<TFormValues extends FieldValues, TOption extends SelectOption = SelectOption> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    loadOptions: () => Promise<TOption[]>;
+    columns?: ColumnDef<TOption, unknown>[];
+    searchKeys?: readonly string[];
+    label?: string;
+    info?: string;
+    required?: boolean;
+    multiple?: boolean;
+    emptyMessage?: string;
+    readOnly?: boolean;
+    pageSize?: number;
+    onChange?: (value: string | string[]) => void;
+    loadOnMount?: boolean;
+};
+export declare const AsyncSearchTableSelect: <TFormValues extends FieldValues, TOption extends SelectOption = SelectOption>({ form, name, loadOptions, columns, searchKeys, label, info, required, multiple, emptyMessage, readOnly, pageSize, onChange, loadOnMount, }: AsyncSearchTableSelectProps<TFormValues, TOption>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/BooleanCheckbox.d.ts

@@ -0,0 +1,14 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type BooleanCheckboxProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    onChange?: (value: boolean) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const BooleanCheckbox: <TFormValues extends FieldValues>({ form, name, label, info, required, readOnly, className, onChange, onRefresh, }: BooleanCheckboxProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/CardSelect.d.ts

@@ -0,0 +1,18 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { SelectOption } from './SelectOption';
+type CardSelectProps<TFormValues extends FieldValues, TOption extends SelectOption = SelectOption> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    options: TOption[];
+    label?: string;
+    info?: string;
+    required?: boolean;
+    multiple?: boolean;
+    readOnly?: boolean;
+    loading?: boolean;
+    onChange?: (value: string | string[]) => void;
+    onRefresh?: () => Promise<void> | void;
+    className?: string;
+};
+export declare const CardSelect: <TFormValues extends FieldValues, TOption extends SelectOption = SelectOption>({ form, name, options, label, info, required, multiple, readOnly, loading, onChange, onRefresh, className, }: CardSelectProps<TFormValues, TOption>) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type CheckboxProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    checkboxLabel?: string;
+    info?: string;
+    required?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+    className?: string;
+    onChange?: (value: boolean) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const Checkbox: <TFormValues extends FieldValues>({ form, name, label, checkboxLabel, info, required, readOnly, disabled, className, onChange, onRefresh, }: CheckboxProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/CheckboxGroup.d.ts

@@ -0,0 +1,18 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { SelectOption } from './SelectOption';
+type CheckboxGroupProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    options: SelectOption[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    onChange?: (values: string[]) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const CheckboxGroup: <TFormValues extends FieldValues>({ form, name, label, info, required, options, readOnly, disabled, small, className, onChange, onRefresh, }: CheckboxGroupProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/DateInput.d.ts

@@ -0,0 +1,20 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type DateInputKind = "date" | "time" | "datetime-local" | "month";
+type DateInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    kind?: DateInputKind;
+    min?: string;
+    max?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    onChange?: (value: string) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const DateInput: <TFormValues extends FieldValues>({ form, name, label, info, required, kind, min, max, readOnly, disabled, small, className, onChange, onRefresh, }: DateInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,19 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type DatePickerProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    className?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    min?: string;
+    max?: string;
+    onChange?: (value: string) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const DatePicker: <TFormValues extends FieldValues>({ form, name, label, info, required, className, placeholder, readOnly, disabled, small, min, max, onChange, onRefresh, }: DatePickerProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/DisplayField.d.ts

@@ -0,0 +1,15 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type DisplayFieldProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    format?: (value: unknown) => string;
+    emptyText?: string;
+    small?: boolean;
+    className?: string;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const DisplayField: <TFormValues extends FieldValues>({ form, name, label, info, required, format, emptyText, small, className, onRefresh, }: DisplayFieldProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/FieldLayout.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+type FieldLayoutProps = {
+    id: string;
+    label?: string;
+    info?: string;
+    error?: string;
+    required?: boolean;
+    onRefresh?: () => Promise<void> | void;
+    loading?: boolean;
+    children: React.ReactNode;
+};
+export declare const FieldLayout: ({ id, label, info, error, required, onRefresh, loading, children, }: FieldLayoutProps) => React.JSX.Element;
+export {};

package/dist/types/src/components/inputs/FileInput.d.ts

@@ -0,0 +1,21 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type FileInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    accept?: string;
+    multiple?: boolean;
+    maxSizeMb?: number;
+    maxFiles?: number;
+    buttonLabel?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    onChange?: (files: File[]) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const FileInput: <TFormValues extends FieldValues>({ form, name, label, info, required, accept, multiple, maxSizeMb, maxFiles, buttonLabel, readOnly, disabled, small, className, onChange, onRefresh, }: FileInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/FileInput.security.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/components/inputs/Input.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { IconType } from 'react-icons';
+type InputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    type?: React.HTMLInputTypeAttribute;
+    className?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    onChange?: (value: string) => void;
+    icon?: IconType;
+    small?: boolean;
+    onIconClick?: () => Promise<void> | void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const Input: <TFormValues extends FieldValues>({ form, name, label, info, required, type, className, placeholder, readOnly, onChange, icon, small, onIconClick, onRefresh, }: InputProps<TFormValues>) => React.JSX.Element;
+export {};

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

@@ -0,0 +1,21 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type NumberInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    placeholder?: string;
+    readOnly?: boolean;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    suffix?: string;
+    small?: boolean;
+    className?: string;
+    onChange?: (value: string) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const NumberInput: <TFormValues extends FieldValues>({ form, name, label, info, required, placeholder, readOnly, disabled, min, max, step, suffix, small, className, onChange, onRefresh, }: NumberInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/PasswordInput.d.ts

@@ -0,0 +1,17 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+type PasswordInputProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    className?: string;
+    placeholder?: string;
+    readOnly?: boolean;
+    small?: boolean;
+    showStrength?: boolean;
+    onChange?: (value: string) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const PasswordInput: <TFormValues extends FieldValues>({ form, name, label, info, required, className, placeholder, readOnly, small, showStrength, onChange, onRefresh, }: PasswordInputProps<TFormValues>) => import("react").JSX.Element;
+export {};

package/dist/types/src/components/inputs/RadioGroup.d.ts

@@ -0,0 +1,18 @@
+import { FieldValues, Path, UseFormReturn } from 'react-hook-form';
+import { SelectOption } from './SelectOption';
+type RadioGroupProps<TFormValues extends FieldValues> = {
+    form: UseFormReturn<TFormValues>;
+    name: Path<TFormValues>;
+    label?: string;
+    info?: string;
+    required?: boolean;
+    options: SelectOption[];
+    readOnly?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    className?: string;
+    onChange?: (value: string) => void;
+    onRefresh?: () => Promise<void> | void;
+};
+export declare const RadioGroup: <TFormValues extends FieldValues>({ form, name, label, info, required, options, readOnly, disabled, small, className, onChange, onRefresh, }: RadioGroupProps<TFormValues>) => import("react").JSX.Element;
+export {};