intelicoreact 1.8.69 → 2.0.0

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

@@ -0,0 +1,78 @@
+import type { KeyboardEventHandler, LegacyRef, ReactNode } from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+import type { IDynamicIconProps } from '../../UI/DynamicIcon';
+import type { THintPosition } from '../../UI/Hint/Hint.interface';
+declare global {
+    interface String {
+        longerThan(compareWith: string): boolean;
+        lastIndexEqualsTo(index: number): boolean;
+    }
+}
+export type TInputMask3ErrorKey = 'onlyLetter' | 'onlyDigit' | 'onlyUpperCase' | 'onlyLowerCase' | 'default';
+export interface IInputMask3Errors {
+    onlyLetter?: string;
+    onlyDigit?: string;
+    onlyUpperCase?: string;
+    onlyLowerCase?: string;
+    default?: string | null;
+}
+export interface IInputMask3CharObj {
+    char: string;
+    maskChar: string;
+    isSpecialSymbol: boolean;
+    isCharSymbol: boolean;
+    ref: LegacyRef<Element>;
+}
+export interface IInputMask3Props extends IUniProps {
+    autocomplete?: string;
+    maskPattern: string;
+    maskPatternPlaceholder?: string;
+    maskPlaceholder?: string;
+    maskDigitPlaceholder?: string;
+    maskLetterPlaceholder?: string;
+    usePatternPlaceholder?: boolean;
+    maxEditableIndex?: number;
+    isFocusedDefault?: boolean;
+    isClearable?: boolean;
+    isCaseSensitive?: boolean;
+    adaptTextCase?: boolean;
+    isUseAutoSelect?: boolean;
+    isLoading?: boolean;
+    withHiddenMode?: boolean;
+    hiddenChar?: string;
+    maxHiddenIndex?: number;
+    isValueHiddenDefault?: boolean;
+    isHide?: boolean;
+    icon?: string | ReactNode;
+    showIcon?: boolean;
+    isIconLeft?: boolean;
+    isIconRight?: boolean;
+    iconDynamicKey?: IDynamicIconProps['iconKey'];
+    iconDynamicProps?: object;
+    value?: string;
+    blinkErrors?: boolean;
+    blinkDuration?: number;
+    showErrors?: boolean;
+    errors?: IInputMask3Errors;
+    error?: string;
+    onChange?: (value?: string, clearValue?: string) => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+    onFilled?: () => void;
+    showHint?: boolean;
+    hintText?: string;
+    hintClassName?: string;
+    isHintRight?: boolean;
+    isHintLeft?: boolean;
+    hintPosition?: THintPosition;
+    isNumericMobileKeyboard?: boolean;
+    hideMaskOnBlur?: boolean;
+    returnMaskedValue?: boolean;
+    name?: string;
+    fieldKey?: string;
+    id?: string;
+    disabled?: boolean;
+    focusSelector?: string;
+    attributesOfNativeInput?: React.InputHTMLAttributes<HTMLInputElement>;
+}

package/dist/Atomic/FormElements/InputMask3/config.d.ts

@@ -0,0 +1,8 @@
+import type { IInputMask3Errors } from './InputMask3.interface';
+export declare const DEFAULT_ERRORS: IInputMask3Errors;
+export declare const UPPERCASE_LETTER_MASK_CHAR: string;
+export declare const LOWERCASE_LETTER_MASK_CHAR: string;
+export declare const DIGIT_MASK_CHAR: string;
+export declare const SPACE_CHAR: string;
+export declare const ANDROID_CHROME_TEXT_CODE: number;
+export declare const EXCLUDED_KEYS: string[];

package/dist/Atomic/FormElements/InputMask3/functions.d.ts

