iguazio.dashboard-react-controls 3.2.21 → 3.2.22

package/dist/components/FormChipCell/FormChipCell.d.ts

@@ -7,45 +7,46 @@ declare function FormChipCell({ chipOptions, className, children, delimiter, for
         borderColor: string;
         density: string;
         font: string;
-    };
-    className?: string;
+    } | undefined;
+    className?: string | undefined;
     children: any;
-    delimiter?: any;
+    delimiter?: null | undefined;
     formState: any;
     initialValues: any;
-    isDeletable?: boolean;
-    isEditable?: boolean;
-    label?: any;
+    isDeletable?: boolean | undefined;
+    isEditable?: boolean | undefined;
+    label?: null | undefined;
     name: any;
-    onClick?: () => void;
-    onExitEditModeCallback?: any;
-    shortChips?: boolean;
-    validationRules?: {};
-    validator?: any;
-    visibleChipsMaxLength?: any;
-    withInitialParentWidth?: boolean;
-}): JSX.Element;
+    onClick?: (() => void) | undefined;
+    onExitEditModeCallback?: null | undefined;
+    shortChips?: boolean | undefined;
+    validationRules?: {} | undefined;
+    validator?: null | undefined;
+    visibleChipsMaxLength?: null | undefined;
+    withInitialParentWidth?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace FormChipCell {
     namespace propTypes {
         export { CHIP_OPTIONS as chipOptions };
-        export let children: any;
-        export let className: any;
-        export let delimiter: any;
-        export let formState: any;
-        export let initialValues: any;
-        export let isDeletable: any;
-        export let isEditable: any;
-        export let label: any;
-        export let name: any;
-        export let onClick: any;
-        export let onExitEditModeCallback: any;
-        export let shortChips: any;
-        export let validationRules: any;
-        export let validator: any;
+        export let children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        export let className: PropTypes.Requireable<string>;
+        export let delimiter: PropTypes.Requireable<NonNullable<string | PropTypes.ReactElementLike | null | undefined>>;
+        export let formState: PropTypes.Validator<object>;
+        export let initialValues: PropTypes.Validator<object>;
+        export let isDeletable: PropTypes.Requireable<boolean>;
+        export let isEditable: PropTypes.Requireable<boolean>;
+        export let label: PropTypes.Requireable<string>;
+        export let name: PropTypes.Validator<string>;
+        export let onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onExitEditModeCallback: PropTypes.Requireable<(...args: any[]) => any>;
+        export let shortChips: PropTypes.Requireable<boolean>;
+        export let validationRules: PropTypes.Requireable<object>;
+        export let validator: PropTypes.Requireable<(...args: any[]) => any>;
         export { VISIBLE_CHIPS_MAX_LENGTH as visibleChipsMaxLength };
-        export let withInitialParentWidth: any;
+        export let withInitialParentWidth: PropTypes.Requireable<boolean>;
     }
 }
 import { CHIP_OPTIONS } from '../../types';
+import PropTypes from 'prop-types';
 import { VISIBLE_CHIPS_MAX_LENGTH } from '../../types';
 //# sourceMappingURL=FormChipCell.d.ts.map

package/dist/components/FormChipCell/FormChipCell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormChipCell.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormChipCell/FormChipCell.jsx"],"names":[],"mappings":";AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;gBA+WC;;;;;;;;;;;;;;;;;;;;;;6BAzXsD,aAAa;yCAAb,aAAa"}
+{"version":3,"file":"FormChipCell.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormChipCell/FormChipCell.jsx"],"names":[],"mappings":";AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;4CA+WC;;;;;;;;;;;;;;;;;;;;;;6BAzXsD,aAAa;sBAJ9C,YAAY;yCAIqB,aAAa"}

package/dist/components/FormChipCell/FormChipCellView.d.ts

@@ -7,7 +7,7 @@ declare function FormChipCellView({ chipOptions, chipSizeIsRecalculated, setChip
         borderColor: string;
         density: string;
         font: string;
-    };
+    } | undefined;
     chipSizeIsRecalculated: any;
     setChipSizeIsRecalculated: any;
     children: any;
