iguazio.dashboard-react-controls 3.2.21 → 3.2.22

package/dist/components/Wizard/Wizard.d.ts

@@ -1,33 +1,34 @@
 export default Wizard;
 declare function Wizard({ children, className, getActions, isWizardOpen, onWizardResolve, previewText, size, stepsConfig, subTitle, title }: {
     children: any;
-    className?: string;
-    getActions?: any;
+    className?: string | undefined;
+    getActions?: null | undefined;
     isWizardOpen: any;
     onWizardResolve: any;
-    previewText?: string;
-    size?: string;
-    stepsConfig?: any[];
-    subTitle?: any;
+    previewText?: string | undefined;
+    size?: string | undefined;
+    stepsConfig?: never[] | undefined;
+    subTitle?: null | undefined;
     title: any;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace Wizard {
     namespace propTypes {
-        export let children: any;
-        export let className: any;
-        export let getActions: any;
-        export let isWizardOpen: any;
-        export let onWizardResolve: any;
-        export let previewText: any;
+        export let children: PropTypes.Validator<NonNullable<PropTypes.ReactNodeLike>>;
+        export let className: PropTypes.Requireable<string>;
+        export let getActions: PropTypes.Requireable<(...args: any[]) => any>;
+        export let isWizardOpen: PropTypes.Validator<boolean>;
+        export let onWizardResolve: PropTypes.Validator<(...args: any[]) => any>;
+        export let previewText: PropTypes.Requireable<string>;
         export { MODAL_SIZES as size };
         export { WIZARD_STEPS_CONFIG as stepsConfig };
-        export let subTitle: any;
-        export let title: any;
+        export let subTitle: PropTypes.Requireable<string>;
+        export let title: PropTypes.Validator<string>;
     }
     function Step({ children }: {
         children: any;
     }): any;
 }
+import PropTypes from 'prop-types';
 import { MODAL_SIZES } from '../../types';
 import { WIZARD_STEPS_CONFIG } from '../../types';
 //# sourceMappingURL=Wizard.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Wizard.d.ts","sourceRoot":"","sources":["../../../src/lib/components/Wizard/Wizard.jsx"],"names":[],"mappings":";AAgCA;;;;;;;;;;;gBAmKC;;;;;;;;;;;;;;IAeD;;YAAwC;;4BAxLS,aAAa;oCAAb,aAAa"}
+{"version":3,"file":"Wizard.d.ts","sourceRoot":"","sources":["../../../src/lib/components/Wizard/Wizard.jsx"],"names":[],"mappings":";AAgCA;;;;;;;;;;;4CAmKC;;;;;;;;;;;;;;IAeD;;YAAwC;;sBAjMlB,YAAY;4BASe,aAAa;oCAAb,aAAa"}

package/dist/components/Wizard/WizardSteps/WizardSteps.d.ts

@@ -1,16 +1,23 @@
 export default WizardSteps;
 declare function WizardSteps({ activeStepNumber, firstDisabledStepIdx, jumpToStep, steps }: {
     activeStepNumber: any;
-    firstDisabledStepIdx?: any;
+    firstDisabledStepIdx?: null | undefined;
     jumpToStep: any;
     steps: any;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace WizardSteps {
     namespace propTypes {
-        let activeStepNumber: any;
-        let firstDisabledStepIdx: any;
-        let jumpToStep: any;
-        let steps: any;
+        let activeStepNumber: PropTypes.Validator<number>;
+        let firstDisabledStepIdx: PropTypes.Requireable<number>;
+        let jumpToStep: PropTypes.Validator<(...args: any[]) => any>;
+        let steps: PropTypes.Validator<(PropTypes.InferProps<{
+            id: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            hidden: PropTypes.Requireable<boolean>;
+            disabled: PropTypes.Requireable<boolean>;
+            nextIsDisabled: PropTypes.Requireable<boolean>;
+        }> | null | undefined)[]>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=WizardSteps.d.ts.map

package/dist/components/Wizard/WizardSteps/WizardSteps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WizardSteps.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/Wizard/WizardSteps/WizardSteps.jsx"],"names":[],"mappings":";AA2BA;;;;;gBA+BC"}
+{"version":3,"file":"WizardSteps.d.ts","sourceRoot":"","sources":["../../../../src/lib/components/Wizard/WizardSteps/WizardSteps.jsx"],"names":[],"mappings":";AA2BA;;;;;4CA+BC;;;;;;;;;;;;;;;sBAzCqB,YAAY"}

package/dist/elements/ActionsMenuItem/ActionsMenuItem.d.ts

@@ -1,16 +1,17 @@
 export default ActionsMenuItem;
 declare function ActionsMenuItem({ dataItem, index, isIconDisplayed, menuItem }: {
-    dataItem?: {};
+    dataItem?: {} | undefined;
     index: any;
     isIconDisplayed: any;
     menuItem: any;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace ActionsMenuItem {
     namespace propTypes {
-        let dataItem: any;
-        let index: any;
-        let isIconDisplayed: any;
-        let menuItem: any;
+        let dataItem: PropTypes.Requireable<NonNullable<string | object | null | undefined>>;
+        let index: PropTypes.Validator<number>;
+        let isIconDisplayed: PropTypes.Validator<boolean>;
+        let menuItem: PropTypes.Validator<object>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=ActionsMenuItem.d.ts.map

package/dist/elements/ActionsMenuItem/ActionsMenuItem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ActionsMenuItem.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/ActionsMenuItem/ActionsMenuItem.jsx"],"names":[],"mappings":";AA+BA;;;;;gBA4CC"}
+{"version":3,"file":"ActionsMenuItem.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/ActionsMenuItem/ActionsMenuItem.jsx"],"names":[],"mappings":";AA+BA;;;;;4CA4CC;;;;;;;;;sBAvDqB,YAAY"}

package/dist/elements/FormActionButton/FormActionButton.d.ts

@@ -1,23 +1,24 @@
 export default FormActionButton;
 declare function FormActionButton({ disabled, fields, fieldsPath, hidden, id, label, onClick }: {
-    disabled?: boolean;
+    disabled?: boolean | undefined;
     fields: any;
     fieldsPath: any;
-    hidden?: boolean;
-    id?: string;
-    label?: string;
+    hidden?: boolean | undefined;
+    id?: string | undefined;
+    label?: string | undefined;
     onClick: any;
-}, ref: any): JSX.Element;
+}, ref: any): import("react/jsx-runtime").JSX.Element;
 declare namespace FormActionButton {
     let displayName: string;
     namespace propTypes {
-        let disabled: any;
-        let fields: any;
-        let fieldsPath: any;
-        let hidden: any;
-        let id: any;
-        let label: any;
-        let onClick: any;
+        let disabled: PropTypes.Requireable<boolean>;
+        let fields: PropTypes.Validator<NonNullable<PropTypes.InferProps<{}>>>;
+        let fieldsPath: PropTypes.Validator<string>;
+        let hidden: PropTypes.Requireable<boolean>;
+        let id: PropTypes.Requireable<string>;
+        let label: PropTypes.Requireable<string>;
+        let onClick: PropTypes.Validator<(...args: any[]) => any>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=FormActionButton.d.ts.map

package/dist/elements/FormActionButton/FormActionButton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormActionButton.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/FormActionButton/FormActionButton.jsx"],"names":[],"mappings":";AAwBA;;;;;;;;0BA8BC"}
+{"version":3,"file":"FormActionButton.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/FormActionButton/FormActionButton.jsx"],"names":[],"mappings":";AAwBA;;;;;;;;sDA8BC;;;;;;;;;;;;;sBAlCqB,YAAY"}

package/dist/elements/FormRowActions/FormRowActions.d.ts

@@ -1,27 +1,28 @@
 export default FormRowActions;
 declare function FormRowActions({ applyChanges, deleteButtonIsHidden, deleteRow, disabled, discardOrDelete, editingItem, fieldsPath, hidden, index }: {
     applyChanges: any;
-    deleteButtonIsHidden?: boolean;
+    deleteButtonIsHidden?: boolean | undefined;
     deleteRow: any;
-    disabled?: boolean;
+    disabled?: boolean | undefined;
     discardOrDelete: any;
-    editingItem?: any;
+    editingItem?: null | undefined;
     fieldsPath: any;
-    hidden?: boolean;
+    hidden?: boolean | undefined;
     index: any;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace FormRowActions {
     namespace propTypes {
-        export let applyChanges: any;
-        export let deleteButtonIsHidden: any;
-        export let deleteRow: any;
-        export let disabled: any;
-        export let discardOrDelete: any;
+        export let applyChanges: PropTypes.Validator<(...args: any[]) => any>;
+        export let deleteButtonIsHidden: PropTypes.Requireable<boolean>;
+        export let deleteRow: PropTypes.Validator<(...args: any[]) => any>;
+        export let disabled: PropTypes.Requireable<boolean>;
+        export let discardOrDelete: PropTypes.Validator<(...args: any[]) => any>;
         export { FORM_TABLE_EDITING_ITEM as editingItem };
-        export let fieldsPath: any;
-        export let hidden: any;
-        export let index: any;
+        export let fieldsPath: PropTypes.Validator<string>;
+        export let hidden: PropTypes.Requireable<boolean>;
+        export let index: PropTypes.Validator<number>;
     }
 }
+import PropTypes from 'prop-types';
 import { FORM_TABLE_EDITING_ITEM } from '../../types';
 //# sourceMappingURL=FormRowActions.d.ts.map

package/dist/elements/FormRowActions/FormRowActions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FormRowActions.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/FormRowActions/FormRowActions.jsx"],"names":[],"mappings":";AA+BA;;;;;;;;;;gBAgEC;;;;;;;;;;;;;;wCAvEuC,aAAa"}
+{"version":3,"file":"FormRowActions.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/FormRowActions/FormRowActions.jsx"],"names":[],"mappings":";AA+BA;;;;;;;;;;4CAgEC;;;;;;;;;;;;;;sBA3EqB,YAAY;wCAIM,aAAa"}

package/dist/elements/OptionsMenu/OptionsMenu.d.ts

@@ -1,18 +1,19 @@
 export default OptionsMenu;
 declare function OptionsMenu({ children, show, timeout }: {
-    children?: any[];
+    children?: never[] | undefined;
     show: any;
-    timeout?: number;
+    timeout?: number | undefined;
 }, { refInputContainer, validationRulesRef }: {
     refInputContainer: any;
     validationRulesRef: any;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace OptionsMenu {
     let displayName: string;
     namespace propTypes {
-        let children: any;
-        let show: any;
-        let timeout: any;
+        let children: PropTypes.Requireable<(PropTypes.ReactElementLike | null | undefined)[]>;
+        let show: PropTypes.Requireable<boolean>;
+        let timeout: PropTypes.Requireable<number>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=OptionsMenu.d.ts.map

package/dist/elements/OptionsMenu/OptionsMenu.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OptionsMenu.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/OptionsMenu/OptionsMenu.jsx"],"names":[],"mappings":";AAwBA;;;;;;;gBAkCC"}
+{"version":3,"file":"OptionsMenu.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/OptionsMenu/OptionsMenu.jsx"],"names":[],"mappings":";AAwBA;;;;;;;4CAkCC;;;;;;;;;sBAzCqB,YAAY"}

package/dist/elements/SelectOption/SelectOption.d.ts

@@ -2,19 +2,29 @@ export default SelectOption;
 declare function SelectOption({ item, name, onClick, multiple, selectedId, withSelectedIcon }: {
     item: any;
     name: any;
-    onClick?: () => void;
-    multiple?: boolean;
+    onClick?: (() => void) | undefined;
+    multiple?: boolean | undefined;
     selectedId: any;
-    withSelectedIcon?: boolean;
-}): JSX.Element;
+    withSelectedIcon?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace SelectOption {
     namespace propTypes {
-        let name: any;
-        let item: any;
-        let onClick: any;
-        let multiple: any;
-        let selectedId: any;
-        let withSelectedIcon: any;
+        let name: PropTypes.Validator<string>;
+        let item: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+            disabled: PropTypes.Requireable<boolean>;
+            hidden: PropTypes.Requireable<boolean>;
+            icon: PropTypes.Requireable<PropTypes.ReactElementLike>;
+            id: PropTypes.Validator<string>;
+            label: PropTypes.Validator<NonNullable<NonNullable<string | PropTypes.ReactElementLike | null | undefined>>>;
+            labelHtml: PropTypes.Requireable<string>;
+            status: PropTypes.Requireable<string>;
+            subLabel: PropTypes.Requireable<string>;
+        }>>>;
+        let onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        let multiple: PropTypes.Requireable<boolean>;
+        let selectedId: PropTypes.Requireable<string>;
+        let withSelectedIcon: PropTypes.Requireable<boolean>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=SelectOption.d.ts.map

package/dist/elements/SelectOption/SelectOption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SelectOption.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/SelectOption/SelectOption.jsx"],"names":[],"mappings":";AA8BA;;;;;;;gBAoEC"}
+{"version":3,"file":"SelectOption.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/SelectOption/SelectOption.jsx"],"names":[],"mappings":";AA8BA;;;;;;;4CAoEC;;;;;;;;;;;;;;;;;;;;sBAjFqB,YAAY"}

package/dist/elements/TableHead/TableHead.d.ts

@@ -1,20 +1,21 @@
 export default TableHead;
 declare function TableHead({ content, hideActionsMenu, mainRowItemsCount, selectedItem, sortProps }: {
     content: any;
-    hideActionsMenu?: boolean;
+    hideActionsMenu?: boolean | undefined;
     mainRowItemsCount: any;
     selectedItem: any;
-    sortProps?: any;
-}, ref: any): JSX.Element;
+    sortProps?: null | undefined;
+}, ref: any): import("react/jsx-runtime").JSX.Element;
 declare namespace TableHead {
     let displayName: string;
     namespace propTypes {
-        export let content: any;
-        export let hideActionsMenu: any;
-        export let mainRowItemsCount: any;
-        export let selectedItem: any;
+        export let content: PropTypes.Validator<any[]>;
+        export let hideActionsMenu: PropTypes.Requireable<boolean>;
+        export let mainRowItemsCount: PropTypes.Validator<number>;
+        export let selectedItem: PropTypes.Validator<object>;
         export { SORT_PROPS as sortProps };
     }
 }
+import PropTypes from 'prop-types';
 import { SORT_PROPS } from '../../types';
 //# sourceMappingURL=TableHead.d.ts.map

package/dist/elements/TableHead/TableHead.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TableHead.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/TableHead/TableHead.jsx"],"names":[],"mappings":";AA8BA;;;;;;0BAoDC;;;;;;;;;;;2BAtD0B,aAAa"}
+{"version":3,"file":"TableHead.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/TableHead/TableHead.jsx"],"names":[],"mappings":";AA8BA;;;;;;sDAoDC;;;;;;;;;;;sBA9DqB,YAAY;2BAQP,aAAa"}

package/dist/elements/TableLinkCell/TableLinkCell.d.ts

@@ -1,24 +1,25 @@
 export default TableLinkCell;
 declare function TableLinkCell({ cellData, className, item, link, selectItem, selectedItem, showExpandButton, toggleRow }: {
-    cellData?: {};
-    className?: string;
+    cellData?: {} | undefined;
+    className?: string | undefined;
     item: any;
     link: any;
     selectItem: any;
-    selectedItem?: {};
-    showExpandButton?: boolean;
-    toggleRow?: any;
-}): JSX.Element;
+    selectedItem?: {} | undefined;
+    showExpandButton?: boolean | undefined;
+    toggleRow?: null | undefined;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace TableLinkCell {
     namespace propTypes {
-        let cellData: any;
-        let className: any;
-        let item: any;
-        let link: any;
-        let selectItem: any;
-        let selectedItem: any;
-        let showExpandButton: any;
-        let toggleRow: any;
+        let cellData: PropTypes.Requireable<object>;
+        let className: PropTypes.Requireable<string>;
+        let item: PropTypes.Validator<object>;
+        let link: PropTypes.Validator<string>;
+        let selectItem: PropTypes.Validator<(...args: any[]) => any>;
+        let selectedItem: PropTypes.Requireable<object>;
+        let showExpandButton: PropTypes.Requireable<boolean>;
+        let toggleRow: PropTypes.Requireable<(...args: any[]) => any>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=TableLinkCell.d.ts.map

package/dist/elements/TableLinkCell/TableLinkCell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TableLinkCell.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/TableLinkCell/TableLinkCell.jsx"],"names":[],"mappings":";AAkCA;;;;;;;;;gBAsGC"}
+{"version":3,"file":"TableLinkCell.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/TableLinkCell/TableLinkCell.jsx"],"names":[],"mappings":";AAkCA;;;;;;;;;4CAsGC;;;;;;;;;;;;;sBAnHqB,YAAY"}

package/dist/elements/TableTypeCell/TableTypeCell.d.ts

@@ -1,12 +1,13 @@
 export default TableTypeCell;
 declare function TableTypeCell({ cellData, className }: {
     cellData: any;
-    className?: string;
-}): JSX.Element;
+    className?: string | undefined;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace TableTypeCell {
     namespace propTypes {
-        let cellData: any;
-        let className: any;
+        let cellData: PropTypes.Validator<object>;
+        let className: PropTypes.Requireable<string>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=TableTypeCell.d.ts.map

package/dist/elements/TableTypeCell/TableTypeCell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TableTypeCell.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/TableTypeCell/TableTypeCell.jsx"],"names":[],"mappings":";AA2BA;;;gBAsBC"}
+{"version":3,"file":"TableTypeCell.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/TableTypeCell/TableTypeCell.jsx"],"names":[],"mappings":";AA2BA;;;4CAsBC;;;;;;;sBA7BqB,YAAY"}

package/dist/elements/ValidationTemplate/ValidationTemplate.d.ts

@@ -2,11 +2,12 @@ export default ValidationTemplate;
 declare function ValidationTemplate({ valid, validationMessage }: {
     valid: any;
     validationMessage: any;
-}): JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 declare namespace ValidationTemplate {
     namespace propTypes {
-        let valid: any;
-        let validationMessage: any;
+        let valid: PropTypes.Validator<boolean>;
+        let validationMessage: PropTypes.Validator<string>;
     }
 }
+import PropTypes from 'prop-types';
 //# sourceMappingURL=ValidationTemplate.d.ts.map

package/dist/elements/ValidationTemplate/ValidationTemplate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ValidationTemplate.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/ValidationTemplate/ValidationTemplate.jsx"],"names":[],"mappings":";AAyBA;;;gBAeC"}
+{"version":3,"file":"ValidationTemplate.d.ts","sourceRoot":"","sources":["../../../src/lib/elements/ValidationTemplate/ValidationTemplate.jsx"],"names":[],"mappings":";AAyBA;;;4CAeC;;;;;;;sBAvBqB,YAAY"}

package/dist/hooks/useDetails.hook.d.ts

@@ -12,61 +12,67 @@ export function useDetails({ applyDetailsChanges, applyDetailsChangesCallback, f
             commonDetailsStore: any;
             detailsMenu: any;
             detailsPanelClassNames: any;
-            detailsPopUpSelectedTab?: string;
+            detailsPopUpSelectedTab?: string | undefined;
             detailsRef: any;
             detailsStore: any;
             doNotLeavePage: any;
             formRef: any;
-            isDetailsPopUp?: any;
+            isDetailsPopUp?: null | undefined;
             leavePage: any;
             params: any;
             renderHeader: any;
             renderTabsContent: any;
             setBlocker: any;
-            setDetailsPopUpSelectedTab?: any;
+            setDetailsPopUpSelectedTab?: null | undefined;
             shouldDetailsBlock: any;
-            withActionMenu?: boolean;
-        }): JSX.Element;
+            withActionMenu?: boolean | undefined;
+        }): import("react/jsx-runtime").JSX.Element;
         propTypes: {
-            blocker: any;
-            detailsMenu: any;
-            detailsPanelClassNames: any;
-            detailsPopUpSelectedTab: any;
-            detailsRef: any;
-            detailsStore: any;
-            commonDetailsStore: any;
-            doNotLeavePage: any;
-            formRef: any;
-            isDetailsPopUp: any;
-            leavePage: any;
-            params: any;
-            renderHeader: any;
-            renderTabsContent: any;
-            setBlocker: any;
-            setDetailsPopUpSelectedTab: any;
-            shouldDetailsBlock: any;
-            withActionMenu: any;
+            blocker: PropTypes.Validator<object>;
+            detailsMenu: PropTypes.Validator<(PropTypes.InferProps<{
+                id: PropTypes.Validator<string>;
+                label: PropTypes.Validator<string>;
+                hidden: PropTypes.Requireable<boolean>;
+            }> | null | undefined)[]>;
+            detailsPanelClassNames: PropTypes.Validator<string>;
+            detailsPopUpSelectedTab: PropTypes.Requireable<string>;
+            detailsRef: PropTypes.Validator<object>;
+            detailsStore: PropTypes.Validator<object>;
+            commonDetailsStore: PropTypes.Validator<object>;
+            doNotLeavePage: PropTypes.Validator<(...args: any[]) => any>;
+            formRef: PropTypes.Validator<object>;
+            isDetailsPopUp: PropTypes.Requireable<boolean>;
+            leavePage: PropTypes.Validator<(...args: any[]) => any>;
+            params: PropTypes.Validator<object>;
+            renderHeader: PropTypes.Validator<(...args: any[]) => any>;
+            renderTabsContent: PropTypes.Validator<(...args: any[]) => any>;
+            setBlocker: PropTypes.Validator<(...args: any[]) => any>;
+            setDetailsPopUpSelectedTab: PropTypes.Requireable<(...args: any[]) => any>;
+            shouldDetailsBlock: PropTypes.Validator<(...args: any[]) => any>;
+            withActionMenu: PropTypes.Requireable<boolean>;
         };
     };
     applyChanges: () => void;
-    applyChangesRef: import("react").MutableRefObject<undefined>;
+    applyChangesRef: React.MutableRefObject<undefined>;
     blocker: {};
     cancelChanges: () => void;
     detailsPanelClassNames: string;
-    detailsRef: import("react").MutableRefObject<undefined>;
+    detailsRef: React.MutableRefObject<undefined>;
     commonDetailsStore: any;
     doNotLeavePage: () => void;
-    formRef: import("react").MutableRefObject<import("final-form").FormApi<any, Partial<any>>>;
+    formRef: React.MutableRefObject<import("final-form").FormApi<any, Partial<any>>>;
     handleShowWarning: (show: any) => void;
     leavePage: () => void;
-    location: import("react-router-dom").Location<any>;
-    params: Readonly<import("react-router-dom").Params<string>>;
+    location: import("react-router").Location<any>;
+    params: Readonly<import("react-router").Params<string>>;
     removeDetailsInfo: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"commonDetailsStore/removeDetailsPopUpInfoContent"> | import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"commonDetailsStore/removeInfoContent">;
-    setBlocker: import("react").Dispatch<import("react").SetStateAction<{}>>;
+    setBlocker: React.Dispatch<React.SetStateAction<{}>>;
     setDetailsInfo: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "commonDetailsStore/setDetailsPopUpInfoContent"> | import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "commonDetailsStore/setInfoContent">;
     shouldDetailsBlock: ({ currentLocation, nextLocation }: {
         currentLocation: any;
         nextLocation: any;
     }) => boolean;
 };
+import PropTypes from 'prop-types';
+import React from 'react';
 //# sourceMappingURL=useDetails.hook.d.ts.map

package/dist/hooks/useDetails.hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDetails.hook.d.ts","sourceRoot":"","sources":["../../src/lib/hooks/useDetails.hook.jsx"],"names":[],"mappings":"AAyIO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuLN"}
+{"version":3,"file":"useDetails.hook.d.ts","sourceRoot":"","sources":["../../src/lib/hooks/useDetails.hook.jsx"],"names":[],"mappings":"AAyIO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuLN;sBA5SqB,YAAY;kBADuC,OAAO"}