intelicoreact 1.8.69 → 2.0.0

package/dist/Atomic/FormElements/ActionAlert/ActionAlert.d.ts

@@ -0,0 +1,5 @@
+import type { IActionAlertProps } from './ActionAlert.interface';
+import React from 'react';
+import './ActionAlert.scss';
+declare const ActionAlert: React.FC<IActionAlertProps>;
+export default ActionAlert;

package/dist/Atomic/FormElements/ActionAlert/ActionAlert.interface.d.ts

@@ -0,0 +1,21 @@
+import type React from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+interface ButtonProps {
+    key: string;
+    buttonColor: string;
+    buttonLabel: string;
+    onClick: () => void;
+}
+export type TAlertVariant = 'default' | 'success' | 'error' | 'warning';
+export interface IActionAlertProps extends IUniProps {
+    message?: string;
+    className?: string;
+    buttonsClassName?: string;
+    date?: string;
+    noButtons?: boolean;
+    children?: React.ReactNode;
+    variant?: TAlertVariant;
+    testId?: string;
+    buttons?: ButtonProps[];
+}
+export {};

package/dist/Atomic/FormElements/ActionAlert/index.d.ts

@@ -0,0 +1,4 @@
+import type { IActionAlertProps, TAlertVariant } from './ActionAlert.interface';
+import ActionAlert from './ActionAlert';
+export type { IActionAlertProps, TAlertVariant };
+export default ActionAlert;

package/dist/Atomic/FormElements/AdvancedStatus/AdvancedStatus.d.ts

@@ -0,0 +1,5 @@
+import type { IAdvancedStatusProps } from './AdvancedStatus.interface';
+import React from 'react';
+import './AdvancedStatus.scss';
+declare const AdvancedStatus: React.FC<IAdvancedStatusProps>;
+export default AdvancedStatus;

package/dist/Atomic/FormElements/AdvancedStatus/AdvancedStatus.interface.d.ts

@@ -0,0 +1,11 @@
+import type React from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+export interface IAdvancedStatusProps extends IUniProps, Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    onChange: (value: boolean) => void;
+    inactiveText: string;
+    activeText: string;
+    value?: boolean | null | undefined;
+    disabled?: boolean;
+    isPrimary?: boolean;
+    primaryStatusText?: string;
+}

package/dist/Atomic/FormElements/AdvancedStatus/index.d.ts

@@ -0,0 +1,3 @@
+import AdvancedStatus from './AdvancedStatus';
+export default AdvancedStatus;
+export type { IAdvancedStatusProps } from './AdvancedStatus.interface';

package/dist/Atomic/FormElements/Calendar/Calendar.d.ts

@@ -0,0 +1,5 @@
+import type { CalendarProps } from './Calendar.props';
+import React from 'react';
+import './Calendar.scss';
+declare const Calendar: React.FC<CalendarProps>;
+export default Calendar;

package/dist/Atomic/FormElements/Calendar/Calendar.props.d.ts

@@ -0,0 +1,28 @@
+import type { Moment } from 'moment';
+import type { IUniProps } from '../../../types/base.interface';
+interface CalendarParams {
+    minDate?: string | Date;
+    maxDate?: string | Date;
+    momentMinDate?: Moment;
+    momentMaxDate?: Moment;
+    isDontLimitFuture?: boolean;
+}
+export interface CalendarProps extends IUniProps {
+    date?: string;
+    setDate: (date: string) => void;
+    setIsOpened: (isOpened: boolean) => void;
+    allowPrev?: boolean;
+    allowNext?: boolean;
+    params?: CalendarParams;
+    isListTop?: boolean;
+}
+interface DayType {
+    date: Date;
+}
+interface WeekDays {
+    [key: number]: DayType;
+}
+export interface Days {
+    [key: number]: WeekDays;
+}
+export {};

package/dist/Atomic/FormElements/CheckboxInput/CheckboxInput.d.ts

@@ -0,0 +1,5 @@
+import type { ICheckboxInputProps } from './CheckboxInput.interface';
+import React from 'react';
+import './CheckboxInput.scss';
+declare const CheckboxInput: React.FC<ICheckboxInputProps>;
+export default CheckboxInput;