@@ -18,51 +18,52 @@ declare function FormChipCellView({ chipOptions, chipSizeIsRecalculated, setChip
     handleRemoveChip: any;
     handleShowElements: any;
     handleToEditMode: any;
-    isDeletable?: boolean;
-    isEditable?: boolean;
+    isDeletable?: boolean | undefined;
+    isEditable?: boolean | undefined;
     name: any;
     setChipsSizes: any;
     setEditConfig: any;
-    shortChips?: boolean;
+    shortChips?: boolean | undefined;
     showChips: any;
     showHiddenChips: any;
     validateFields: any;
-    validationRules?: {};
-    visibleChipsMaxLength?: any;
+    validationRules?: {} | undefined;
+    visibleChipsMaxLength?: null | undefined;
 }, { chipsCellRef, chipsWrapperRef, hiddenChipsCounterRef, hiddenChipsPopUpRef }: {
     chipsCellRef: any;
     chipsWrapperRef: any;
     hiddenChipsCounterRef: any;
     hiddenChipsPopUpRef: any;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace FormChipCellView {
     let displayName: string;
     namespace propTypes {
         export { CHIP_OPTIONS as chipOptions };
-        export let chipSizeIsRecalculated: any;
-        export let setChipSizeIsRecalculated: any;
-        export let children: any;
-        export let chips: any;
-        export let editConfig: any;
-        export let formState: any;
-        export let handleAddNewChip: any;
-        export let handleEditChip: any;
-        export let handleRemoveChip: any;
-        export let handleShowElements: any;
-        export let handleToEditMode: any;
-        export let isDeletable: any;
-        export let isEditable: any;
-        export let name: any;
-        export let setChipsSizes: any;
-        export let setEditConfig: any;
-        export let shortChips: any;
-        export let showChips: any;
-        export let showHiddenChips: any;
-        export let validateFields: any;
-        export let validationRules: any;
+        export let chipSizeIsRecalculated: PropTypes.Validator<boolean>;
+        export let setChipSizeIsRecalculated: PropTypes.Validator<(...args: any[]) => any>;
+        export let children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        export let chips: PropTypes.Validator<object>;
+        export let editConfig: PropTypes.Validator<object>;
+        export let formState: PropTypes.Validator<object>;
+        export let handleAddNewChip: PropTypes.Validator<(...args: any[]) => any>;
+        export let handleEditChip: PropTypes.Validator<(...args: any[]) => any>;
+        export let handleRemoveChip: PropTypes.Validator<(...args: any[]) => any>;
+        export let handleShowElements: PropTypes.Validator<(...args: any[]) => any>;
+        export let handleToEditMode: PropTypes.Validator<(...args: any[]) => any>;
+        export let isDeletable: PropTypes.Requireable<boolean>;
+        export let isEditable: PropTypes.Requireable<boolean>;
+        export let name: PropTypes.Validator<string>;
+        export let setChipsSizes: PropTypes.Validator<(...args: any[]) => any>;
+        export let setEditConfig: PropTypes.Validator<(...args: any[]) => any>;
+        export let shortChips: PropTypes.Requireable<boolean>;
+        export let showChips: PropTypes.Validator<boolean>;
+        export let showHiddenChips: PropTypes.Validator<boolean>;
+        export let validateFields: PropTypes.Validator<(...args: any[]) => any>;
+        export let validationRules: PropTypes.Requireable<object>;
         export { VISIBLE_CHIPS_MAX_LENGTH as visibleChipsMaxLength };
     }
 }
 import { CHIP_OPTIONS } from '../../types';
+import PropTypes from 'prop-types';
 import { VISIBLE_CHIPS_MAX_LENGTH } from '../../types';
 //# sourceMappingURL=FormChipCellView.d.ts.map

package/dist/components/FormChipCell/FormChipCellView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormChipCellView.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormChipCell/FormChipCellView.jsx"],"names":[],"mappings":";AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmLC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAzLsD,aAAa;yCAAb,aAAa"}
+{"version":3,"file":"FormChipCellView.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormChipCell/FormChipCellView.jsx"],"names":[],"mappings":";AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4CAmLC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAzLsD,aAAa;sBAV9C,YAAY;yCAUqB,aAAa"}

package/dist/components/FormChipCell/HiddenChipsBlock/HiddenChipsBlock.d.ts

@@ -4,19 +4,28 @@ declare function HiddenChipsBlock({ chipClassNames, chipOptions, chips, handleSh
     chipOptions: any;
     chips: any;
     handleShowElements: any;
-    textOverflowEllipsis?: boolean;
+    textOverflowEllipsis?: boolean | undefined;
 }, { hiddenChipsCounterRef, hiddenChipsPopUpRef }: {
     hiddenChipsCounterRef: any;
     hiddenChipsPopUpRef: any;
-}): import("react").ReactPortal;
+}): React.ReactPortal;
 declare namespace HiddenChipsBlock {
     let displayName: string;
     namespace propTypes {
-        let chipClassNames: any;
-        let chipOptions: any;
-        let chips: any;
-        let handleShowElements: any;
-        let textOverflowEllipsis: any;
+        let chipClassNames: PropTypes.Validator<string>;
+        let chipOptions: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            background: PropTypes.Requireable<string>;
+            boldValue: PropTypes.Requireable<boolean>;
+            borderColor: PropTypes.Requireable<string>;
+            density: PropTypes.Requireable<string>;
+            font: PropTypes.Requireable<string>;
+            borderRadius: PropTypes.Requireable<string>;
+        }>>>;
+        let chips: PropTypes.Validator<any[]>;
+        let handleShowElements: PropTypes.Validator<(...args: any[]) => any>;
+        let textOverflowEllipsis: PropTypes.Requireable<boolean>;
     }
 }
