@gridsuite/commons-ui 0.47.0 → 0.49.0

package/dist/components/AuthenticationRouter/AuthenticationRouter.d.ts

@@ -0,0 +1,10 @@
+export default AuthenticationRouter;
+declare function AuthenticationRouter({ userManager, signInCallbackError, authenticationRouterError, showAuthenticationRouterLogin, dispatch, navigate, location, }: {
+    userManager: any;
+    signInCallbackError: any;
+    authenticationRouterError: any;
+    showAuthenticationRouterLogin: any;
+    dispatch: any;
+    navigate: any;
+    location: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/AuthenticationRouter/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./AuthenticationRouter";

package/dist/components/CardErrorBoundary/card-error-boundary.d.ts

@@ -0,0 +1,18 @@
+export default CardErrorBoundary;
+declare class CardErrorBoundary extends React.Component<any, any, any> {
+    static getDerivedStateFromError(error: any): {
+        hasError: boolean;
+        error: any;
+    };
+    constructor(props: any);
+    state: {
+        hasError: boolean;
+        expanded: boolean;
+        error: undefined;
+    };
+    handleExpandClick(): void;
+    handleReloadClick(): void;
+    componentDidCatch(error: any, errorInfo: any): void;
+    render(): any;
+}
+import React from 'react';

package/dist/components/CardErrorBoundary/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./card-error-boundary";

package/dist/components/DirectoryItemSelector/directory-item-selector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2022, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+/// <reference types="node" />
+import { FunctionComponent } from 'react';
+import { UUID } from 'crypto';
+interface DirectoryItemSelectorProps {
+    open: boolean;
+    onClose: any;
+    types: string[];
+    equipmentTypes?: string[];
+    title: string;
+    itemFilter?: any;
+    fetchDirectoryContent: (directoryUuid: UUID, elementTypes: string[]) => Promise<any>;
+    fetchRootFolders: (types: string[]) => Promise<any>;
+    fetchElementsInfos: (ids: UUID[], elementTypes: string[], equipmentTypes?: string[]) => Promise<any>;
+    classes?: any;
+    contentText?: string;
+    defaultExpanded?: string[];
+    defaultSelected?: string[];
+    validationButtonText?: string;
+    className?: string;
+    cancelButtonProps?: any;
+    onlyLeaves?: boolean;
+    multiselect?: boolean;
+}
+declare const DirectoryItemSelector: FunctionComponent<DirectoryItemSelectorProps>;
+export default DirectoryItemSelector;

package/dist/components/DirectoryItemSelector/directory-item-selector.js

@@ -0,0 +1,270 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import { useState, useRef, useCallback, useEffect } from "react";
+import { elementType, getFileIcon } from "../../utils/ElementType.js";
+import { useSnackMessage } from "../../hooks/useSnackMessage.js";
+import TreeViewFinder from "../TreeViewFinder/TreeViewFinder.js";
+const styles = {
+  icon: (theme) => ({
+    marginRight: theme.spacing(1),
+    width: "18px",
+    height: "18px"
+  })
+};
+const DirectoryItemSelector = ({
+  open,
+  onClose,
+  types,
+  equipmentTypes,
+  title,
+  itemFilter,
+  fetchDirectoryContent,
+  fetchRootFolders,
+  fetchElementsInfos,
+  classes,
+  contentText,
+  defaultExpanded,
+  defaultSelected,
+  validationButtonText,
+  className,
+  cancelButtonProps,
+  onlyLeaves = true,
+  multiselect = true
+}) => {
+  const [data, setData] = useState([]);
+  const [rootDirectories, setRootDirectories] = useState([]);
+  const nodeMap = useRef({});
+  const dataRef = useRef([]);
+  dataRef.current = data;
+  const rootsRef = useRef([]);
+  rootsRef.current = rootDirectories;
+  const { snackError } = useSnackMessage();
+  const openRef = useRef();
+  openRef.current = open;
+  const contentFilter = useCallback(
+    () => /* @__PURE__ */ new Set([elementType.DIRECTORY, ...types]),
+    [types]
+  );
+  const convertChildren = useCallback((children) => {
+    return children.map((e) => {
+      return {
+        id: e.elementUuid,
+        name: e.elementName,
+        specificMetadata: e.specificMetadata,
+        icon: getFileIcon(e.type, styles.icon),
+        children: e.type === elementType.DIRECTORY ? convertChildren(e.children) : void 0,
+        childrenCount: e.type === elementType.DIRECTORY ? e.subdirectoriesCount : void 0
+      };
+    });
+  }, []);
+  const convertRoots = useCallback(
+    (newRoots) => {
+      return newRoots.map((e) => {
+        return {
+          id: e.elementUuid,
+          name: e.elementName,
+          icon: getFileIcon(e.type, styles.icon),
+          children: e.type === elementType.DIRECTORY ? convertChildren(
+            nodeMap.current[e.elementUuid].children
+          ) : void 0,
+          childrenCount: e.type === elementType.DIRECTORY ? e.subdirectoriesCount : void 0
+        };
+      });
+    },
+    [convertChildren]
+  );
+  const addToDirectory = useCallback(
+    (nodeId, content) => {
+      let [nrs, mdr] = updatedTree(
+        rootsRef.current,
+        nodeMap.current,
+        nodeId,
+        content
+      );
+      setRootDirectories(nrs);
+      nodeMap.current = mdr;
+      setData(convertRoots(nrs));
+    },
+    [convertRoots]
+  );
+  const updateRootDirectories = useCallback(() => {
+    fetchRootFolders(types).then((data2) => {
+      let [nrs, mdr] = updatedTree(
+        rootsRef.current,
+        nodeMap.current,
+        null,
+        data2
+      );
+      setRootDirectories(nrs);
+      nodeMap.current = mdr;
+      setData(convertRoots(nrs));
+    }).catch((error) => {
+      snackError({
+        messageTxt: error.message,
+        headerId: "DirectoryItemSelector"
+      });
+    });
+  }, [convertRoots, types, snackError, fetchRootFolders]);
+  useEffect(() => {
+    if (open) {
+      updateRootDirectories();
+    }
+  }, [open, updateRootDirectories]);
+  const fetchDirectory = useCallback(
+    (nodeId) => {
+      fetchDirectoryContent(nodeId, types).then((children) => {
+        const childrenMatchedTypes = children.filter(
+          (item) => contentFilter().has(item.type)
+        );
+        if (childrenMatchedTypes.length > 0 && equipmentTypes && equipmentTypes.length > 0) {
+          fetchElementsInfos(
+            childrenMatchedTypes.map((e) => e.elementUuid),
+            types,
+            equipmentTypes
+          ).then((childrenWithMetadata) => {
+            const children2 = itemFilter ? childrenWithMetadata.filter((val) => {
+              if (val.type === elementType.DIRECTORY) {
+                return true;
+              }
+              return itemFilter(val);
+            }) : childrenWithMetadata;
+            addToDirectory(nodeId, children2);
+          });
+        } else {
+          addToDirectory(nodeId, childrenMatchedTypes);
+        }
+      }).catch((error) => {
+        console.warn(
+          `Could not update subs (and content) of '${nodeId}' : ${error.message}`
+        );
+      });
+    },
+    [
+      types,
+      equipmentTypes,
+      itemFilter,
+      contentFilter,
+      addToDirectory,
+      fetchDirectoryContent,
+      fetchElementsInfos
+    ]
+  );
+  function sortHandlingDirectories(a, b) {
+    if (a.children && !b.children) {
+      return -1;
+    } else if (b.children && !a.children) {
+      return 1;
+    }
+    return a.name.localeCompare(b.name);
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(
+    TreeViewFinder,
+    {
+      multiselect,
+      onTreeBrowse: fetchDirectory,
+      data,
+      onlyLeaves,
+      sortMethod: sortHandlingDirectories,
+      title,
+      onClose,
+      open,
+      classes,
+      contentText,
+      defaultExpanded,
+      defaultSelected,
+      validationButtonText,
+      className,
+      cancelButtonProps
+    }
+  ) });
+};
+function updatedTree(prevRoots, prevMap, nodeId, children) {
+  var _a;
+  const nextChildren = children.sort((a, b) => a.elementName.localeCompare(b.elementName)).map((n) => {
+    let pn = prevMap[n.elementUuid];
+    if (!pn) {
+      return { ...n, children: [], parentUuid: nodeId };
+    } else if (n.elementName === pn.elementName && sameRights(n.accessRights, pn.accessRights) && n.subdirectoriesCount === pn.subdirectoriesCount && nodeId === pn.parentUuid) {
+      return pn;
+    } else {
+      if (pn.parentUuid !== nodeId) {
+        console.warn("reparent " + pn.parentUuid + " -> " + nodeId);
+      }
+      return {
+        ...pn,
+        elementName: n.elementName,
+        accessRights: n.accessRights,
+        subdirectoriesCount: n.subdirectoriesCount,
+        parentUuid: nodeId
+      };
+    }
+  });
+  const prevChildren = nodeId ? (_a = prevMap[nodeId]) == null ? void 0 : _a.children : prevRoots;
+  if ((prevChildren == null ? void 0 : prevChildren.length) === nextChildren.length && prevChildren.every((e, i) => e === nextChildren[i])) {
+    return [prevRoots, prevMap];
+  }
+  let nextUuids = new Set(children ? children.map((n) => n.elementUuid) : []);
+  let prevUuids = prevChildren ? prevChildren.map((n) => n.elementUuid) : [];
+  let mayNodeId = nodeId ? [nodeId] : [];
+  let nonCopyUuids = /* @__PURE__ */ new Set([
+    ...nextUuids,
+    ...mayNodeId,
+    ...Array.prototype.concat(
+      ...prevUuids.filter((u) => !nextUuids.has(u)).map(
+        (u) => flattenDownNodes(prevMap[u], (n) => n.children).map(
+          (n) => n.elementUuid
+        )
+      )
+    )
+  ]);
+  const prevNode = nodeId ? prevMap[nodeId] : {};
+  const nextNode = {
+    elementUuid: nodeId,
+    parentUuid: null,
+    ...prevNode,
+    children: nextChildren,
+    subdirectoriesCount: nextChildren.length
+  };
+  const nextMap = Object.fromEntries([
+    ...Object.entries(prevMap).filter(([k, v], i) => !nonCopyUuids.has(k)),
+    ...nextChildren.map((n) => [n.elementUuid, n]),
+    ...refreshedUpNodes(prevMap, nextNode).map((n) => [n.elementUuid, n])
+  ]);
+  const nextRoots = nodeId === null ? nextChildren : prevRoots.map((r) => nextMap[r.elementUuid]);
+  return [nextRoots, nextMap];
+}
+function sameRights(a, b) {
+  if (!a && !b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  return a.isPrivate === b.isPrivate;
+}
+function flattenDownNodes(n, cef) {
+  const subs = cef(n);
+  if (subs.length === 0) {
+    return [n];
+  }
+  return Array.prototype.concat(
+    [n],
+    ...subs.map((sn) => flattenDownNodes(sn, cef))
+  );
+}
+function refreshedUpNodes(m, nn) {
+  if (!(nn == null ? void 0 : nn.elementUuid)) {
+    return [];
+  }
+  if (nn.parentUuid === null) {
+    return [nn];
+  }
+  const parent = m[nn.parentUuid];
+  const nextChildren = parent.children.map(
+    (c) => c.elementUuid === nn.elementUuid ? nn : c
+  );
+  const nextParent = { ...parent, children: nextChildren };
+  return [nn, ...refreshedUpNodes(m, nextParent)];
+}
+export {
+  DirectoryItemSelector as default
+};

package/dist/components/ElementSearchDialog/element-search-dialog.d.ts

@@ -0,0 +1,16 @@
+export default ElementSearchDialog;
+declare function ElementSearchDialog(props: any): import("react/jsx-runtime").JSX.Element;
+declare namespace ElementSearchDialog {
+    namespace propTypes {
+        const open: PropTypes.Validator<boolean>;
+        const onClose: PropTypes.Validator<(...args: any[]) => any>;
+        const searchingLabel: PropTypes.Requireable<string>;
+        const onSearchTermChange: PropTypes.Validator<(...args: any[]) => any>;
+        const onSelectionChange: PropTypes.Validator<(...args: any[]) => any>;
+        const elementsFound: PropTypes.Validator<any[]>;
+        const renderElement: PropTypes.Validator<(...args: any[]) => any>;
+        const searchTermDisabled: PropTypes.Requireable<boolean>;
+        const searchTermDisableReason: PropTypes.Requireable<string>;
+    }
+}
+import PropTypes from 'prop-types';

package/dist/components/ElementSearchDialog/equipment-item.d.ts

@@ -0,0 +1,16 @@
+export function EquipmentItem({ inputValue, suffixRenderer, element, showsJustText, ...props }: {
+    [x: string]: any;
+    inputValue: any;
+    suffixRenderer?: {
+        ({ props, element }: {
+            props: any;
+            element: any;
+        }): import("react/jsx-runtime").JSX.Element;
+        propTypes: {
+            element: import("prop-types").Requireable<object>;
+            props: import("prop-types").Requireable<object>;
+        };
+    } | undefined;
+    element: any;
+    showsJustText?: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ElementSearchDialog/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./element-search-dialog";
+export { TagRenderer } from "./tag-renderer";

package/dist/components/ElementSearchDialog/tag-renderer.d.ts

@@ -0,0 +1,11 @@
+export function TagRenderer({ props, element }: {
+    props: any;
+    element: any;
+}): import("react/jsx-runtime").JSX.Element;
+export namespace TagRenderer {
+    namespace propTypes {
+        const element: PropTypes.Requireable<object>;
+        const props: PropTypes.Requireable<object>;
+    }
+}
+import PropTypes from 'prop-types';

package/dist/components/FlatParameters/FlatParameters.d.ts

@@ -0,0 +1,10 @@
+export function extractDefault(paramDescription: any): any;
+export function FlatParameters({ paramsAsArray, initValues, onChange, variant, showSeparator, selectionWithDialog, }: {
+    paramsAsArray: any;
+    initValues: any;
+    onChange: any;
+    variant?: string | undefined;
+    showSeparator?: boolean | undefined;
+    selectionWithDialog?: ((param: any) => boolean) | undefined;
+}): import("react/jsx-runtime").JSX.Element;
+export default FlatParameters;

package/dist/components/FlatParameters/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./FlatParameters";

package/dist/components/Login/Login.d.ts

@@ -0,0 +1,5 @@
+export default Login;
+declare function Login({ onLoginClick, disabled }: {
+    onLoginClick: any;
+    disabled: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Login/Logout.d.ts

@@ -0,0 +1,5 @@
+export default Logout;
+declare function Logout({ onLogoutClick, disabled }: {
+    onLogoutClick: any;
+    disabled: any;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Login/index.d.ts

@@ -0,0 +1 @@
+export { default } from "./Login";

package/dist/components/MuiVirtualizedTable/ColumnHeader.d.ts

@@ -0,0 +1,4 @@
+export const ColumnHeader: React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+declare const _default: import("@emotion/styled").StyledComponent<React.RefAttributes<any> & import("@mui/system").MUIStyledCommonProps<import("@mui/system").Theme>, {}, {}>;
+export default _default;
+import React from 'react';

package/dist/components/MuiVirtualizedTable/KeyedColumnsRowIndexer.d.ts

@@ -0,0 +1,104 @@
+export namespace CHANGE_WAYS {
+    const SIMPLE: string;
+    const TAIL: string;
+    const AMEND: string;
+    const REMOVE: string;
+}
+export const noOpHelper: Readonly<{
+    debugName: "noOp";
+    maintainsStats: false;
+    initStat: () => undefined;
+    updateStat: (colStat: any, value: any) => void;
+    accepts: (value: any, userParams: any, outerParams: any) => true;
+}>;
+export const collectibleHelper: Readonly<{
+    debugName: "collectible";
+    maintainsStats: true;
+    initStat: () => {
+        seen: {};
+        kept: {};
+    };
+    updateStat: (colStat: any, cellValue: any, isForKeep: any) => void;
+    accepts: (value: any, userParams: any, outerParams: any) => any;
+}>;
+export function getHelper(column: any): Readonly<{
+    debugName: "noOp";
+    maintainsStats: false;
+    initStat: () => undefined;
+    updateStat: (colStat: any, value: any) => void;
+    accepts: (value: any, userParams: any, outerParams: any) => true;
+}> | Readonly<{
+    debugName: "num";
+    maintainsStats: true;
+    initStat: () => {
+        imin: null;
+        imax: null;
+    };
+    updateStat: (colStat: any, value: any) => void;
+    accepts: (value: any, userParams: any, outerParams: any) => true;
+}> | Readonly<{
+    debugName: "collectible";
+    maintainsStats: true;
+    initStat: () => {
+        seen: {};
+        kept: {};
+    };
+    updateStat: (colStat: any, cellValue: any, isForKeep: any) => void;
+    accepts: (value: any, userParams: any, outerParams: any) => any;
+}>;
+/**
+ * A rows indexer for MuiVirtualizedTable to delegate to an instance of it
+ * for filtering, grouping and multi-column sorting via
+ * a view index to model index array.
+ */
+export class KeyedColumnsRowIndexer {
+    static get CHANGE_WAYS(): {
+        SIMPLE: string;
+        TAIL: string;
+        AMEND: string;
+        REMOVE: string;
+    };
+    constructor(isThreeState?: boolean, singleColumnByDefault?: boolean, delegatorCallback?: null, versionSetter?: null);
+    _versionSetter: any;
+    version: number;
+    filterVersion: number;
+    delegatorCallback: any;
+    indirectionStatus: string | null;
+    isThreeState: boolean;
+    singleColumnByDefault: boolean;
+    lastUsedRank: number;
+    sortingState: any;
+    groupingCount: number;
+    byColFilter: {} | null;
+    byRowFilter: any;
+    hasVersionSetter: () => boolean;
+    getVersion: () => number;
+    _bumpVersion: (isFilter?: boolean) => void;
+    updatePreferences: (preferences: any) => false | undefined;
+    preFilterRowMapping: (columns: any, rows: any, rowFilter: any) => {
+        rowAndOrigIndex: any[][];
+        colsStats: {};
+        rowsCount: any;
+    } | null;
+    makeGroupAndSortIndirector: (preFilteredRowPairs: any, columns: any) => any;
+    getSortingAsKeyAndCodedRank: () => any;
+    updateSortingFromUser: (colKey: any, change_way: any) => boolean;
+    codedRankByColumnIndex: (columns: any) => number[] | null;
+    columnSortingSignedRank: (colKey: any) => number;
+    highestCodedColumn: (columns: any) => number;
+    _getColFilterParams: (colKey: any, isForUser: any) => any;
+    _setColFilterParams: (colKey: any, params: any, isForUser: any) => boolean;
+    getColFilterOuterParams: (colKey: any) => any;
+    setColFilterOuterParams: (colKey: any, outerParams: any) => boolean;
+    getColFilterUserParams: (colKey: any) => any;
+    setColFilterUserParams: (colKey: any, params: any) => boolean;
+    getUserFiltering: () => {};
+    updateRowFiltering: (rowFilterFunc: any) => void;
+}
+export namespace forTesting {
+    export { codedColumnsFromKeyAndDirection };
+    export { makeCompositeComparatorFromCodedColumns };
+}
+declare function codedColumnsFromKeyAndDirection(keyAndDirections: any, columns: any): number[] | null;
+declare function makeCompositeComparatorFromCodedColumns(codedColumns: any, columns: any, rowExtractor: any): (row_a_i: any, row_b_i: any) => number;
+export {};

package/dist/components/MuiVirtualizedTable/MuiVirtualizedTable.d.ts

@@ -0,0 +1,131 @@
+export const DEFAULT_CELL_PADDING: 16;
+export const DEFAULT_HEADER_HEIGHT: 48;
+export const DEFAULT_ROW_HEIGHT: 48;
+export function generateMuiVirtualizedTableClass(className: any): string;
+declare const _default: import("@emotion/styled").StyledComponent<Pick<PropTypes.InferProps<{
+    name: PropTypes.Requireable<string>;
+    classes: PropTypes.Requireable<object>;
+    rows: PropTypes.Requireable<any[]>;
+    columns: PropTypes.Validator<(PropTypes.InferProps<{
+        dataKey: PropTypes.Validator<string>;
+        label: PropTypes.Validator<string>;
+        numeric: PropTypes.Requireable<boolean>;
+        width: PropTypes.Requireable<number>;
+        minWidth: PropTypes.Requireable<number>;
+        maxWidth: PropTypes.Requireable<number>;
+        unit: PropTypes.Requireable<string>;
+        fractionDigits: PropTypes.Requireable<number>;
+        extra: PropTypes.Requireable<PropTypes.ReactElementLike>;
+    }> | null | undefined)[]>;
+    enableExportCSV: PropTypes.Requireable<boolean>;
+    exportCSVDataKeys: PropTypes.Requireable<any[]>;
+    sort: PropTypes.Requireable<(...args: any[]) => any>;
+    sortable: PropTypes.Requireable<boolean>;
+    indexer: PropTypes.Requireable<object>;
+    headerHeight: PropTypes.Requireable<number>;
+    onRowClick: PropTypes.Requireable<(...args: any[]) => any>;
+    onCellClick: PropTypes.Requireable<(...args: any[]) => any>;
+    rowHeight: PropTypes.Requireable<number>;
+    filter: PropTypes.Requireable<(...args: any[]) => any>;
+    tooltipSx: PropTypes.Requireable<object>;
+}>, "filter" | "name" | "rows" | "columns" | "sort" | "tooltipSx" | "indexer" | "sortable" | "exportCSVDataKeys" | "onRowClick" | "onCellClick"> & {
+    classes?: object | null | undefined;
+    headerHeight?: number | null | undefined;
+    enableExportCSV?: boolean | null | undefined;
+    rowHeight?: number | null | undefined;
+} & {} & import("@mui/system").MUIStyledCommonProps<import("@mui/system").Theme>, {}, {
+    ref?: React.Ref<MuiVirtualizedTable> | undefined;
+}>;
+export default _default;
+import PropTypes from 'prop-types';
+declare class MuiVirtualizedTable extends React.PureComponent<any, any, any> {
+    static defaultProps: {
+        headerHeight: number;
+        rowHeight: number;
+        enableExportCSV: boolean;
+        classes: {};
+    };
+    constructor(props: any, context: any);
+    _computeHeaderSize(): void;
+    _registerHeader(label: any, header: any): void;
+    _registerObserver(element: any): void;
+    headers: React.RefObject<any>;
+    observer: IntersectionObserver;
+    state: {
+        headerHeight: any;
+        indexer: any;
+        indirectionVersion: number;
+        popoverAnchorEl: null;
+        popoverColKey: null;
+        deferredFilterChange: null;
+    };
+    setVersion: (v: any) => void;
+    componentDidUpdate(oldProps: any): void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    computeDataWidth: (text: any) => any;
+    sizes: import("memoize-one").MemoizedFn<(this: any, columns: any, rows: any, rowGetter: any) => {}>;
+    openPopover: (popoverTarget: any, colKey: any) => void;
+    dropDownVisible: any;
+    handleKeyDownOnPopover: (evt: any) => void;
+    closePopover: (evt: any, reason: any) => void;
+    makeColumnFilterEditor: () => import("react/jsx-runtime").JSX.Element;
+    _commitFilterChange: () => boolean;
+    onFilterParamsChange(newVal: any, colKey: any): void;
+    sortClickHandler: (evt: any, name: any, columnIndex: any) => void;
+    filterClickHandler: (evt: any, target: any, columnIndex: any) => void;
+    sortableHeader: ({ label, columnIndex }: {
+        label: any;
+        columnIndex: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+    simpleHeaderRenderer: ({ label }: {
+        label: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+    getRowClassName: ({ index, rowGetter }: {
+        index: any;
+        rowGetter: any;
+    }) => string;
+    onClickableRowClick: (event: any) => void;
+    cellRenderer: ({ cellData, columnIndex, rowIndex }: {
+        cellData: any;
+        columnIndex: any;
+        rowIndex: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+    getDisplayValue(column: any, cellData: any): any;
+    makeHeaderRenderer(dataKey: any, columnIndex: any): (headerProps: any) => import("react/jsx-runtime").JSX.Element;
+    makeSizedTable: (height: any, width: any, sizes: any, reorderedIndex: any, rowGetter: any) => import("react/jsx-runtime").JSX.Element;
+    getCSVFilename: () => any;
+    getCSVData: () => Promise<{}[]>;
+    csvHeaders: import("memoize-one").MemoizedFn<(this: any, columns: any, exportCSVDataKeys: any) => any[]>;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+declare namespace MuiVirtualizedTable {
+    namespace propTypes {
+        const name: PropTypes.Requireable<string>;
+        const classes: PropTypes.Requireable<object>;
+        const rows: PropTypes.Requireable<any[]>;
+        const columns: PropTypes.Validator<(PropTypes.InferProps<{
+            dataKey: PropTypes.Validator<string>;
+            label: PropTypes.Validator<string>;
+            numeric: PropTypes.Requireable<boolean>;
+            width: PropTypes.Requireable<number>;
+            minWidth: PropTypes.Requireable<number>;
+            maxWidth: PropTypes.Requireable<number>;
+            unit: PropTypes.Requireable<string>;
+            fractionDigits: PropTypes.Requireable<number>;
+            extra: PropTypes.Requireable<PropTypes.ReactElementLike>;
+        }> | null | undefined)[]>;
+        const enableExportCSV: PropTypes.Requireable<boolean>;
+        const exportCSVDataKeys: PropTypes.Requireable<any[]>;
+        const sort: PropTypes.Requireable<(...args: any[]) => any>;
+        const sortable: PropTypes.Requireable<boolean>;
+        const indexer: PropTypes.Requireable<object>;
+        const headerHeight: PropTypes.Requireable<number>;
+        const onRowClick: PropTypes.Requireable<(...args: any[]) => any>;
+        const onCellClick: PropTypes.Requireable<(...args: any[]) => any>;
+        const rowHeight: PropTypes.Requireable<number>;
+        const filter: PropTypes.Requireable<(...args: any[]) => any>;
+        const tooltipSx: PropTypes.Requireable<object>;
+    }
+}
+import React from 'react';

package/dist/components/MuiVirtualizedTable/index.d.ts

@@ -0,0 +1,2 @@
+export { default, generateMuiVirtualizedTableClass } from "./MuiVirtualizedTable";
+export { KeyedColumnsRowIndexer, CHANGE_WAYS } from "./KeyedColumnsRowIndexer";

package/dist/components/MultipleSelectionDialog/MultipleSelectionDialog.d.ts

@@ -0,0 +1,10 @@
+export default MultipleSelectionDialog;
+declare function MultipleSelectionDialog({ options, selectedOptions, open, getOptionLabel, handleClose, handleValidate, titleId, }: {
+    options: any;
+    selectedOptions: any;
+    open: any;
+    getOptionLabel: any;
+    handleClose: any;
+    handleValidate: any;
+    titleId: any;
+}): import("react/jsx-runtime").JSX.Element;