@scbt-ecom/ui 0.22.8 → 0.24.0

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

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

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

@@ -0,0 +1 @@
+export { AutocompleteControl, type AutocompleteControlProps } from './Autocomplete';

package/dist/shared/ui/formElements/controlled/dadata/address/DadataAddress.d.ts

@@ -0,0 +1,11 @@
+import { FieldValues } from 'react-hook-form';
+import { AutocompleteControlProps } from '../../autocomplete';
+import { IDadataCacheOption } from '../types';
+import { SelectItemOption } from '../../../..';
+/**
+ * DADATA_BASE_CACHE_URL - нужно использовать этот url
+ */
+export declare const DadataAddress: <TFieldValues extends FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<AutocompleteControlProps<TFieldValues, IDadataCacheOption<unknown>>, "query" | "formatter"> & {
+    dadataBaseUrl: string;
+    formatter?: (item: IDadataCacheOption<unknown>) => SelectItemOption;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { DadataAddress } from './DadataAddress';

package/dist/shared/ui/formElements/controlled/dadata/address/query.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { IDadataCacheOption } from '../types';
+export declare const useDadataQueryAddress: (query: string, dadataBaseUrl: string, options?: Partial<UseQueryOptions<IDadataCacheOption<unknown>[]>>) => import('@tanstack/react-query').UseQueryResult<IDadataCacheOption<unknown>[], Error>;

package/dist/shared/ui/formElements/controlled/dadata/auto/DadataAuto.d.ts

@@ -0,0 +1,11 @@
+import { FieldValues } from 'react-hook-form';
+import { AutocompleteControlProps } from '../../autocomplete';
+import { IDadataAutoOption } from '../types';
+import { SelectItemOption } from '../../../..';
+/**
+ * DADATA_BASE_CONSTANTS_URL - нужно использовать этот url
+ */
+export declare const DadataAuto: <TFieldValues extends FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<AutocompleteControlProps<TFieldValues, IDadataAutoOption>, "query" | "formatter"> & {
+    dadataBaseUrl: string;
+    formatter?: (item: IDadataAutoOption) => SelectItemOption;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { DadataAuto } from './DadataAuto';

package/dist/shared/ui/formElements/controlled/dadata/auto/query.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { IDadataAutoOption } from '../types';
+export declare const useDadataQueryAuto: (query: string, dadataBaseUrl: string, options?: Partial<UseQueryOptions<IDadataAutoOption[]>>) => import('@tanstack/react-query').UseQueryResult<IDadataAutoOption[], Error>;

package/dist/shared/ui/formElements/controlled/dadata/country/DadataCountry.d.ts

@@ -0,0 +1,11 @@
+import { FieldValues } from 'react-hook-form';
+import { AutocompleteControlProps } from '../../autocomplete';
+import { IDadataCountryOption } from '../types';
+import { SelectItemOption } from '../../../..';
+/**
+ * DADATA_BASE_CONSTANTS_URL - нужно использовать этот url
+ */
+export declare const DadataCountry: <TFieldValues extends FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<AutocompleteControlProps<TFieldValues, IDadataCountryOption>, "query" | "formatter"> & {
+    dadataBaseUrl: string;
+    formatter?: (item: IDadataCountryOption) => SelectItemOption;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { DadataCountry } from './DadataCountry';

package/dist/shared/ui/formElements/controlled/dadata/country/query.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { IDadataCountryOption } from '../types';
+export declare const useDadataQueryCountry: (query: string, dadataBaseUrl: string, options?: Partial<UseQueryOptions<IDadataCountryOption[]>>) => import('@tanstack/react-query').UseQueryResult<IDadataCountryOption[], Error>;

package/dist/shared/ui/formElements/controlled/dadata/fio/DadataFio.d.ts

@@ -0,0 +1,11 @@
+import { FieldValues } from 'react-hook-form';
+import { AutocompleteControlProps } from '../../autocomplete';
+import { IDadataCacheOption } from '../types';
+import { SelectItemOption } from '../../../..';
+/**
+ * DADATA_BASE_CACHE_URL - нужно использовать этот url
+ */
+export declare const DadataFio: <TFieldValues extends FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<AutocompleteControlProps<TFieldValues, IDadataCacheOption<unknown>>, "query" | "formatter"> & {
+    dadataBaseUrl: string;
+    formatter?: (item: IDadataCacheOption<unknown>) => SelectItemOption;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { DadataFio } from './DadataFio';

package/dist/shared/ui/formElements/controlled/dadata/fio/query.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { IDadataCacheOption } from '../types';
+export declare const useDadataQueryFio: (query: string, dadataBaseUrl: string, options?: Partial<UseQueryOptions<IDadataCacheOption<unknown>[]>>) => import('@tanstack/react-query').UseQueryResult<IDadataCacheOption<unknown>[], Error>;

package/dist/shared/ui/formElements/controlled/dadata/helpers.d.ts

@@ -0,0 +1,2 @@
+import { TDadataReturn, TDadataType } from './types';
+export declare const getDataByDadataType: <T>(dadataType: TDadataType, data: TDadataReturn<T>) => import('./types').IDadataCountryOption[] | import('./types').IDadataAutoOption[] | import('./types').IDadataCacheOption<T>[];

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

@@ -0,0 +1,5 @@
+export { DadataOrganization } from './party';
+export { DadataAddress } from './address';
+export { DadataAuto } from './auto';
+export { DadataCountry } from './country';
+export { DadataFio } from './fio';

package/dist/shared/ui/formElements/controlled/dadata/party/DadataOrganization.d.ts

@@ -0,0 +1,11 @@
+import { FieldValues } from 'react-hook-form';
+import { AutocompleteControlProps } from '../../autocomplete';
+import { IDadataOrganizationOption } from '../types';
+import { SelectItemOption } from '../../../..';
+/**
+ * DADATA_BASE_CACHE_URL - нужно использовать этот url
+ */
+export declare const DadataOrganization: <TFieldValues extends FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<AutocompleteControlProps<TFieldValues, IDadataOrganizationOption>, "query" | "formatter"> & {
+    dadataBaseUrl: string;
+    formatter?: (item: IDadataOrganizationOption) => SelectItemOption;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { DadataOrganization } from './DadataOrganization';

package/dist/shared/ui/formElements/controlled/dadata/party/query.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryOptions } from '@tanstack/react-query';
+import { IDadataOrganizationOption } from '../types';
+export declare const useDadataQueryParty: (query: string, dadataBaseUrl: string, options?: Partial<UseQueryOptions<IDadataOrganizationOption[]>>) => import('@tanstack/react-query').UseQueryResult<IDadataOrganizationOption[], Error>;

package/dist/shared/ui/formElements/controlled/dadata/types.d.ts

@@ -0,0 +1,35 @@
+export type TDadataType = 'address' | 'fio' | 'country' | 'auto' | 'party';
+export interface IDadataCountryOption {
+    id: number;
+    country_name: string;
+}
+export interface IDadataConstantsCountrySuggestion {
+    matches: IDadataCountryOption[];
+}
+export interface IDadataAutoOption {
+    id: number;
+    mark: string;
+    model: string;
+    model_mark: string;
+    year_max: string;
+    year_min: string;
+}
+export interface IDadataConstantsAutoSuggestion {
+    matches: IDadataAutoOption[];
+}
+export interface IDadataCacheOption<T> {
+    value: string;
+    unrestricted_value: string;
+    data: T;
+}
+export interface IDadataCacheSuggestion<T> {
+    suggestions: IDadataCacheOption<T>[];
+}
+export interface IDadataOrganizationOption {
+    value: string;
+    unrestricted_value: string;
+    data: {
+        inn: 'string';
+    };
+}
+export type TDadataReturn<T> = IDadataConstantsCountrySuggestion | IDadataCacheSuggestion<T> | IDadataConstantsAutoSuggestion;

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

@@ -37,31 +37,34 @@ export declare const Controlled: {
         };
         helperText?: string;
     }) => import("react/jsx-runtime").JSX.Element;
-    SelectControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, classes, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, helperText, size, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('react-select').Props<import('..').SelectItemOption, boolean>, "options" | "defaultValue" | "placeholder" | "isSearchable"> & Pick<import('..').InputBaseProps, "invalid" | "label" | "attachmentProps"> & {
+    SelectControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ control, classes, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, helperText, size, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('@headlessui/react').ComboboxProps<import('..').SelectItemOption, boolean, "li">, "onChange" | "className" | "multiple" | "by" | "virtual"> & {
+        label: string;
+        isMulti: boolean;
+        invalid?: boolean;
         isSearchable?: boolean;
-        returnValue?: (option: import('..').SelectItemOption) => string;
-        displayValue?: (option: import('..').SelectItemOption) => string;
-        classes?: {
-            container?: string;
-            control?: import('../uncontrolled/select/ui').ControlClasses;
-            option?: import('../uncontrolled/select/ui').SelectItemClasses;
-            list?: import('../uncontrolled/select/ui').SelectListClasses;
-        };
         options: import('..').SelectItemOption[];
-        filterOptionDisabled?: boolean;
+        classes?: import('../uncontrolled/select/Select').SelectClasses;
+        displayValue?: (option: import('..').SelectItemOption) => string;
+        onChange?: ((value: import('..').SelectItemOption | import('..').SelectItemOption[] | undefined) => void) | undefined;
+        onInputChange?: (value: string) => void;
+        inputValue?: string;
+        attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
+        filterDisabled?: boolean;
     } & {
         control: import('react-hook-form').Control<TFieldValues>;
         classes?: {
-            container?: string;
-            control?: import('../uncontrolled/select/ui').ControlClasses;
-            option?: import('../uncontrolled/select/ui').SelectItemClasses;
-            list?: import('../uncontrolled/select/ui').SelectListClasses;
+            item?: string;
+            helperText?: string;
+        } & {
+            root?: string;
+            list?: string;
         } & {
             container?: string;
             message?: string;
         };
         helperText?: string;
         size?: import('../ui').TFieldContainerConfig["size"];
+        returnValue?: (option: import('..').SelectItemOption) => string;
     }) => import("react/jsx-runtime").JSX.Element;
     SwitchControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ classes, className, control, name, rules, defaultValue, disabled, shouldUnregister, children, helperText, tooltip, popoverProps, ...props }: import('./switch/SwitchControl').SwitchControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
     RadioGroupControl: <TFieldValues extends import('react-hook-form').FieldValues = import('react-hook-form').FieldValues>({ classes, className, control, name, rules, shouldUnregister, disabled, defaultValue, helperText, label, ...props }: import('react-hook-form').UseControllerProps<TFieldValues, import('react-hook-form').Path<TFieldValues>> & Omit<import('..').RadioGroupBaseProps, "classes"> & {
@@ -82,4 +85,25 @@ 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, size, 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;
+        formatter?: (item: import('./dadata/types').IDadataCacheOption<unknown>) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataAddress: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataCacheOption<unknown>>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataCacheOption<unknown>) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataCountry: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataCountryOption>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataCountryOption) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataAuto: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataAutoOption>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataAutoOption) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
+    DadataOrganization: <TFieldValues extends import('react-hook-form').FieldValues>({ formatter, dadataBaseUrl, ...props }: Omit<import('./autocomplete').AutocompleteControlProps<TFieldValues, import('./dadata/types').IDadataOrganizationOption>, "query" | "formatter"> & {
+        dadataBaseUrl: string;
+        formatter?: (item: import('./dadata/types').IDadataOrganizationOption) => import('..').SelectItemOption;
+    }) => import("react/jsx-runtime").JSX.Element;
 };

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