+import React from 'react';
+import PropTypes from 'prop-types';
 //# sourceMappingURL=HiddenChipsBlock.d.ts.map

package/dist/components/FormChipCell/HiddenChipsBlock/HiddenChipsBlock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HiddenChipsBlock.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/FormChipCell/HiddenChipsBlock/HiddenChipsBlock.jsx"],"names":[],"mappings":";AA2BA;;;;;;;;;gCA2EC"}
+{"version":3,"file":"HiddenChipsBlock.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/FormChipCell/HiddenChipsBlock/HiddenChipsBlock.jsx"],"names":[],"mappings":";AA2BA;;;;;;;;;sBA2EC;;;;;;;;;;;;;;;;;;kBAtF4C,OAAO;sBAE9B,YAAY"}

package/dist/components/FormChipCell/NewChipForm/NewChipForm.d.ts

@@ -3,7 +3,7 @@ declare function NewChipForm({ chip, chipIndex, chipOptions, className, editConf
     chip: any;
     chipIndex: any;
     chipOptions: any;
-    className?: string;
+    className?: string | undefined;
     editConfig: any;
     handleRemoveChip: any;
     isDeletable: any;
@@ -13,27 +13,35 @@ declare function NewChipForm({ chip, chipIndex, chipOptions, className, editConf
     onChange: any;
     setChipSizeIsRecalculated: any;
     setEditConfig: any;
-    validationRules?: {};
+    validationRules?: {} | undefined;
     valueName: any;
-}, ref: any): JSX.Element;
+}, ref: any): import("react/jsx-runtime").JSX.Element;
 declare namespace NewChipForm {
     let displayName: string;
     namespace propTypes {
-        let chip: any;
-        let chipIndex: any;
-        let chipOptions: any;
-        let className: any;
-        let editConfig: any;
-        let handleRemoveChip: any;
-        let isDeletable: any;
-        let isEditable: any;
-        let keyName: any;
-        let meta: any;
-        let onChange: any;
-        let setChipSizeIsRecalculated: any;
-        let setEditConfig: any;
-        let validationRules: any;
-        let valueName: any;
+        let chip: PropTypes.Validator<object>;
+        let chipIndex: PropTypes.Validator<number>;
+        let chipOptions: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            background: PropTypes.Requireable<string>;
+            boldValue: PropTypes.Requireable<boolean>;
+            borderColor: PropTypes.Requireable<string>;
+            density: PropTypes.Requireable<string>;
+            font: PropTypes.Requireable<string>;
+            borderRadius: PropTypes.Requireable<string>;
+        }>>>;
+        let className: PropTypes.Requireable<string>;
+        let editConfig: PropTypes.Validator<object>;
+        let handleRemoveChip: PropTypes.Validator<(...args: any[]) => any>;
+        let isDeletable: PropTypes.Validator<boolean>;
+        let isEditable: PropTypes.Validator<boolean>;
+        let keyName: PropTypes.Validator<string>;
+        let meta: PropTypes.Validator<object>;
+        let onChange: PropTypes.Validator<(...args: any[]) => any>;
+        let setChipSizeIsRecalculated: PropTypes.Validator<(...args: any[]) => any>;
+        let setEditConfig: PropTypes.Validator<(...args: any[]) => any>;
+        let validationRules: PropTypes.Requireable<object>;
+        let valueName: PropTypes.Validator<string>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=NewChipForm.d.ts.map

package/dist/components/FormChipCell/NewChipForm/NewChipForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NewChipForm.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/FormChipCell/NewChipForm/NewChipForm.jsx"],"names":[],"mappings":";AA6CA;;;;;;;;;;;;;;;;0BAmbC"}
+{"version":3,"file":"NewChipForm.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/FormChipCell/NewChipForm/NewChipForm.jsx"],"names":[],"mappings":";AA6CA;;;;;;;;;;;;;;;;sDAmbC;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAxcqB,YAAY"}