package/dist/Atomic/FormElements/CheckboxInput/CheckboxInput.interface.d.ts

@@ -0,0 +1,11 @@
+import type React from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+export interface ICheckboxInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange' | 'id'>, IUniProps {
+    label: string;
+    id?: string | number;
+    value?: boolean;
+    onChange?: (value: boolean, event: React.ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    isStark?: boolean;
+    attributesOfNativeInput?: React.InputHTMLAttributes<HTMLInputElement>;
+}

package/dist/Atomic/FormElements/CheckboxInput/index.d.ts

@@ -0,0 +1,3 @@
+import CheckboxInput from './CheckboxInput';
+export default CheckboxInput;
+export type { ICheckboxInputProps } from './CheckboxInput.interface';

package/dist/Atomic/FormElements/CheckboxesLine/CheckboxesLine.d.ts

@@ -0,0 +1,5 @@
+import type { ICheckboxLineProps } from './CheckboxesLine.interface';
+import React from 'react';
+import './CheckboxesLine.scss';
+declare const CheckboxesLine: React.FC<ICheckboxLineProps>;
+export default CheckboxesLine;

package/dist/Atomic/FormElements/CheckboxesLine/CheckboxesLine.interface.d.ts

@@ -0,0 +1,24 @@
+import type { IUniProps } from '../../../types/base.interface';
+interface CheckboxItem {
+    id: string | number;
+    label?: string;
+    disabled?: boolean;
+    testId?: string;
+}
+export interface ICheckboxLineProps extends IUniProps {
+    field?: {
+        items?: CheckboxItem[];
+        value?: (string | number)[];
+        disabled?: boolean;
+        isPositionColumn?: boolean;
+        className?: string;
+        testId?: string;
+    };
+    isIncludeOuterStyles?: boolean;
+    items?: CheckboxItem[];
+    value?: (string | number)[];
+    disabled?: boolean;
+    isPositionColumn?: boolean;
+    onChange: (value: (string | number)[]) => void;
+}
+export {};

package/dist/Atomic/FormElements/CheckboxesLine/index.d.ts

@@ -0,0 +1,3 @@
+import CheckboxesLine from './CheckboxesLine';
+export default CheckboxesLine;
+export type { ICheckboxLineProps } from './CheckboxesLine.interface';

package/dist/Atomic/FormElements/Datepicker/Datepicker.d.ts

@@ -0,0 +1,5 @@
+import type { DatepickerProps } from './Datepicker.props';
+import React from 'react';
+import './Datepicker.scss';
+declare const Datepicker: React.FC<DatepickerProps>;
+export default Datepicker;

package/dist/Atomic/FormElements/Datepicker/Datepicker.props.d.ts

@@ -0,0 +1,25 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface DateRange {
+    start?: Date | null;
+    end?: Date | null;
+    compare?: boolean;
+}
+export interface DatepickerProps extends IUniProps {
+    isCompareHidden?: boolean;
+    limitRange?: number;
+    values?: DateRange;
+    onChange?: (range: {
+        start: Date;
+        end: Date;
+        startPrevDate: Date | null;
+        endPrevDate: Date | null;
+        compare: boolean;
+    }) => void;
+    onChangeCompare?: (compare: boolean) => void;
+    onCancel?: () => void;
+    getSelectedMode?: (range: {
+        start: Date | null;
+        end: Date | null;
+    }) => string;
+    onChangeInterval?: (interval: string) => void;
+}

package/dist/Atomic/FormElements/Datepicker/components/DatepickerCalendar.d.ts

@@ -0,0 +1,4 @@
+import type { DatepickerCalendarProps } from './DatepickerCalendar.props';
+import React from 'react';
+declare const DatepickerCalendar: React.FC<DatepickerCalendarProps>;
+export default DatepickerCalendar;

package/dist/Atomic/FormElements/Datepicker/components/DatepickerCalendar.props.d.ts

