@scbt-ecom/ui 0.31.2 → 0.31.4

package/dist/hooks.js

@@ -1,8 +1,8 @@
 import { u as O } from "./useDevice-L83kSsN7.js";
 import * as l from "react";
 import { useState as i, useEffect as b } from "react";
-import { u as f } from "./useDebounce-DyvGYvL9.js";
-import { d as V, a as w, b as C, c as D, e as k } from "./useDebounce-DyvGYvL9.js";
+import { u as f } from "./useDebounce-BNBPHQrJ.js";
+import { d as V, a as w, b as C, c as D, e as k } from "./useDebounce-BNBPHQrJ.js";
 const d = (s = !1) => {
   const [t, o] = l.useState(s);
   return [t, (u) => o((r) => u ?? !r)];

package/dist/shared/ui/formElements/controlled/autocomplete/Autocomplete.d.ts

@@ -1,13 +1,11 @@
 import { Control, FieldValues, Path, UseControllerProps } from 'react-hook-form';
-import { AutocompleteBaseProps } from '../../uncontrolled';
-import { SelectClasses } from '../../uncontrolled/select/Select';
+import { AutocompleteBaseProps } from '../../..';
 export type AutocompleteControlProps<TFieldValues extends FieldValues, T, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<AutocompleteBaseProps<T>, 'classes'> & {
     control: Control<TFieldValues>;
     helperText?: string;
-    classes?: SelectClasses & {
+    classes?: AutocompleteBaseProps<T>['classes'] & {
         container?: string;
         message?: string;
     };
 };
-export declare const InnerComponent: <TFieldValues extends FieldValues, T>({ control, name, defaultValue, disabled, helperText, rules, shouldUnregister, classes, ...props }: AutocompleteControlProps<TFieldValues, T>) => import("react/jsx-runtime").JSX.Element;
-export declare const AutocompleteControl: typeof InnerComponent;
+export declare const AutocompleteControl: <TFieldValues extends FieldValues, T>({ control, name, defaultValue, disabled, helperText, rules, shouldUnregister, classes, ...props }: AutocompleteControlProps<TFieldValues, T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/controlled/checkbox/CheckboxControl.d.ts

@@ -23,6 +23,5 @@ type CheckboxControlProps<TFieldValues extends FieldValues = FieldValues, TName
      */
     helperText?: string;
 };
-declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ control, classes, className, name, rules, shouldUnregister, defaultValue, disabled, children, helperText, ...props }: CheckboxControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
-export declare const CheckboxControl: typeof InnerComponent;
+export declare const CheckboxControl: <TFieldValues extends FieldValues = FieldValues>({ control, classes, className, name, rules, shouldUnregister, defaultValue, disabled, children, helperText, ...props }: CheckboxControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/controlled/dayPickerControl/dayPickerControl.d.ts

@@ -32,6 +32,5 @@ export type DayPickerControlProps<TFieldValues extends FieldValues = FieldValues
      */
     externalHandlers?: ExternalHandlers;
 };
-declare const InnerComponent: <T extends FieldValues = FieldValues>({ control, name, disabled, rules, shouldUnregister, defaultValue, inputProps, helperText, classes, ...props }: DayPickerControlProps<T>) => import("react/jsx-runtime").JSX.Element;
-export declare const DayPickerControl: typeof InnerComponent;
+export declare const DayPickerControl: <T extends FieldValues = FieldValues>({ control, name, disabled, rules, shouldUnregister, defaultValue, inputProps, helperText, classes, ...props }: DayPickerControlProps<T>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/controlled/editor/EditorControl.d.ts

@@ -0,0 +1,16 @@
+import { ReactElement } from 'react';
+import { FieldValues, Path, UseControllerProps } from 'react-hook-form';
+export type EditorControlClasses = {
+    root?: string;
+    editor?: string;
+    wrapper?: string;
+    message?: string;
+    label?: string;
+};
+export type EditorControlProps<TFieldValues extends FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & {
+    editable?: boolean;
+    classes?: EditorControlClasses;
+    helperText?: string | ReactElement;
+    label?: string;
+};
+export declare const EditorControl: <T extends FieldValues>({ control, label, helperText, editable, classes, defaultValue, disabled, rules, shouldUnregister, name, ...props }: EditorControlProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/{editorControl → controlled/editor}/model/helper.d.ts

@@ -1,8 +1,8 @@
 import { Editor } from '@tiptap/react';
-import { TColorOption, THeadingOptions } from './types';
-export declare const headingsOptions: THeadingOptions[];
+import { ColorOption, HeadingOptions } from './types';
+export declare const headingsOptions: HeadingOptions[];
 export declare const editorHeadingClasses: Record<number, string>;
-export declare const editorAllowedColors: TColorOption[];
+export declare const editorAllowedColors: ColorOption[];
 export declare const renderEditorPanel: (editor: Editor) => ({
     label: string;
     icon: import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/{editorControl → controlled/editor}/model/types.d.ts

@@ -1,6 +1,6 @@
 export type THeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
-export interface THeadingOptions {
+export interface HeadingOptions {
     shortcuts: string[];
     level: THeadingLevel;
 }
-export type TColorOption = `#${string}`;
+export type ColorOption = `#${string}`;

package/dist/shared/ui/formElements/{editorControl → controlled/editor}/ui/Editor.d.ts

@@ -1,15 +1,18 @@
+import { ReactElement } from 'react';
 import { FieldError } from 'react-hook-form';
 import { EditorEvents, UseEditorOptions } from '@tiptap/react';
-import { ICommonEditorProps, TEditorControlClasses } from '../EditorControl';
+import { EditorControlClasses } from '../EditorControl';
 type ExternalHandlers = {
     onUpdate?: (editor: EditorEvents['update']) => void;
 };
-interface EditorProps extends ICommonEditorProps, Partial<UseEditorOptions> {
+interface EditorProps extends Partial<UseEditorOptions> {
     onChange: (value: string) => void;
     value: string;
     error?: FieldError;
-    classes?: TEditorControlClasses;
+    classes?: EditorControlClasses;
     externalHandlers?: ExternalHandlers;
+    label?: string;
+    helperText?: string | ReactElement;
 }
 export declare const Editor: import('react').ForwardRefExoticComponent<EditorProps & import('react').RefAttributes<HTMLDivElement>>;
 export {};

package/dist/shared/ui/formElements/controlled/editor/ui/Toolbar.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+interface ToolbarProps {
+    editor: Editor;
+}
+export declare const Toolbar: ({ editor }: ToolbarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/index.d.ts

@@ -1,4 +1,5 @@
 export type { TextareaControlProps } from './textarea';
+export type { InputOtpControlProps } from './inputOtp';
 export declare const Controlled: {
     InputControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, helperText, classes, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('..').InputBaseProps, "classes"> & {
         control: import('react-hook-form').Control<TFieldValues>;
@@ -72,7 +73,6 @@ export declare const Controlled: {
         };
         helperText?: string;
     }) => import("react/jsx-runtime").JSX.Element;
-    ComboboxControl: <T extends import('react-hook-form').FieldValues, ValueType>({ options, control, defaultValue, isClearable, label, disabled, placeholder, helperText, noOptionsMessage, size, classes, isMulti, isSearchable, customChange, ...props }: import('./combobox').IComboboxControlProps<T, ValueType>) => import("react/jsx-runtime").JSX.Element;
     AutocompleteControl: <TFieldValues extends import('react-hook-form').FieldValues, T>({ control, name, defaultValue, disabled, helperText, rules, shouldUnregister, classes, ...props }: import('./autocomplete').AutocompleteControlProps<TFieldValues, T>) => import("react/jsx-runtime").JSX.Element;
     DadataFio: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataCacheOption<unknown>>, "query" | "formatter"> & {
         dadataBaseUrl: string;
@@ -108,4 +108,7 @@ export declare const Controlled: {
             container?: string;
         };
     }) => import("react/jsx-runtime").JSX.Element;
+    InputOtpControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, helperText, ...props }: import('./inputOtp').InputOtpControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+    EditorControl: <T extends import('react-hook-form').FieldValues>({ control, label, helperText, editable, classes, defaultValue, disabled, rules, shouldUnregister, name, ...props }: import('./editor').EditorControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+    InputCurrencyControl: <T extends import('react-hook-form').FieldValues>({ defaultCurrency, label, helperText, control, classes, disabled, name, defaultValue, rules, attachmentProps, shouldUnregister, externalHandlers, ...props }: import('./inputCurrency').InputCurrencyControlProps<T>) => import("react/jsx-runtime").JSX.Element;
 };

package/dist/shared/ui/formElements/controlled/input/InputControl.d.ts

@@ -18,6 +18,5 @@ type InputControlProps<TFieldValues extends FieldValues = FieldValues, TName ext
      */
     classes?: InputControlClasses;
 };
-declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, helperText, classes, ...props }: InputControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
-export declare const InputControl: typeof InnerComponent;
+export declare const InputControl: <TFieldValues extends FieldValues = FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, helperText, classes, ...props }: InputControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/controlled/inputCurrency/InputCurrencyControl.d.ts

@@ -0,0 +1,26 @@
+import { ReactElement } from 'react';
+import { FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { InputBaseProps } from '../../..';
+import * as React from 'react';
+export type TCurrencyVariant = 'euro' | 'dollars' | 'rubles' | 'yuan' | 'dirhams';
+export interface ICurrencyOption {
+    ruName: string;
+    engName: string;
+    currency: TCurrencyVariant;
+}
+type ExternalHandlers = {
+    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+};
+export type InputCurrencyControlProps<TFieldValues extends FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = Omit<InputBaseProps, 'externalHandlers' | 'onChange' | 'value' | 'defaultValue' | 'type'> & UseControllerProps<TFieldValues, TName> & {
+    classes?: any;
+    defaultCurrency?: TCurrencyVariant;
+    disabled?: boolean;
+    label: string;
+    helperText?: string | ReactElement;
+    externalHandlers?: ExternalHandlers;
+};
+export declare const InputCurrencyControl: <T extends FieldValues>({ defaultCurrency, label, helperText, control, classes, disabled, name, defaultValue, rules, attachmentProps, shouldUnregister, externalHandlers, ...props }: InputCurrencyControlProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/inputOtp/InputOtpControl.d.ts

@@ -0,0 +1,12 @@
+import { FieldValues, Path, UseControllerProps } from 'react-hook-form';
+import { InputOtpBaseProps } from '../../..';
+type InputOtpControlClasses = InputOtpBaseProps['classes'] & {
+    message?: string;
+    container?: string;
+};
+export type InputOtpControlProps<TFieldValues extends FieldValues = FieldValues, TName extends Path<TFieldValues> = Path<TFieldValues>> = UseControllerProps<TFieldValues, TName> & Omit<InputOtpBaseProps, 'classes'> & {
+    classes?: InputOtpControlClasses;
+    helperText?: string;
+};
+export declare const InputOtpControl: <TFieldValues extends FieldValues = FieldValues>({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, helperText, ...props }: InputOtpControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/ui/formElements/controlled/inputOtp/index.d.ts

@@ -0,0 +1 @@
+export { InputOtpControl, type InputOtpControlProps } from './InputOtpControl';

package/dist/shared/ui/formElements/controlled/radio/RadioGroupControl.d.ts

@@ -23,6 +23,5 @@ type RadioGroupControlProps<TFieldValues extends FieldValues = FieldValues, TNam
      */
     helperText?: string;
 };
-declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ classes, className, control, name, rules, shouldUnregister, disabled, defaultValue, helperText, label, ...props }: RadioGroupControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
-export declare const RadioGroupControl: typeof InnerComponent;
+export declare const RadioGroupControl: <TFieldValues extends FieldValues = FieldValues>({ classes, className, control, name, rules, shouldUnregister, disabled, defaultValue, helperText, label, ...props }: RadioGroupControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/controlled/select/SelectControl.d.ts

@@ -22,6 +22,5 @@ type SelectControlProps<TFieldValues extends FieldValues = FieldValues, TName ex
      */
     returnValue?: (option: SelectItemOption) => string;
 };
-declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ control, classes, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, helperText, ...props }: SelectControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
-export declare const SelectControl: typeof InnerComponent;
+export declare const SelectControl: <TFieldValues extends FieldValues = FieldValues>({ control, classes, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, helperText, ...props }: SelectControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/controlled/slider/SliderControl.d.ts

@@ -7,6 +7,5 @@ type SliderControlProps<TFieldValues extends FieldValues = FieldValues, TName ex
     control: Control<TFieldValues>;
     classes?: SliderControlClasses;
 };
-export declare const InnerComponent: ({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, ...props }: SliderControlProps) => import("react/jsx-runtime").JSX.Element;
-export declare const SliderControl: typeof InnerComponent;
+export declare const SliderControl: ({ control, name, defaultValue, disabled, rules, shouldUnregister, classes, ...props }: SliderControlProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/controlled/switch/SwitchControl.d.ts

@@ -31,6 +31,5 @@ export type SwitchControlProps<TFieldValues extends FieldValues = FieldValues, T
      */
     popoverProps?: PopoverProps;
 };
-declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ classes, className, control, name, rules, defaultValue, disabled, shouldUnregister, children, helperText, tooltip, popoverProps, ...props }: SwitchControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
-export declare const SwitchControl: typeof InnerComponent;
+export declare const SwitchControl: <TFieldValues extends FieldValues = FieldValues>({ classes, className, control, name, rules, defaultValue, disabled, shouldUnregister, children, helperText, tooltip, popoverProps, ...props }: SwitchControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/controlled/textarea/TextareaControl.d.ts

@@ -18,6 +18,5 @@ export type TextareaControlProps<TFieldValues extends FieldValues = FieldValues,
      */
     helperText?: string;
 };
-declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ classes, control, name, rules, disabled, defaultValue, shouldUnregister, helperText, ...props }: TextareaControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
-export declare const TextareaControl: typeof InnerComponent;
+export declare const TextareaControl: <TFieldValues extends FieldValues = FieldValues>({ classes, control, name, rules, disabled, defaultValue, shouldUnregister, helperText, ...props }: TextareaControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/shared/ui/formElements/index.d.ts

@@ -1,13 +1,2 @@
-export * from './InputControl';
-export * from './inputControlMask';
-export * from './CheckboxControl';
-export * from './SwitchControl';
-export * from './TextareaControl';
-export * from './dadataControl';
-export * from './comboboxControl';
-export * from './editorControl';
-export * from './radioControl';
-export * from './inputCurrencyControl';
-export * from './InputOtpControl';
 export * from './controlled';
 export * from './uncontrolled';

package/dist/shared/ui/formElements/ui/index.d.ts

@@ -1,4 +1,2 @@
-export * from './FieldContainer';
 export * from './fieldAttachment';
-export * from './fieldWrapper';
 export * from './MessageView';

package/dist/shared/ui/formElements/uncontrolled/index.d.ts

@@ -8,6 +8,7 @@ export type { AutocompleteBaseProps } from './autocomplete';
 export type { RadioGroupBaseProps, RadioOption } from './radio';
 export type { TextareaBaseProps } from './textarea';
 export { isSingleOption } from './select';
+export type { InputOtpBaseProps } from './inputOtp';
 export declare const Uncontrolled: {
     InputBase: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "size" | "placeholder"> & {
         classes?: import('./input/Input').InputBaseClasses;
@@ -123,5 +124,16 @@ export declare const Uncontrolled: {
             onBlur?: (event: React.FocusEvent<HTMLTextAreaElement>) => void;
         };
     } & import('react').RefAttributes<HTMLTextAreaElement>>;
+    InputOtpBase: import('react').ForwardRefExoticComponent<Omit<import('input-otp').OTPInputProps, "render"> & {
+        classes?: import('./inputOtp').InputOtpBaseClasses;
+        initialFocus?: boolean;
+        externalHandlers?: {
+            onChange?: (value: string) => void;
+            onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+            onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+            onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+        };
+        invalid?: boolean;
+    } & import('react').RefAttributes<HTMLInputElement>>;
     UploaderBase: import('react').ForwardRefExoticComponent<import('./uploader').UploaderBaseProps & import('react').RefAttributes<HTMLInputElement>>;
 };

package/dist/shared/ui/formElements/uncontrolled/input/Input.d.ts

@@ -4,6 +4,7 @@ export type InputBaseClasses = {
     container?: string;
     input?: string;
     label?: string;
+    renderWrapper?: string;
 };
 type FieldAttachmentProps = React.ComponentPropsWithoutRef<typeof FieldAttachment>;
 type ExternalHandlers = {

package/dist/shared/ui/formElements/uncontrolled/inputOtp/InputOtpBase.d.ts

@@ -0,0 +1,51 @@
+import { OTPInputProps } from 'input-otp';
+import { InputOTPSlotClasses } from './ui';
+export type InputOtpBaseClasses = {
+    input?: string;
+    inputContainer?: string;
+    container?: string;
+    slot?: InputOTPSlotClasses;
+};
+type ExternalHandlers = {
+    onChange?: (value: string) => void;
+    onClick?: (event: React.MouseEvent<HTMLDivElement>) => void;
+    onFocus?: (event: React.FocusEvent<HTMLDivElement>) => void;
+    onBlur?: (event: React.FocusEvent<HTMLDivElement>) => void;
+};
+export type InputOtpBaseProps = Omit<OTPInputProps, 'render'> & {
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: InputOtpBaseClasses;
+    /**
+     * Изначальный автофокус
+     */
+    initialFocus?: boolean;
+    /**
+     * Внешние handlers
+     */
+    externalHandlers?: ExternalHandlers;
+    /**
+     * Для aria-invalid валидное или не валидное поле
+     */
+    invalid?: boolean;
+};
+export declare const InputOtpBase: import('react').ForwardRefExoticComponent<Omit<OTPInputProps, "render"> & {
+    /**
+     * Внешние классы которыми можно поменять стили
+     */
+    classes?: InputOtpBaseClasses;
+    /**
+     * Изначальный автофокус
+     */
+    initialFocus?: boolean;
+    /**
+     * Внешние handlers
+     */
+    externalHandlers?: ExternalHandlers;
+    /**
+     * Для aria-invalid валидное или не валидное поле
+     */
+    invalid?: boolean;
+} & import('react').RefAttributes<HTMLInputElement>>;
+export {};

package/dist/shared/ui/formElements/uncontrolled/inputOtp/index.d.ts

@@ -0,0 +1 @@
+export { type InputOtpBaseClasses, type InputOtpBaseProps, InputOtpBase } from './InputOtpBase';

package/dist/shared/ui/formElements/{InputOtpControl → uncontrolled/inputOtp}/ui/InputOtpSlot.d.ts

@@ -1,5 +1,5 @@
 import { ComponentPropsWithoutRef } from 'react';
-export type TInputOTPSlotClasses = {
+export type InputOTPSlotClasses = {
     singleChar?: string;
     caretWrapper?: string;
     caret?: string;
@@ -7,7 +7,8 @@ export type TInputOTPSlotClasses = {
 };
 interface InputOTPSlotProps extends ComponentPropsWithoutRef<'div'> {
     index: number;
-    classes?: TInputOTPSlotClasses;
+    classes?: InputOTPSlotClasses;
+    invalid?: boolean;
 }
 export declare const InputOTPSlot: import('react').ForwardRefExoticComponent<InputOTPSlotProps & import('react').RefAttributes<HTMLDivElement>>;
 export {};

package/dist/shared/ui/formElements/uncontrolled/inputOtp/ui/index.d.ts

@@ -0,0 +1 @@
+export { InputOTPSlot, type InputOTPSlotClasses } from './InputOtpSlot';

package/dist/shared/ui/formElements/uncontrolled/uploader/UploaderBase.d.ts

@@ -24,7 +24,7 @@ export interface UploaderBaseProps extends Omit<InputHTMLAttributes<HTMLInputEle
      * Сеттер значение
      * @param file - файлы
      */
-    onChange: (file: File[]) => void;
+    onChange?: (file: File[]) => void;
     /**
      * Валидное ли значение
      */
@@ -32,7 +32,7 @@ export interface UploaderBaseProps extends Omit<InputHTMLAttributes<HTMLInputEle
     /**
      * Значение
      */
-    value: File[];
+    value?: File[];
 }
 export declare const UploaderBase: import('react').ForwardRefExoticComponent<UploaderBaseProps & import('react').RefAttributes<HTMLInputElement>>;
 export {};

package/dist/shared/ui/formElements/uncontrolled/uploader/model/hooks/useUploader.d.ts

@@ -1,8 +1,8 @@
 import { DropzoneOptions } from 'react-dropzone';
 export type TUseUploader = {
-    controlledFiles: File[];
+    controlledFiles?: File[];
     dropzoneOptions: DropzoneOptions;
-    onChange: (files: File[]) => void;
+    onChange?: (files: File[]) => void;
 };
 export declare const useUploader: ({ dropzoneOptions, controlledFiles, onChange }: TUseUploader) => {
     filesStatus: Record<string, "error" | "success" | "loading">;

package/dist/shared/ui/formElements/uncontrolled/uploader/ui/UploaderFiles.d.ts

@@ -5,7 +5,7 @@ export type UploaderFilesClasses = {
     file?: UploaderFileClasses;
 };
 interface UploaderFilesProps extends HTMLAttributes<HTMLDivElement> {
-    files: File[];
+    files?: File[];
     filesStatus: {
         [key: string]: 'loading' | 'success' | 'error';
     };