package/dist/components/FormChipCell/NewChipInput/NewChipInput.d.ts

@@ -4,13 +4,14 @@ declare function NewChipInput({ name, onChange, onFocus, ...inputProps }: {
     name: any;
     onChange: any;
     onFocus: any;
-}, ref: any): JSX.Element;
+}, ref: any): import("react/jsx-runtime").JSX.Element;
 declare namespace NewChipInput {
     let displayName: string;
     namespace propTypes {
-        let name: any;
-        let onChange: any;
-        let onFocus: any;
+        let name: PropTypes.Validator<string>;
+        let onChange: PropTypes.Validator<(...args: any[]) => any>;
+        let onFocus: PropTypes.Validator<(...args: any[]) => any>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=NewChipInput.d.ts.map

package/dist/components/FormChipCell/NewChipInput/NewChipInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NewChipInput.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/FormChipCell/NewChipInput/NewChipInput.jsx"],"names":[],"mappings":";AAoBA;;;;;0BA+BC"}
+{"version":3,"file":"NewChipInput.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/FormChipCell/NewChipInput/NewChipInput.jsx"],"names":[],"mappings":";AAoBA;;;;;sDA+BC;;;;;;;;;sBAlCqB,YAAY"}

package/dist/components/FormCombobox/FormCombobox.d.ts

@@ -1,56 +1,61 @@
 export default FormCombobox;
 declare function FormCombobox({ comboboxClassName, density, disabled, hideSearchInput, inputDefaultValue, inputPlaceholder, invalidText, label, maxSuggestedMatches, name, onBlur, onChange, onFocus, required, rules, selectDefaultValue, selectOptions, selectPlaceholder, suggestionList, validator, withoutBorder }: {
-    comboboxClassName?: string;
-    density?: string;
-    disabled?: boolean;
-    hideSearchInput?: boolean;
-    inputDefaultValue?: string;
-    inputPlaceholder?: string;
-    invalidText?: string;
-    label?: string;
-    maxSuggestedMatches?: number;
+    comboboxClassName?: string | undefined;
+    density?: string | undefined;
+    disabled?: boolean | undefined;
+    hideSearchInput?: boolean | undefined;
+    inputDefaultValue?: string | undefined;
+    inputPlaceholder?: string | undefined;
+    invalidText?: string | undefined;
+    label?: string | undefined;
+    maxSuggestedMatches?: number | undefined;
     name: any;
-    onBlur?: any;
-    onChange?: any;
-    onFocus?: any;
-    required?: boolean;
-    rules?: any[];
+    onBlur?: null | undefined;
+    onChange?: null | undefined;
+    onFocus?: null | undefined;
+    required?: boolean | undefined;
+    rules?: never[] | undefined;
     selectDefaultValue?: {
         label: string;
         id: string;
         className: string;
-    };
+    } | undefined;
     selectOptions: any;
-    selectPlaceholder?: string;
-    suggestionList?: any[];
-    validator?: any;
-    withoutBorder?: boolean;
-}): JSX.Element;
+    selectPlaceholder?: string | undefined;
+    suggestionList?: never[] | undefined;
+    validator?: null | undefined;
+    withoutBorder?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace FormCombobox {
     namespace propTypes {
-        export let comboboxClassName: any;
+        export let comboboxClassName: PropTypes.Requireable<string>;
         export { DENSITY as density };
-        export let disabled: any;
-        export let hideSearchInput: any;
-        export let inputDefaultValue: any;
-        export let inputPlaceholder: any;
-        export let invalidText: any;
-        export let label: any;
-        export let maxSuggestedMatches: any;
-        export let name: any;
-        export let onBlur: any;
-        export let onChange: any;
-        export let onFocus: any;
-        export let required: any;
-        export let rules: any;
-        export let selectDefaultValue: any;
-        export let selectOptions: any;
-        export let selectPlaceholder: any;
+        export let disabled: PropTypes.Requireable<boolean>;
+        export let hideSearchInput: PropTypes.Requireable<boolean>;
+        export let inputDefaultValue: PropTypes.Requireable<string>;
+        export let inputPlaceholder: PropTypes.Requireable<string>;
+        export let invalidText: PropTypes.Requireable<string>;
+        export let label: PropTypes.Requireable<string>;
+        export let maxSuggestedMatches: PropTypes.Requireable<number>;
+        export let name: PropTypes.Validator<string>;
+        export let onBlur: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        export let onFocus: PropTypes.Requireable<(...args: any[]) => any>;
+        export let required: PropTypes.Requireable<boolean>;
+        export let rules: PropTypes.Requireable<any[]>;
+        export let selectDefaultValue: PropTypes.Requireable<PropTypes.InferProps<{}>>;
+        export let selectOptions: PropTypes.Validator<(PropTypes.InferProps<{
+            className: PropTypes.Requireable<string>;
+            id: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+        }> | null | undefined)[]>;
+        export let selectPlaceholder: PropTypes.Requireable<string>;
         export { COMBOBOX_SUGGESTION_LIST as suggestionList };
-        export let validator: any;
-        export let withoutBorder: any;
+        export let validator: PropTypes.Requireable<(...args: any[]) => any>;
+        export let withoutBorder: PropTypes.Requireable<boolean>;
     }
 }