@@ -0,0 +1,23 @@
+import type { IUniProps } from '../../../../types/base.interface';
+export interface DatepickerCalendarProps extends IUniProps {
+    date: Date;
+    setDate: (date: Date) => void;
+    startDate?: Date | null;
+    endDate?: Date | null;
+    allowPrev?: boolean;
+    allowNext?: boolean;
+    onClick: (date: Date) => void;
+    onHover: (date: Date | null) => void;
+    startPrevDate?: Date | null;
+    endPrevDate?: Date | null;
+    limitRange?: number;
+}
+export interface DayInfo {
+    date: Date;
+}
+export interface WeekDays {
+    [weekday: number]: DayInfo;
+}
+export interface DaysByWeek {
+    [week: number]: WeekDays;
+}

package/dist/Atomic/FormElements/Dropdown/Dropdown.d.ts

@@ -0,0 +1,6 @@
+import type { IDropdownProps } from './Dropdown.interface';
+import React from 'react';
+import './Dropdown.scss';
+export declare const MIN_ITEMS_FOR_SHOW_MOBILE_SEARCH = 10;
+declare function Dropdown<T extends string | number = string | number>({ label, options, value, error, disabled, onChange, placeholder, className, isSearchable: isSearchableProp, entity, scrollReactionObj, isListTop, isNotValidateASCII, testId, sortAlphabetical, fieldKey, id, noOptionsText, isDoNotPullOutListOfMainContainer, withMobileLogic, withActions, minItemsForShowMobileSearch, customTrigger, tabIndex, onActionConfirmClick, onActionCancelClick, isDefaultOpened, isDefaultOpenedMobile, footerContent, closeOnSelect, closeOnSelectMobile, withApplyLogic, cancelButtonRef, applyButtonRef, }: IDropdownProps): React.ReactElement | null;
+export default Dropdown;

package/dist/Atomic/FormElements/Dropdown/Dropdown.interface.d.ts

@@ -0,0 +1,102 @@
+import type { ReactNode } from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+export interface IDropdownOption extends IUniProps {
+    list?: IDropdownOption[];
+    items?: IDropdownOption[];
+    value: string | number;
+    label: string;
+    postfix?: string | undefined;
+    disabled?: boolean;
+    labelClassName?: string;
+    description?: string;
+    icon?: ReactNode | string;
+    customMobileIcon?: ReactNode | string;
+}
+export interface IDropdownProps extends IUniProps {
+    label?: string;
+    options?: IDropdownOption[];
+    value: string | number;
+    error?: string | boolean;
+    disabled?: boolean;
+    onChange?: (value: string | number) => void;
+    placeholder?: string;
+    isSearchable?: boolean;
+    entity?: string;
+    scrollReactionObj?: {
+        callback?: (e: Event) => void;
+        isWithAnyScrolling?: boolean;
+        scrollingInaccuracy?: number;
+    };
+    isListTop?: boolean;
+    isNotValidateASCII?: boolean;
+    sortAlphabetical?: boolean;
+    fieldKey?: string;
+    id?: string | number;
+    noOptionsText?: string;
+    attributesOfNativeInput?: React.InputHTMLAttributes<HTMLInputElement>;
+    isDoNotPullOutListOfMainContainer?: boolean;
+    withMobileLogic?: boolean;
+    withActions?: boolean;
+    minItemsForShowMobileSearch?: number;
+    customTrigger?: ReactNode;
+    tabIndex?: number;
+    onActionConfirmClick?: () => void;
+    onActionCancelClick?: () => void;
+    isDefaultOpened?: boolean;
+    isDefaultOpenedMobile?: boolean;
+    footerContent?: ReactNode;
+    closeOnSelect?: boolean;
+    closeOnSelectMobile?: boolean;
+    withApplyLogic?: boolean;
+    cancelButtonRef?: React.MutableRefObject<HTMLElement | null>;
+    applyButtonRef?: React.MutableRefObject<HTMLElement | null>;
+}
+export interface IDependOptions {
+    onChange: (item: IDropdownOption) => void;
+    options?: IDropdownOption[];
+}
+export interface IUseDropdown {
+    isMobile?: boolean;
+    dropdownId: string;
+    isOpen: boolean;
+    setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    searchValue?: string | null;
+    setSearchValue: (v: string | null) => void;
+    initListHeight: number | null;
+    setInitListHeight: (v: number | null) => void;
+    isSearchChanged: boolean;
+    setIsSearchChanged: (v: boolean) => void;
+    isSearchInputFocused: boolean;
+    setIsSearchInputFocused: (v: boolean) => void;
+    isScrollableList: boolean;
+    setIsScrollableList: (v: boolean) => void;
+    isFixedMaxHeight: boolean;
+    setIsFixedMaxHeight: (v: boolean) => void;
+    scrollTop: number;
+    setScrollTop: (v: number) => void;
+    scrollHeight: number;
+    setScrollHeight: (v: number) => void;
+    maxListContainerHeight: number;
+    setMaxListContainerHeight: (v: number) => void;
+    getListContainer: () => HTMLElement | null;
+    getListContainerWrapper: () => Element | null;
+    getParentNode: () => Element | null;
+    getPreparedOptionLabel: (text: string, postfix?: string | undefined, description?: string | undefined) => string;
+    getSortedOptions: (data: IDropdownOption[]) => IDropdownOption[];
+    filteredGroups: IDropdownOption[];
+    filteredItems: IDropdownOption[];
+    filteredOptions: IDropdownOption[];
+    selectedLabel?: string;
+    postfixText?: string | null;
+    dropdownRef: React.MutableRefObject<Element | null>;
+    dropdownListRef: React.MutableRefObject<Element | null>;
+    dropdownListWrapperRef: React.MutableRefObject<Element | null>;
+    dropdownFooterRef: React.MutableRefObject<Element | null>;
+    searchInputRef: React.MutableRefObject<HTMLInputElement | Omit<HTMLInputElement, 'value'> | null>;
+    wrapperRef: React.MutableRefObject<Element | null>;
+    totalOptionsLength: number;
+    isSearchable?: boolean;
+    valueToApply?: string | number | null;
+    valueToApplyRef?: React.MutableRefObject<string | number | null>;
+    setValueToApply?: (value: string | number | null) => void;
+}