@@ -0,0 +1,11 @@
+export declare function getSelectionText(): string;
+export declare function resetSelectionText(): void;
+export declare function copyToClipboard(str: string): Promise<void>;
+export declare function selectElementContents(el: Node): void;
+export declare function isLetter(char: string): boolean;
+export declare function isUpperCaseLetter(char: string): boolean;
+export declare function isLowerCaseLetter(char: string): boolean;
+export declare function isDigit(char: string): boolean;
+export declare function isDigitMaskChar(char: string): boolean;
+export declare function isLetterMaskChar(char: string): boolean;
+export declare function voidFn(): void;

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

@@ -0,0 +1,5 @@
+import type { IInputWithActionProps } from './InputWithAction.interface';
+import React from 'react';
+import './InputWithAction.scss';
+declare const _default: React.ForwardRefExoticComponent<Pick<IInputWithActionProps, keyof IInputWithActionProps> & React.RefAttributes<any>>;
+export default _default;

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

@@ -0,0 +1,26 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface IInputWithActionProps extends IUniProps {
+    className?: string;
+    inputClassName?: string;
+    isHideAction?: boolean;
+    actionLabel?: string;
+    doAction?: (value: any, props?: any) => Promise<any>;
+    actionContent?: React.ReactNode;
+    actionProps?: any;
+    isNoChangeAfterAction?: boolean;
+    isWithCopy?: boolean;
+    copyLabel?: string;
+    copy?: (value: any) => void;
+    copyIcon?: React.ReactNode;
+    isNoCopyIcon?: boolean;
+    isCopyIconRight?: boolean;
+    copyButtonVariant?: string;
+    disabled?: boolean;
+    isInputZoneDisabled?: boolean;
+    isInputDisabled?: boolean;
+    isLodaing?: boolean;
+    onChange: (value: any) => void;
+    value: any;
+    testId?: string;
+    [key: string]: any;
+}

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

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

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

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

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

@@ -0,0 +1,15 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface IInputRow {
+    param: string;
+    value: string;
+    description: string;
+    rowId: string;
+}
+export interface IInputsRowProps extends IUniProps {
+    items?: IInputRow[];
+    title?: string;
+    paramPlaceholder?: string;
+    valuePlaceholder?: string;
+    descriptionPlaceholder?: string;
+    onChange?: (rows: IInputRow[]) => void;
+}

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

@@ -0,0 +1,4 @@
+import type { IInputRow, IInputsRowProps } from './InputsRow.interface';
+import InputsRow from './InputsRow';
+export type { IInputRow, IInputsRowProps };
+export default InputsRow;

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

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

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

@@ -0,0 +1,19 @@
+import type React from 'react';
+import type { IHintProps } from '../../../Atomic/UI/Hint';
+import type { IUniProps } from '../../../types/base.interface';
+export interface ILabelProps extends IUniProps {
+    label?: string;
+    note?: string;
+    hint?: {
+        text: string;
+        icon?: React.ReactNode;
+        variant?: IHintProps['variant'];
+        hintSide?: IHintProps['side'];
+    };
+    isRequired?: boolean;
+    isLabelBolt?: boolean;
+    onClickHintCallback?: () => void;
+    error?: string | null;
+    isAccessability?: boolean;
+    isAccessabilityHint?: boolean;
+}

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

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

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

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { IMobileCalendarProps } from './MobileCalendar.interface';
+import './MobileCalendar.scss';
+declare function MobileCalendar({ min, max, value, rows, label, timeout, isMobile, showSelectedDate, listItemHeight, classes, onChange, onMinDateReached, onMaxDateReached, }: IMobileCalendarProps): ReactElement;
+export default MobileCalendar;

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