+import PropTypes from 'prop-types';
 import { DENSITY } from '../../types';
 import { COMBOBOX_SUGGESTION_LIST } from '../../types';
 //# sourceMappingURL=FormCombobox.d.ts.map

package/dist/components/FormCombobox/FormCombobox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormCombobox.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormCombobox/FormCombobox.jsx"],"names":[],"mappings":";AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;gBAgcC;;;;;;;;;;;;;;;;;;;;;;;;;;wBAzc0E,aAAa;yCAAb,aAAa"}
+{"version":3,"file":"FormCombobox.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormCombobox/FormCombobox.jsx"],"names":[],"mappings":";AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;4CAgcC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBApdqB,YAAY;wBAWyC,aAAa;yCAAb,aAAa"}

package/dist/components/FormCombobox/FormCombobox.stories.d.ts

@@ -3,10 +3,62 @@ declare namespace _default {
     export { FormCombobox as component };
 }
 export default _default;
-export const Dense: any;
-export const Normal: any;
-export const Medium: any;
-export const Chunky: any;
-export const withDefaultValue: any;
-export const withSuggestions: any;
+export function Dense(args: any): import("react/jsx-runtime").JSX.Element;
+export namespace Dense {
+    namespace args {
+        let density: string;
+        let name: string;
+        let selectOptions: {
+            className: string;
+            label: string;
+            id: string;
+        }[];
+    }
+}
+export function Normal(args: any): import("react/jsx-runtime").JSX.Element;
+export namespace Normal {
+    export namespace args_1 {
+        let density_1: string;
+        export { density_1 as density };
+    }
+    export { args_1 as args };
+}
+export function Medium(args: any): import("react/jsx-runtime").JSX.Element;
+export namespace Medium {
+    export namespace args_2 {
+        let density_2: string;
+        export { density_2 as density };
+    }
+    export { args_2 as args };
+}
+export function Chunky(args: any): import("react/jsx-runtime").JSX.Element;
+export namespace Chunky {
+    export namespace args_3 {
+        let density_3: string;
+        export { density_3 as density };
+    }
+    export { args_3 as args };
+}
+export function withDefaultValue(args: any): import("react/jsx-runtime").JSX.Element;
+export namespace withDefaultValue {
+    export namespace args_4 {
+        namespace selectDefaultValue {
+            let className: string;
+            let label: string;
+            let id: string;
+        }
+        let inputDefaultValue: string;
+    }
+    export { args_4 as args };
+}
+export function withSuggestions(args: any): import("react/jsx-runtime").JSX.Element;
+export namespace withSuggestions {
+    export namespace args_5 {
+        let suggestionList: {
+            label: string;
+            id: string;
+        }[];
+    }
+    export { args_5 as args };
+}
 //# sourceMappingURL=FormCombobox.stories.d.ts.map

package/dist/components/FormCombobox/FormCombobox.stories.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormCombobox.stories.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormCombobox/FormCombobox.stories.js"],"names":[],"mappings":";;;;;AA4CA,wBAAsC;AAMtC,yBAAuC;AAMvC,yBAAuC;AAMvC,yBAAuC;AAMvC,mCAAiD;AAWjD,kCAAgD"}
+{"version":3,"file":"FormCombobox.stories.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormCombobox/FormCombobox.stories.js"],"names":[],"mappings":";;;;;AA0CA,0EAA8F;;;;;;;;;;;;AAA9F,2EAA8F;;;;;;;;AAA9F,2EAA8F;;;;;;;;AAA9F,2EAA8F;;;;;;;;AAA9F,qFAA8F;;;;;;;;;;;;AAA9F,oFAA8F"}