package/dist/Atomic/FormElements/Dropdown/_utils.d.ts

@@ -0,0 +1,8 @@
+import type { IDropdownOption } from './Dropdown.interface';
+export declare function getTotalOptions(options: IDropdownOption[]): number;
+export declare function moveOtherToEnd(options: IDropdownOption[]): IDropdownOption[];
+export declare function getListContainer(dropdownId: string): HTMLElement | null;
+export declare function getListContainerWrapper(dropdownId: string): Element | null;
+export declare function getParentNode(dropdownRef: React.MutableRefObject<Element | null>, isDoNotPullOutListOfMainContainer?: boolean): Element | null;
+export declare function getPreparedOptionLabel(searchValue: string | null | undefined, text: string, isSearchable?: boolean, postfix?: string, description?: string): string;
+export declare function getSortedOptions(data: IDropdownOption[], sortAlphabetical?: boolean): IDropdownOption[];

package/dist/Atomic/FormElements/Dropdown/components/DropdownLoader.d.ts

@@ -0,0 +1,4 @@
+export default DropdownLoader;
+declare function DropdownLoader({ variant }: {
+    variant?: string | undefined;
+}): JSX.Element;

package/dist/Atomic/FormElements/Dropdown/index.d.ts

@@ -0,0 +1,4 @@
+import type { IDropdownOption, IDropdownProps } from './Dropdown.interface';
+import Dropdown from './Dropdown';
+export type { IDropdownOption, IDropdownProps };
+export default Dropdown;

package/dist/Atomic/FormElements/Dropdown/useDropdown.d.ts

@@ -0,0 +1,3 @@
+import type { IDropdownProps, IUseDropdown } from './Dropdown.interface';
+declare function useDropdown({ id, fieldKey, value, sortAlphabetical, withMobileLogic, options, minItemsForShowMobileSearch, isSearchable: isSearchableProp, isDoNotPullOutListOfMainContainer }?: Partial<IDropdownProps>): IUseDropdown;
+export default useDropdown;

package/dist/Atomic/FormElements/DropdownLiveSearch/DropdownLiveSearch.d.ts