@@ -0,0 +1,34 @@
+import type { Moment } from 'moment';
+interface Classes {
+    wrapper?: string;
+    label?: string;
+    body?: string;
+    yearsBlock?: string;
+    yearsList?: string;
+    yearsListItem?: string;
+    monthsBlock?: string;
+    monthsList?: string;
+    monthsListItem?: string;
+    daysBlock?: string;
+    daysList?: string;
+    daysListItem?: string;
+    prevItem?: string;
+    nextItem?: string;
+    activeItem?: string;
+}
+export interface IMobileCalendarProps {
+    min?: Moment | string;
+    max?: Moment | string;
+    value?: Moment | string;
+    rows?: number;
+    label?: string;
+    timeout?: number;
+    isMobile?: boolean;
+    showSelectedDate?: boolean;
+    listItemHeight?: number;
+    classes?: Classes;
+    onChange?: (date: Moment) => void;
+    onMinDateReached?: (date: Moment) => void;
+    onMaxDateReached?: (date: Moment) => void;
+}
+export {};

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import './MultiSelect.scss';
+export interface MultiSelectOption {
+    label: string;
+    value: string;
+    id: string | number;
+}
+export interface MultiSelectProps {
+    options: MultiSelectOption[];
+    chosenOptions: string[];
+    onChange: (values: string[]) => void;
+}
+declare const MultiSelect: React.FC<MultiSelectProps>;
+export default MultiSelect;

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

@@ -0,0 +1,36 @@
+export default NumericInput;
+declare function NumericInput({ disabled, withDelete, numStep, min, max, value, placeholder, className, testId, name, fieldKey, id, onChange, onBlur, onFocus, onKeyUp, onKeyDown, maskChar, formatChars, error, icon, isNotBlinkErrors, blinkTime, isPriceInput, isFocusDefault, isNotRenderButtons, isUseAutoSelect, isLoading, isAllowNullValue, onlyNumbers, attributesOfNativeInput, }: {
+    disabled: any;
+    withDelete: any;
+    numStep?: number | undefined;
+    min?: number | undefined;
+    max: any;
+    value: any;
+    placeholder: any;
+    className: any;
+    testId?: string | undefined;
+    name: any;
+    fieldKey: any;
+    id: any;
+    onChange?: (() => void) | undefined;
+    onBlur?: (() => void) | undefined;
+    onFocus?: (() => void) | undefined;
+    onKeyUp?: (() => void) | undefined;
+    onKeyDown?: (() => void) | undefined;
+    maskChar: any;
+    formatChars: any;
+    error: any;
+    icon: any;
+    isNotBlinkErrors: any;
+    blinkTime: any;
+    isPriceInput: any;
+    isFocusDefault?: boolean | undefined;
+    isNotRenderButtons?: boolean | undefined;
+    isUseAutoSelect?: boolean | undefined;
+    isLoading?: boolean | undefined;
+    isAllowNullValue?: boolean | undefined;
+    onlyNumbers?: {
+        type: string;
+    } | undefined;
+    attributesOfNativeInput?: {} | undefined;
+}): JSX.Element;

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

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { IRadioGroupProps } from './RadioGroup.interface';
+import './RadioGroup.scss';
+declare function RadioGroup({ className, disabled, value, onChange, direction, options, }: IRadioGroupProps): ReactElement;
+export default RadioGroup;

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

@@ -0,0 +1,16 @@
+import type { IUniProps } from '../../../types/base.interface';
+interface IOption {
+    id: string;
+    label: string;
+    value: string;
+    checked?: boolean | string | number | undefined;
+}
+export interface IRadioGroupProps extends IUniProps {
+    className?: string;
+    disabled?: boolean;
+    value: string;
+    onChange: (value: string | number | boolean) => void;
+    direction?: string;
+    options: IOption[];
+}
+export {};

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

@@ -0,0 +1,5 @@
+import type { IRadioGroupWithInputProps } from './RadioGroupWithInput.interface';
+import React from 'react';
+import './RadioGroupWithInput.scss';
+declare function RadioGroupWithInput({ alert, className, disabled, onChange, direction, options, }: IRadioGroupWithInputProps): React.ReactElement;
+export default RadioGroupWithInput;

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