@@ -1,11 +1,11 @@
 import { Control, FieldPath, FieldValues, UseControllerProps } from 'react-hook-form';
-import { SelectBaseProps } from '../../..';
+import { SelectBaseProps, SelectItemOption } from '../../..';
 import { TFieldContainerConfig } from '../../ui';
-type SelectControlClasses = SelectBaseProps['classes'] & {
+type SelectControlClasses = SelectBaseProps<boolean>['classes'] & {
     container?: string;
     message?: string;
 };
-type SelectControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & SelectBaseProps & {
+type SelectControlProps<TFieldValues extends FieldValues = FieldValues, TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>> = UseControllerProps<TFieldValues, TName> & SelectBaseProps<boolean> & {
     /**
      * Контрол объект для управления полем
      */
@@ -22,6 +22,10 @@ type SelectControlProps<TFieldValues extends FieldValues = FieldValues, TName ex
      * Размер контейнера для поля
      */
     size?: TFieldContainerConfig['size'];
+    /**
+     * Функция для управления возвращаемым значением
+     */
+    returnValue?: (option: SelectItemOption) => string;
 };
 declare const InnerComponent: <TFieldValues extends FieldValues = FieldValues>({ control, classes, name, rules, shouldUnregister, disabled, defaultValue, returnValue, options, helperText, size, ...props }: SelectControlProps<TFieldValues>) => import("react/jsx-runtime").JSX.Element;
 export declare const SelectControl: typeof InnerComponent;

package/dist/shared/ui/formElements/dadataControl/DadataAddress.d.ts

@@ -1,3 +1,6 @@
 import { FieldValues } from 'react-hook-form';
 import { IDadataProps } from './types';
+/**
+ * @deprecated For better performance use `Controlled.DadataAddress` instead.
+ */
 export declare const DadataAddress: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/DadataAuto.d.ts

@@ -1,3 +1,6 @@
 import { FieldValues } from 'react-hook-form';
 import { IDadataProps } from './types';
+/**
+ * @deprecated For better performance use `Controlled.DadataAuto` instead.
+ */
 export declare const DadataAuto: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/DadataCountry.d.ts

@@ -1,3 +1,6 @@
 import { FieldValues } from 'react-hook-form';
 import { IDadataProps } from './types';
+/**
+ * @deprecated For better performance use `Controlled.DadataCountry` instead.
+ */
 export declare const DadataCountry: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/DadataFio.d.ts

@@ -1,3 +1,6 @@
 import { FieldValues } from 'react-hook-form';
 import { IDadataProps } from './types';
+/**
+ * @deprecated For better performance use `Controlled.DadataFio` instead.
+ */
 export declare const DadataFio: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/DadataOrganization.d.ts

@@ -1,3 +1,6 @@
 import { FieldValues } from 'react-hook-form';
 import { IDadataProps } from './types';
+/**
+ * @deprecated For better performance use `Controlled.DadataOrganization` instead.
+ */
 export declare const DadataOrganization: <T extends FieldValues>({ ...props }: IDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/autocompleteDadata/AutocompleteDadata.d.ts

@@ -23,4 +23,7 @@ export interface IAutocompleteDadataProps<T extends FieldValues> extends TCommon
     customChangeInput?: (...args: unknown[]) => void;
     customChangeOption?: (...args: unknown[]) => void;
 }
+/**
+ * @deprecated For better performance use `Controlled.AutocompleteControl` instead.
+ */
 export declare const AutocompleteDadata: <T extends FieldValues>({ dadataType, dadataBaseUrl, label, helperText, control, disabled, size, classes, badge, withValidateIcons, icon, onClickIcon, onKeyDownIcon, customChangeInput, customChangeOption, ...props }: IAutocompleteDadataProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/shared/ui/formElements/dadataControl/autocompleteDadata/model/helpers.d.ts

@@ -1,4 +1,5 @@
 import { IDadataAutoOption, IDadataCacheOption, IDadataCountryOption, TDadataReturn, TDadataSuggestionType, TDadataType } from './types';
+export type IDadataOptions<T> = IDadataCountryOption[] | IDadataAutoOption[] | IDadataCacheOption<T>[];
 export declare const getDataByDadataType: <T>(dadataType: TDadataType, data: TDadataReturn<T>) => IDadataCountryOption[] | IDadataAutoOption[] | IDadataCacheOption<T>[];
 export declare const getOptionsByDadataType: <T>(dadataType: TDadataType, suggestions: TDadataSuggestionType<T>) => {
     value: string;

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

@@ -0,0 +1,25 @@
+import { SelectBaseProps, SelectItemOption } from '..';
+import { UseQueryResult } from '@tanstack/react-query';
+export interface AutocompleteBaseProps<TData> extends Omit<SelectBaseProps<boolean>, 'options' | 'inputValue' | 'onInputChange' | 'isSearchable' | 'isMulti' | 'value' | 'onChange'> {
+    /**
+     * Запрос который должен получать options (пишем на tanstack/query)
+     */
+    query: (query: string) => UseQueryResult<TData[]>;
+    /**
+     * Позволяет форматировать данные
+     */
+    formatter: (item: TData, index: number, array: TData[]) => SelectItemOption;
+    /**
+     * Позволяет управлять выходным значением
+     */
+    returnValue?: (value: SelectItemOption) => string;
+    /**
+     * Значение инпута
+     */
+    value?: string;
+    /**
+     * Handler инпута
+     */
+    onChange?: (value: string) => void;
+}
+export declare const AutocompleteBase: <TData>({ formatter, query, value, returnValue, onChange, ...props }: AutocompleteBaseProps<TData>) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1 @@
+export { AutocompleteBase, type AutocompleteBaseProps } from './Autocomplete';

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

@@ -3,6 +3,7 @@ export type { MaskInputProps } from './maskInput';
 export type { SelectBaseProps, SelectItemOption } from './select';
 export type { CheckboxBaseProps, CheckedState } from './checkbox';
 export type { SwitchBaseProps } from './switch';
+export type { AutocompleteBaseProps } from './autocomplete';
 export type { RadioGroupBaseProps, RadioOption } from './radio';
 export declare const Uncontrolled: {
     InputBase: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "size" | "placeholder"> & {
@@ -16,6 +17,7 @@ export declare const Uncontrolled: {
         attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
         renderValues?: () => React.JSX.Element | null;
     } & import('react').RefAttributes<HTMLInputElement>>;
+    AutocompleteBase: <TData>({ formatter, query, value, returnValue, onChange, ...props }: import('./autocomplete').AutocompleteBaseProps<TData>) => import("react/jsx-runtime").JSX.Element;
     MaskInput: import('react').ForwardRefExoticComponent<Omit<import('react').InputHTMLAttributes<HTMLInputElement>, "size" | "placeholder"> & {
         classes?: {
             container?: string;
@@ -30,19 +32,20 @@ export declare const Uncontrolled: {
         mask: "datetime" | "email" | "numeric" | "currency" | "decimal" | "integer" | "percentage" | "url" | "ip" | "mac" | "ssn" | "brl-currency" | "cpf" | "cnpj" | (string & {}) | (string[] & {}) | null;
         externalMaskDefinitions?: Record<string, import('./maskInput/MaskInput').Definition>;
     } & import('react').RefAttributes<HTMLInputElement>>;
-    SelectBase: import('react').ForwardRefExoticComponent<Omit<import('react-select').Props<import('./select').SelectItemOption, boolean>, "options" | "defaultValue" | "placeholder" | "isSearchable"> & Pick<import('./input').InputBaseProps, "invalid" | "label" | "attachmentProps"> & {
+    SelectBase: import('react').ForwardRefExoticComponent<Omit<import('@headlessui/react').ComboboxProps<import('./select').SelectItemOption, boolean, "li">, "onChange" | "className" | "multiple" | "by" | "virtual"> & {
+        label: string;
+        isMulti: boolean;
+        invalid?: boolean;
         isSearchable?: boolean;
-        returnValue?: (option: import('./select').SelectItemOption) => string;
-        displayValue?: (option: import('./select').SelectItemOption) => string;
-        classes?: {
-            container?: string;
-            control?: import('./select/ui').ControlClasses;
-            option?: import('./select/ui').SelectItemClasses;
-            list?: import('./select/ui').SelectListClasses;
-        };
         options: import('./select').SelectItemOption[];
-        filterOptionDisabled?: boolean;
-    } & import('react').RefAttributes<import('node_modules/react-select/dist/declarations/src/Select').default<import('./select').SelectItemOption, boolean, import('react-select').GroupBase<import('./select').SelectItemOption>>>>;
+        classes?: import('./select/Select').SelectClasses;
+        displayValue?: (option: import('./select').SelectItemOption) => string;
+        onChange?: ((value: import('./select').SelectItemOption | import('./select').SelectItemOption[] | undefined) => void) | undefined;
+        onInputChange?: (value: string) => void;
+        inputValue?: string;
+        attachmentProps?: import('../../../types').DeepPartial<import('../ui').IFieldAttachmentProps>;
+        filterDisabled?: boolean;
+    } & import('react').RefAttributes<HTMLElement>>;
     CheckboxBase: import('react').ForwardRefExoticComponent<import('@radix-ui/react-checkbox').CheckboxProps & {
         classes?: {
             root?: string;

package/dist/shared/ui/formElements/uncontrolled/select/Select.d.ts

@@ -1,62 +1,111 @@
-import { Props } from 'react-select';
-import { ControlClasses, SelectItemClasses, SelectItemOption, SelectListClasses } from './ui';
-import { InputBaseProps } from '../../..';
-type SelectClasses = {
-    container?: string;
-    control?: ControlClasses;
-    option?: SelectItemClasses;
-    list?: SelectListClasses;
+import { ComboboxProps } from '@headlessui/react';
+import { SelectItemOption } from './model';
+import { SelectItemProps } from './ui';
+import { DeepPartial } from '../../../../types';
+import { FieldAttachment } from '../../ui';
+type FieldAttachmentProps = React.ComponentPropsWithoutRef<typeof FieldAttachment>;
+export type SelectClasses = SelectItemProps['classes'] & {
+    root?: string;
+    list?: string;
 };
-export type SelectBaseProps<IsMulti extends boolean = boolean> = Omit<Props<SelectItemOption, IsMulti>, 'placeholder' | 'options' | 'defaultValue' | 'isSearchable'> & Pick<InputBaseProps, 'attachmentProps' | 'label' | 'invalid'> & {
+export type SelectBaseProps<Multi extends boolean> = Omit<ComboboxProps<SelectItemOption, Multi, 'li'>, 'multiple' | 'onChange' | 'by' | 'virtual' | 'className'> & {
+    /**
+     * Отображаемый лейбл
+     */
+    label: string;
+    /**
+     * Поддержка множественного выбора
+     */
+    isMulti: Multi;
+    /**
+     * Пометить поле как не валидное
+     */
+    invalid?: boolean;
     /**
      * Свойство управляющее поиском
      */
     isSearchable?: boolean;
     /**
-     * Функция для управления возвращаемым значением
+     * Список отображаемых значений
+     */
+    options: SelectItemOption[];
+    /**
+     * Дополнительные стили каждого внутреннего элемента
      */
-    returnValue?: (option: SelectItemOption) => string;
+    classes?: SelectClasses;
     /**
      * Функция для управления отображаемым значением
      */
     displayValue?: (option: SelectItemOption) => string;
     /**
-     * Дополнительные стили каждого внутреннего элемента
+     * Функция для изменения значения
      */
-    classes?: SelectClasses;
+    onChange?: (value: (Multi extends true ? SelectItemOption[] : SelectItemOption) | undefined) => void;
     /**
-     * Список отображаемых значений
+     * Функция для изменения значения поиска
      */
-    options: SelectItemOption[];
+    onInputChange?: (value: string) => void;
+    /**
+     * Значение инпута
+     */
+    inputValue?: string;
+    /**
+     * Свойства дополнительной иконки
+     */
+    attachmentProps?: DeepPartial<FieldAttachmentProps>;
     /**
-     * Свойство для выключения фильтрации элементов по поиску
+     * Свойство для выключении фильтрации по поиску
      */
-    filterOptionDisabled?: boolean;
+    filterDisabled?: boolean;
 };
-export declare const SelectBase: import('react').ForwardRefExoticComponent<Omit<Props<SelectItemOption, boolean>, "options" | "defaultValue" | "placeholder" | "isSearchable"> & Pick<InputBaseProps, "invalid" | "label" | "attachmentProps"> & {
+export declare const SelectBase: import('react').ForwardRefExoticComponent<Omit<ComboboxProps<SelectItemOption, boolean, "li">, "onChange" | "className" | "multiple" | "by" | "virtual"> & {
+    /**
+     * Отображаемый лейбл
+     */
+    label: string;
+    /**
+     * Поддержка множественного выбора
+     */
+    isMulti: boolean;
+    /**
+     * Пометить поле как не валидное
+     */
+    invalid?: boolean;
     /**
      * Свойство управляющее поиском
      */
     isSearchable?: boolean;
     /**
-     * Функция для управления возвращаемым значением
+     * Список отображаемых значений
+     */
+    options: SelectItemOption[];
+    /**
+     * Дополнительные стили каждого внутреннего элемента
      */
-    returnValue?: (option: SelectItemOption) => string;
+    classes?: SelectClasses;
     /**
      * Функция для управления отображаемым значением
      */
     displayValue?: (option: SelectItemOption) => string;
     /**
-     * Дополнительные стили каждого внутреннего элемента
+     * Функция для изменения значения
      */
-    classes?: SelectClasses;
+    onChange?: ((value: SelectItemOption | SelectItemOption[] | undefined) => void) | undefined;
     /**
-     * Список отображаемых значений
+     * Функция для изменения значения поиска
      */
-    options: SelectItemOption[];
+    onInputChange?: (value: string) => void;
+    /**
+     * Значение инпута
+     */
+    inputValue?: string;
+    /**
+     * Свойства дополнительной иконки
+     */
+    attachmentProps?: DeepPartial<FieldAttachmentProps>;
     /**
-     * Свойство для выключения фильтрации элементов по поиску
+     * Свойство для выключении фильтрации по поиску
      */
-    filterOptionDisabled?: boolean;
-} & import('react').RefAttributes<import('node_modules/react-select/dist/declarations/src/Select').default<SelectItemOption, boolean, import('react-select').GroupBase<SelectItemOption>>>>;
+    filterDisabled?: boolean;
+} & import('react').RefAttributes<HTMLElement>>;
 export {};

package/dist/shared/ui/formElements/uncontrolled/select/hooks/useSelectController.d.ts

@@ -0,0 +1,20 @@
+import { SelectItemOption } from '../model';
+type UseSelectControllerProps = {
+    options: SelectItemOption[];
+    isMulti?: boolean;
+    isSearchable?: boolean;
+    displayValue?: (option: SelectItemOption) => string;
+    onChange?: (value: SelectItemOption | SelectItemOption[] | undefined) => void;
+    filterDisabled: boolean;
+    externalInputValue?: string;
+    externalOnInputChange?: (value: string) => void;
+};
+export declare const useSelectController: ({ options: initialOptions, displayValue, isSearchable, onChange, filterDisabled, externalInputValue, externalOnInputChange }: UseSelectControllerProps) => {
+    options: SelectItemOption[];
+    inputValue: string;
+    onInputValueChange: import('react').ChangeEventHandler<HTMLInputElement>;
+    onValueChange: (value: SelectItemOption | SelectItemOption[] | null) => void;
+    onDeleteItem: (values: SelectItemOption | SelectItemOption[], option: SelectItemOption) => void;
+    selectDisplayValue: (value: SelectItemOption | SelectItemOption[] | null) => string | undefined;
+};
+export {};

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

@@ -1,2 +1,2 @@
 export { SelectBase, type SelectBaseProps } from './Select';
-export type { SelectItemOption } from './ui';
+export type { SelectItemOption } from './model';

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

@@ -0,0 +1 @@
+export type * from './types';

package/dist/shared/ui/formElements/uncontrolled/select/model/types.d.ts

@@ -0,0 +1,14 @@
+import { DeepPartial } from '../../../../../types';
+import { FieldAttachment } from '../../../ui';
+type FieldAttachmentProps = React.ComponentPropsWithoutRef<typeof FieldAttachment>;
+export type SelectItemOption = {
+    value: string;
+    label: string;
+    helperText?: string;
+    disabled?: boolean;
+    attachment?: {
+        left?: DeepPartial<FieldAttachmentProps>;
+        right?: DeepPartial<FieldAttachmentProps>;
+    };
+};
+export {};

package/dist/shared/ui/formElements/uncontrolled/select/ui/{control/ui/Chip.d.ts → Chip.d.ts}

@@ -1,4 +1,4 @@
-import { SelectItemOption } from '../../../../../..';
+import { SelectItemOption } from '../model';
 type ControlChipClasses = {
     chip?: string;
 };