@@ -0,0 +1,5 @@
+import type { IDropdownLiveSearchProps } from './DropdownLiveSearch.interface';
+import React from 'react';
+import './DropdownLiveSearch.scss';
+declare const DropdownLiveSearch: React.FC<IDropdownLiveSearchProps>;
+export default DropdownLiveSearch;

package/dist/Atomic/FormElements/DropdownLiveSearch/DropdownLiveSearch.interface.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+export interface IDropdownLiveSearchOption extends IUniProps {
+    list?: IDropdownLiveSearchOption[];
+    items?: IDropdownLiveSearchOption[];
+    value: string | number;
+    label: string;
+    postfix?: string | undefined;
+    disabled?: boolean;
+    labelClassName?: string;
+    description?: string;
+    icon?: ReactNode | string;
+    customMobileIcon?: ReactNode | string;
+}
+export interface IDropdownLiveSearchProps extends IUniProps {
+    label?: string;
+    value: string | number;
+    error?: string | boolean;
+    disabled?: boolean;
+    onChange?: (value: string | number) => void;
+    placeholder?: string;
+    isSearchable?: boolean;
+    doRequest?: (search: string, flag?: boolean) => Promise<void>;
+    isLoading?: boolean;
+    options?: IDropdownLiveSearchOption[];
+    fieldKey?: string;
+    id?: string | number;
+    isListTop?: boolean;
+    attributesOfNativeInput?: React.InputHTMLAttributes<HTMLInputElement>;
+    withMobileLogic?: boolean;
+    tabIndex?: number;
+    isNotValidateASCII?: boolean;
+    noOptionsText?: string;
+}

package/dist/Atomic/FormElements/FileLoader/FileLoader.d.ts

@@ -0,0 +1,5 @@
+import type { FileLoaderProps } from './FileLoader.interface';
+import React from 'react';
+import './FileLoader.scss';
+declare const FileLoader: React.FC<FileLoaderProps>;
+export default FileLoader;

package/dist/Atomic/FormElements/FileLoader/FileLoader.interface.d.ts

@@ -0,0 +1,29 @@
+import type React from 'react';
+import type { LoadZoneProps } from './partial/LoadZone.interface';
+export interface FileLoaderValue {
+    id?: string;
+    name: string;
+    path: string;
+}
+export interface FileLoaderProps {
+    fieldKey: string;
+    value: FileLoaderValue | null;
+    disabled?: boolean;
+    error?: any;
+    className?: string;
+    placeholder?: string;
+    onChange: (value: FileLoaderValue | null) => void;
+    doLoad: LoadZoneProps['doLoad'];
+    filterFiles?: LoadZoneProps['filterFiles'];
+    processErrors?: (error: unknown) => void;
+    isBlockNullValues?: boolean;
+    isDisableErrorsClass?: boolean;
+    uploadIcon?: React.ReactNode;
+    downloadIcon?: React.ReactNode;
+    deleteIcon?: React.ReactNode;
+    spiner?: React.ReactNode;
+    isIconAfter?: boolean;
+    isLinkTypeDownload?: boolean;
+    isUseLinkTitle?: boolean;
+    attributesOfNativeInput?: React.InputHTMLAttributes<HTMLInputElement>;
+}

package/dist/Atomic/FormElements/FileLoader/partial/LoadZone.d.ts

@@ -0,0 +1,5 @@
+import type { LoadZoneProps } from './LoadZone.interface';
+import React from 'react';
+import '../FileLoader.scss';
+declare const LoadZone: React.FC<LoadZoneProps>;
+export default LoadZone;

package/dist/Atomic/FormElements/FileLoader/partial/LoadZone.interface.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+import type { FileLoaderValue } from '../FileLoader.interface';
+export interface LoadZoneProps {
+    RC: string;
+    fieldKey: string;
+    onChange: (value: any) => void;
+    doLoad: (file: File | null) => Promise<FileLoaderValue | null>;
+    setDragenter?: (value: boolean) => void;
+    setIsLoadContent?: (value: boolean) => void;
+    icon?: React.ReactNode;
+    placeholder?: string;
+    filterFiles?: (file: File) => File | null | Promise<File | null>;
+    processErrors?: (file: File) => void | Promise<void>;
+    isBlockNullValues?: boolean;
+    attributesOfNativeInput?: React.InputHTMLAttributes<HTMLInputElement>;
+}