@@ -0,0 +1,24 @@
+export interface IInputProps {
+    id: string;
+    label: string;
+    name: string;
+    [key: string]: any;
+}
+export interface IOption {
+    id: number | string;
+    label: string;
+    value: string;
+    checked: string;
+    input?: IInputProps;
+}
+export interface IRadioGroupWithInputProps {
+    alert?: {
+        status: string;
+        text: string;
+    };
+    className?: string;
+    disabled?: boolean;
+    direction?: 'row' | 'column';
+    options: IOption[];
+    onChange?: (options: IOption[]) => void;
+}

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

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

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

@@ -0,0 +1,13 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface IRadioInputProps extends IUniProps {
+    label?: string;
+    id?: string;
+    name?: string | number;
+    className?: string;
+    checked: boolean | string | number | undefined;
+    disabled?: boolean;
+    value: boolean | string | number;
+    testId?: string;
+    onChange?: (value: string | number | boolean) => void;
+    attributesOfNativeInput?: any;
+}

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

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

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import './RadioRowSwitcher.scss';
+export interface RadioRowSwitcherItem {
+    key: string;
+    label: React.ReactNode;
+}
+export interface RadioRowSwitcherProps {
+    onChange: (value: string) => void;
+    radios: RadioRowSwitcherItem[];
+    label?: string;
+    value?: string;
+}
+declare const RadioRowSwitcher: React.FC<RadioRowSwitcherProps>;
+export default RadioRowSwitcher;

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

@@ -0,0 +1,2 @@
+export default RangeCalendar;
+declare function RangeCalendar(props: any): JSX.Element;

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

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

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

@@ -0,0 +1,32 @@
+import type { IUniProps } from '../../../types/base.interface';
+export interface OnChangeValue {
+    from?: string | number;
+    to?: string | number;
+    prop?: number;
+}
+export interface IRangeInputsProps extends IUniProps {
+    isColumnPosition?: boolean;
+    className?: string;
+    value?: {
+        from?: string | number;
+        to?: string | number;
+    };
+    onChange: (value: OnChangeValue) => void;
+    validateErrors?: (from: string, to: string) => {
+        from?: string;
+        to?: string;
+    } | undefined;
+    setError?: (error: string | {
+        from?: string;
+        to?: string;
+    }) => void;
+    type?: string;
+    label?: string;
+    isPrice?: boolean;
+    testId?: string;
+    withZero?: boolean;
+    fromPlaceholder?: string;
+    toPlaceholder?: string;
+    disabled?: boolean;
+    isDisabled?: boolean;
+}

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

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

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

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

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

@@ -0,0 +1,36 @@
+import type { IUniProps } from '../../../types/base.interface';
+interface RangeValue {
+    from: number | string;
+    to: number | string;
+}
+export interface IRangeListProps extends IUniProps {
+    className?: string;
+    value?: RangeValue[];
+    disabled?: boolean;
+    validateErrors?: (from: number, to: number) => string | boolean | undefined;
+    onChange: (value: RangeValue[]) => void;
+    isFloatValues?: boolean;
+    decimalPlaces?: number;
+    error?: string;
+    defaultErrorText?: string;
+    nullValueText?: string;
+    isOnlyOneRow?: boolean;
+    testId?: string;
+}
+export interface IRangeListCellProps {
+    children: React.ReactNode;
+    idx?: number;
+    className?: string;
+    onClick?: () => void;
+}
+export interface IRangeListRowProps {
+    from: number | string;
+    to: number | string;
+    idx: number;
+    actionClick: (index: number) => void;
+}
+export interface IInputOnlyNumbersOptions {
+    type: 'float' | 'int';
+    decimalPlaces?: number;
+}
+export {};

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

@@ -0,0 +1,4 @@
+import type { IRangeListCellProps, IRangeListProps, IRangeListRowProps } from './RangeList.interface';
+import RangeList from './RangeList.js';
+export type { IRangeListCellProps, IRangeListProps, IRangeListRowProps };
+export default RangeList;