package/dist/components/FormInput/FormInput.d.ts

@@ -1,3 +1,79 @@
-declare const _default: any;
+declare const _default: React.MemoExoticComponent<{
+    ({ async, className, customRequiredLabel, density, disabled, focused, iconClass, iconClick, inputIcon, invalidText, label, link, name, onBlur, onFocus, onKeyDown, pattern, required, onValidationError, suggestionList, step, tip, type, validationRules: rules, validator, withoutBorder, ...inputProps }: {
+        [x: string]: any;
+        async?: boolean | undefined;
+        className?: string | undefined;
+        customRequiredLabel?: string | undefined;
+        density?: string | undefined;
+        disabled?: boolean | undefined;
+        focused?: boolean | undefined;
+        iconClass?: string | undefined;
+        iconClick?: (() => void) | undefined;
+        inputIcon?: null | undefined;
+        invalidText?: string | undefined;
+        label?: string | undefined;
+        link?: {
+            show: string;
+            value: string;
+        } | undefined;
+        name: any;
+        onBlur?: (() => void) | undefined;
+        onFocus: any;
+        onKeyDown?: (() => void) | undefined;
+        pattern?: null | undefined;
+        required?: boolean | undefined;
+        onValidationError?: (() => void) | undefined;
+        suggestionList?: never[] | undefined;
+        step?: string | undefined;
+        tip?: string | undefined;
+        type?: string | undefined;
+        validationRules?: never[] | undefined;
+        validator?: (() => void) | undefined;
+        withoutBorder?: boolean | undefined;
+    }, ref: any): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+    propTypes: {
+        async: PropTypes.Requireable<boolean>;
+        className: PropTypes.Requireable<string>;
+        customRequiredLabel: PropTypes.Requireable<string>;
+        density: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        focused: PropTypes.Requireable<boolean>;
+        iconClass: PropTypes.Requireable<string>;
+        iconClick: PropTypes.Requireable<(...args: any[]) => any>;
+        inputIcon: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        invalidText: PropTypes.Requireable<string>;
+        label: PropTypes.Requireable<string>;
+        link: PropTypes.Requireable<PropTypes.InferProps<{
+            show: PropTypes.Requireable<NonNullable<string | boolean | null | undefined>>;
+            url: PropTypes.Requireable<string>;
+        }>>;
+        max: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        min: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        name: PropTypes.Validator<string>;
+        onBlur: PropTypes.Requireable<(...args: any[]) => any>;
+        onFocus: PropTypes.Requireable<(...args: any[]) => any>;
+        onKeyDown: PropTypes.Requireable<(...args: any[]) => any>;
+        onValidationError: PropTypes.Requireable<(...args: any[]) => any>;
+        pattern: PropTypes.Requireable<string>;
+        placeholder: PropTypes.Requireable<string>;
+        required: PropTypes.Requireable<boolean>;
+        step: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        suggestionList: PropTypes.Requireable<(string | null | undefined)[]>;
+        tip: PropTypes.Requireable<NonNullable<string | PropTypes.ReactElementLike | null | undefined>>;
+        type: PropTypes.Requireable<string>;
+        validationRules: PropTypes.Requireable<(PropTypes.InferProps<{
+            name: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            pattern: PropTypes.Validator<NonNullable<NonNullable<RegExp | ((...args: any[]) => any) | null | undefined>>>;
+            isValid: PropTypes.Requireable<boolean>;
+        }> | null | undefined)[]>;
+        validator: PropTypes.Requireable<(...args: any[]) => any>;
+        value: PropTypes.Requireable<NonNullable<string | number | null | undefined>>;
+        withoutBorder: PropTypes.Requireable<boolean>;
+    };
+}>;
 export default _default;
+import PropTypes from 'prop-types';
+import React from 'react';
 //# sourceMappingURL=FormInput.d.ts.map

package/dist/components/FormInput/FormInput.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormInput.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormInput/FormInput.jsx"],"names":[],"mappings":""}
+{"version":3,"file":"FormInput.d.ts","sourceRoot":"","sources":["../../../src/lib/components/FormInput/FormInput.jsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAiBsB,YAAY;kBAD6B,OAAO"}