package/dist/Atomic/FormElements/FileLoader/partial/LoadedContent.d.ts

@@ -0,0 +1,5 @@
+import type { LoadedContentProps } from './LoadedContent.interface';
+import React from 'react';
+import '../FileLoader.scss';
+declare const LoadedContent: React.FC<LoadedContentProps>;
+export default LoadedContent;

package/dist/Atomic/FormElements/FileLoader/partial/LoadedContent.interface.d.ts

@@ -0,0 +1,12 @@
+import type React from 'react';
+import type { FileLoaderValue } from '../FileLoader.interface';
+export interface LoadedContentProps {
+    RC: string;
+    value: FileLoaderValue;
+    onDelete?: () => void;
+    icon?: React.ReactNode;
+    isIconAfter?: boolean;
+    deleteIcon?: React.ReactNode;
+    isUseLinkTitle?: boolean;
+    isLinkTypeDownload?: boolean;
+}

package/dist/Atomic/FormElements/FileLoaderDescription/FileLoaderDescription.d.ts

@@ -0,0 +1,5 @@
+import type { IFileLoaderDescriptionProps } from './FileLoaderDescription.interface';
+import React from 'react';
+import './FileLoaderDescription.scss';
+declare const FileLoaderDescription: React.FC<IFileLoaderDescriptionProps>;
+export default FileLoaderDescription;

package/dist/Atomic/FormElements/FileLoaderDescription/FileLoaderDescription.interface.d.ts

@@ -0,0 +1,31 @@
+export interface IFile {
+    id?: string | number;
+    value: string;
+    base64: string;
+    maxItemSizeBytes: number;
+    error: string | null;
+    outerError?: string | null | boolean;
+    isRequired?: boolean;
+    accept?: string;
+}
+export interface IAccordionItem {
+    title: string;
+    description: string;
+}
+export interface IFileLoaderDescriptionProps {
+    id?: string;
+    testId?: string;
+    fieldKey?: string;
+    files?: IFile[];
+    onChange: (files: IFile[]) => void;
+    className?: string;
+    filesDescription?: string;
+    documentName?: string;
+    accordionTitle?: string;
+    accordionListContent?: IAccordionItem[];
+    listDescription?: string;
+    maxFilesCount?: number;
+    isWithoutAccordion?: boolean;
+    error?: string | boolean | null;
+    [key: string]: any;
+}

package/dist/Atomic/FormElements/FileLoaderLocal/FileLoaderLocal.d.ts

@@ -0,0 +1,5 @@
+import type { FileLoaderLocalProps } from './FileLoaderLocal.interface';
+import React from 'react';
+import './FileLoaderLocal.scss';
+declare const FileLoaderLocal: React.FC<FileLoaderLocalProps>;
+export default FileLoaderLocal;

package/dist/Atomic/FormElements/FileLoaderLocal/FileLoaderLocal.interface.d.ts

@@ -0,0 +1,31 @@
+import type React from 'react';
+export interface FileLoaderLocalValue {
+    name: string;
+    valueExtension: string;
+    file: File;
+    e: React.ChangeEvent<HTMLInputElement>;
+    id: string;
+    groupId?: string;
+    error?: string;
+}
+export interface FileLoaderLocalProps {
+    id: string | number;
+    fieldKey?: string;
+    fieldId?: string;
+    groupId?: string;
+    label: string;
+    error?: string;
+    outerError?: string | boolean | null;
+    isRequired?: boolean;
+    accept?: string;
+    onChange: (payload: FileLoaderLocalValue | {
+        id: string | number;
+        groupId?: string;
+    }) => void;
+    className?: string;
+    value?: string;
+    isNoTrashIcon?: boolean;
+    maxItemSizeBytes?: number;
+    testId?: string;
+    attributesOfNativeInput?: React.InputHTMLAttributes<HTMLInputElement>;
+}

package/dist/Atomic/FormElements/FileLoaderLocalGroup/FileLoaderLocalGroup.d.ts