package/dist/Atomic/FormElements/RangeList/partial/RangeListRow.d.ts

@@ -0,0 +1,5 @@
+import type { IRangeListCellProps, IRangeListRowProps } from '../RangeList.interface';
+import React from 'react';
+export declare const RangeListCell: React.FC<IRangeListCellProps>;
+declare const RangeListRow: React.FC<IRangeListRowProps>;
+export default RangeListRow;

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

@@ -0,0 +1,19 @@
+export default function RangeSlider({ required, noTrack, rangeSymbol, min, max, decimalPlaces, minRange, precision, testId, value, unit, label, isUseBitPoints, onChange, }: {
+    required: any;
+    noTrack: any;
+    rangeSymbol: any;
+    min?: number | undefined;
+    max?: number | undefined;
+    decimalPlaces?: number | undefined;
+    minRange?: number | undefined;
+    precision?: number | undefined;
+    testId?: string | undefined;
+    value?: {
+        from: any;
+        to: any;
+    } | undefined;
+    unit?: string | undefined;
+    label?: string | undefined;
+    isUseBitPoints?: boolean | undefined;
+    onChange?: (() => void) | undefined;
+}): JSX.Element;

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

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

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

@@ -0,0 +1,47 @@
+import type { IUniProps } from '../../../types/base.interface';
+export declare enum EPointValueType {
+    From = "from",
+    To = "to",
+    Both = "both"
+}
+export declare enum ECollision {
+    None = 0,
+    Left = -1,
+    Right = 1,
+    Both = 2
+}
+export declare enum EAssignSide {
+    Left = -1,
+    Right = 1
+}
+export interface IRangeItem {
+    id?: number | null;
+    from: number;
+    to: number;
+    label?: string;
+    data?: any[];
+    value?: number;
+}
+export interface ITriggerItem {
+    id: number;
+    value: number;
+    isFixed?: boolean;
+    isHidden?: boolean;
+}
+export interface ITransformOnConcatResult {
+    data: IRangeItem['data'];
+    value: IRangeItem['value'];
+}
+export interface IRangeSlider2Props extends IUniProps {
+    min?: number;
+    max?: number;
+    minRange?: number;
+    dividersRange?: number;
+    pointValueType?: EPointValueType;
+    precision?: number;
+    step?: number;
+    className?: string;
+    value?: IRangeItem[];
+    onChange?: (ranges: IRangeItem[], triggers: ITriggerItem[]) => void;
+    transformDataOnConcat?: (left: IRangeItem, right: IRangeItem) => ITransformOnConcatResult;
+}

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

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

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

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+export interface ISwitchableRowProps extends IUniProps {
+    RC?: string;
+    className?: string;
+    children?: ReactNode;
+    isActive: boolean;
+    setIsActive: (value: boolean) => void;
+    switcherLabel: string;
+    isSwitcherLabelBold?: boolean;
+    isIncludeOuterStyles?: boolean;
+}

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

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

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

@@ -0,0 +1,14 @@
+import type React from 'react';
+import type { IUniProps } from '../../../types/base.interface';
+export interface ISwitcherProps extends IUniProps {
+    isLabelBold?: boolean;
+    disabled?: boolean;
+    isIncludeOuterStyles?: boolean;
+    label?: string;
+    className?: string;
+    isActive?: boolean;
+    hint?: React.ReactNode;
+    hintSide?: string;
+    testId?: string;
+    onChange: (value: boolean, event: any) => void;
+}

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

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

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

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+import type { ISwitcherCheckboxProps } from './SwitcherCheckbox.interface';
+import './SwitcherCheckbox.scss';
+declare function SwitcherCheckbox({ label, hint, items, value, className, isLabelBold, isActive, hintSide, disabled, hideChildren, onSwitcherChange, onChange, }: ISwitcherCheckboxProps): ReactElement;
+export default SwitcherCheckbox;