@@ -0,0 +1,5 @@
+import type { FileLoaderLocalGroupProps } from './FileLoaderLocalGroup.interface';
+import React from 'react';
+import './FileLoaderLocalGroup.scss';
+declare const FileLoaderLocalGroup: React.FC<FileLoaderLocalGroupProps>;
+export default FileLoaderLocalGroup;

package/dist/Atomic/FormElements/FileLoaderLocalGroup/FileLoaderLocalGroup.interface.d.ts

@@ -0,0 +1,28 @@
+export interface FileItem {
+    id: number | string;
+    value: string;
+    base64?: string;
+    error?: string;
+    accept: string;
+    maxItemSizeBytes?: number;
+    isRequired?: boolean;
+    fieldKey?: string;
+}
+export interface FileGroup {
+    groupId: string;
+    groupTitleDescription?: string;
+    alertText?: string;
+    accept: string;
+    maxItemSizeBytes?: number;
+    isRequired?: boolean;
+    files: FileItem[];
+}
+export interface FileLoaderLocalGroupProps {
+    className?: string;
+    groupsArray?: FileGroup[];
+    isSingleGroup?: boolean;
+    onChange: (groups: FileGroup[]) => void;
+    labelPrefix?: string;
+    testId?: string;
+    alertText?: string;
+}

package/dist/Atomic/FormElements/FormattedRawSSN/FormattedRawSSN.d.ts

@@ -0,0 +1,5 @@
+import type { IFormattedRawSSNProps } from './FormattedRawSSN.interface';
+import React from 'react';
+import './FormattedRawSSN.scss';
+declare const FormattedRawSSN: React.FC<IFormattedRawSSNProps>;
+export default FormattedRawSSN;

package/dist/Atomic/FormElements/FormattedRawSSN/FormattedRawSSN.interface.d.ts

@@ -0,0 +1,14 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface IFormattedRawSSNProps extends IUniProps {
+    value?: string;
+    onChange?: (value: string) => void;
+    testId?: string;
+    fullSnnMask?: string;
+    significantChars?: string[];
+    maskChar?: string;
+    isHiddenDefault?: boolean;
+    maxLen?: number;
+    countOfFirstDigitsToHide?: number;
+    postfix?: string;
+    [key: string]: any;
+}

package/dist/Atomic/FormElements/FormattedRawSSN/FormattedRawSSN_old.d.ts

@@ -0,0 +1,11 @@
+export default FormattedRawSSN;
+declare function FormattedRawSSN({ value, postfix, onChange: onChangeProp, maskChar, testId, isHiddenDefault, maxLen, ...args }: {
+    [x: string]: any;
+    value?: string | undefined;
+    postfix?: string | undefined;
+    onChange?: (() => void) | undefined;
+    maskChar?: string | undefined;
+    testId?: string | undefined;
+    isHiddenDefault?: boolean | undefined;
+    maxLen?: number | undefined;
+}): JSX.Element;

package/dist/Atomic/FormElements/FormattedRawSSN/index.d.ts

@@ -0,0 +1,4 @@
+import type { IFormattedRawSSNProps } from './FormattedRawSSN.interface';
+import FormattedRawSSN from './FormattedRawSSN';
+export type { IFormattedRawSSNProps };
+export default FormattedRawSSN;

package/dist/Atomic/FormElements/Input/Input.d.ts

@@ -0,0 +1,8 @@
+import type { ReactElement } from 'react';
+import type { InputProps } from './types';
+import React from 'react';
+import './Input.scss';
+declare function Input({ ref, blurTrim, autocomplete, isSelect, onChange, onBlur, onFocus, onKeyUp, onKeyDown, isNotBlinkErrors, isPriceInput, onlyNumbers, disabled, withDelete, value, placeholder, className, type, mask, maskChar, formatChars, error, icon, iconDynamicKey, iconDynamicProps, symbolsLimit, blinkTime, isFocusDefault, isNotValidateASCII, isNumericMobileKeyboard, isCropFirstNool, testId, action, isUseAutoSelect, isReadOnly, isLoading, name, fieldKey, id, attributesOfNativeInput }: InputProps & {
+    ref?: React.RefObject<Omit<HTMLInputElement, 'value'> | null>;
+}): ReactElement;
+export default Input;