@reltio/components 1.4.1853 → 1.4.1854

package/esm/EditModeComplexAttribute/EditModeComplexAttribute.d.ts

@@ -1,5 +1,42 @@
-declare const _default: React.ComponentType<{
-    [x: string]: unknown;
-}>;
+import React, { ContextType, ReactNode } from 'react';
+import { Crosswalk, AttributeType, AttributeError, Mode, Metadata, ComplexAttributeValue } from '@reltio/mdm-sdk';
+import { ScrollToElementContext } from '../contexts/ScrollToElementContext';
+import { AdditionalControlsRenderer } from '../types';
+export type EditModeComplexAttributeProps<T> = {
+    label?: string;
+    attributeTypesList?: AttributeType[];
+    attributeType: AttributeType;
+    attributeValue: T;
+    errors?: AttributeError[];
+    ownError?: AttributeError;
+    mode: Mode;
+    metadata: Metadata;
+    crosswalks?: Crosswalk[];
+    lazy?: boolean;
+    showEmptyEditors?: boolean;
+    onAddOneMore?: () => void;
+    onAddAttributes: (attribute: {
+        uri: string;
+        attributeType: AttributeType;
+    }[]) => void;
+    onDeleteAttribute: (attribute: {
+        uri: string;
+        attributeType: AttributeType;
+        attributeValue: T;
+    }) => void;
+    onChangeAttribute: (attribute: {
+        uri: string;
+        attributeType: AttributeType;
+        value: T;
+    }) => void;
+    additionalControlsRenderer: (props: AdditionalControlsRenderer<ComplexAttributeValue>) => ReactNode;
+    hideDeleteButton?: boolean;
+    state?: 'deleted' | 'edited';
+    showNonOv?: boolean;
+    isHighlightedPath?: boolean;
+    highlightedError?: ContextType<typeof ScrollToElementContext>;
+    expanded?: boolean;
+    children?: ReactNode;
+};
+declare const _default: React.ComponentType<EditModeComplexAttributeProps<ComplexAttributeValue>>;
 export default _default;
-import React from 'react';

package/esm/EditModeComplexAttribute/EditModeComplexAttribute.js

@@ -1,20 +1,8 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import React, { useMemo, useState, useEffect } from 'react';
 import { pipe, propOr, pathEq, any } from 'ramda';
-import PropTypes from 'prop-types';
 import classnames from 'classnames';
 import i18n from 'ui-i18n';
-import { checkCanDeleteAttribute, isReltioCrosswalk, isTempUri, ComplexAttributeType, ReferenceAttributeValueType, NestedAttributeValueType, AttributeTypeType, getErrorMessage, hasAttributeDescendantsWithErrors, isAnalyticAttribute } from '@reltio/mdm-sdk';
+import { checkCanDeleteAttribute, isReltioCrosswalk, isTempUri, getErrorMessage, hasAttributeDescendantsWithErrors, isAnalyticAttribute } from '@reltio/mdm-sdk';
 import Button from '@mui/material/Button';
 import DeleteIcon from '@mui/icons-material/Delete';
 import Typography from '@mui/material/Typography';
@@ -71,10 +59,12 @@ var EditModeComplexAttribute = function (_a) {
         }
     }, [deleted]);
     var hasAnalyticValue = (attributeTypesList || []).some(function (attributeType) { return isAnalyticAttribute(attributeType); });
-    var attributeListEntity = useMemo(function () { return ({
-        attributes: hasAnalyticValue ? null : attributeValue.value,
-        analyticsAttributes: hasAnalyticValue ? attributeValue.value : null
-    }); }, [attributeValue, hasAnalyticValue]);
+    var attributeListEntity = useMemo(function () {
+        return ({
+            attributes: hasAnalyticValue ? null : attributeValue.value,
+            analyticsAttributes: hasAnalyticValue ? attributeValue.value : null
+        });
+    }, [attributeValue, hasAnalyticValue]);
     var errorMessage = getErrorMessage(ownError) || (hasDescendantsWithErrors && i18n.text('Has an incorrect value')) || '';
     return lazy ? (React.createElement(Button, { variant: "text", color: "primary", onClick: onAddOneMore }, "Create attribute")) : (React.createElement("div", { ref: ref, className: classnames(styles.complexWrapper, errorClassName) },
         React.createElement("div", { className: styles.editor },
@@ -91,7 +81,6 @@ var EditModeComplexAttribute = function (_a) {
                 showDeleteButton && (React.createElement(SmallIconButton, { icon: DeleteIcon, onClick: onDeleteThis, size: "L", "data-reltio-id": "reltio-delete-complex-attribute-button" })))),
         expanded && (React.createElement(EditModeAttributesList, { parentAttributeType: attributeType, attrTypes: attributeTypesList, entity: attributeListEntity, showEmptyEditors: showEmptyEditors || isNew, drawLines: true, parentUri: uri, mode: mode, crosswalks: crosswalks, onAddAttributes: onAddAttributes, onChangeAttribute: onChangeAttribute, onDeleteAttribute: onDeleteAttribute, additionalControlsRenderer: additionalControlsRenderer, showNonOv: showNonOv }, children))));
 };
-EditModeComplexAttribute.propTypes = __assign({ label: PropTypes.string, children: PropTypes.node, attributeTypesList: PropTypes.arrayOf(AttributeTypeType), attributeValue: PropTypes.oneOfType([NestedAttributeValueType, ReferenceAttributeValueType]), highlightedError: PropTypes.object, isHighlightedPath: PropTypes.bool }, ComplexAttributeType);
 export default withContext(ScrollToElementContext, function (contextValue, _a) {
     var attributeValue = _a.attributeValue;
     var _b = contextValue || {}, element = _b.element, type = _b.type;

package/esm/EditModeComplexAttribute/index.d.ts

@@ -1 +1,2 @@
 export { default as EditModeComplexAttribute } from './EditModeComplexAttribute';
+export type { EditModeComplexAttributeProps } from './EditModeComplexAttribute';

package/esm/EntitySelector/EntitySelector.d.ts

@@ -1,32 +1,20 @@
-export function EntitySelector({ entity, entityTypesUris, mode, max, onChange, onCreate, metadata, globalSearchRequestOptions, attributeTypesSelectionStrategy, disableLinkClick, ...otherProps }: {
-    [x: string]: any;
-    entity?: {};
-    entityTypesUris?: any[];
-    mode: any;
-    max: any;
-    onChange: any;
-    onCreate: any;
-    metadata: any;
-    globalSearchRequestOptions: any;
-    attributeTypesSelectionStrategy: any;
+import { ConnectionEntity, Mode, Metadata, GlobalSearchRequestOptions, TEntityType, AttributeType, PrimitiveValue } from '@reltio/mdm-sdk';
+import { TextFieldProps } from '@mui/material/TextField';
+type Props = {
+    entity?: ConnectionEntity;
+    entityTypesUris?: string[];
+    mode: Mode;
+    max: number;
+    onChange: (entity: ConnectionEntity) => void;
+    onCreate?: (entityTypeUri: string, value: PrimitiveValue) => void;
+    metadata: Metadata;
+    globalSearchRequestOptions: GlobalSearchRequestOptions;
+    attributeTypesSelectionStrategy: (entityType: TEntityType) => AttributeType[];
     disableLinkClick?: boolean;
-}): JSX.Element;
-export namespace EntitySelector {
-    namespace propTypes {
-        export { ConnectionEntityType as entity };
-        export let entityTypesUris: PropTypes.Requireable<string[]>;
-        export let max: PropTypes.Requireable<number>;
-        export { ModeType as mode };
-        export let dispatch: PropTypes.Requireable<(...args: any[]) => any>;
-        export { MetadataType as metadata };
-        export let onChange: PropTypes.Validator<(...args: any[]) => any>;
-        export let onCreate: PropTypes.Requireable<(...args: any[]) => any>;
-        export let attributeTypesSelectionStrategy: PropTypes.Requireable<(...args: any[]) => any>;
-        export let globalSearchRequestOptions: PropTypes.Requireable<object>;
-        export let disableLinkClick: PropTypes.Requireable<boolean>;
-    }
-}
-import { ConnectionEntityType } from '@reltio/mdm-sdk';
-import PropTypes from 'prop-types';
-import { ModeType } from '@reltio/mdm-sdk';
-import { MetadataType } from '@reltio/mdm-sdk';
+    TextFieldProps?: TextFieldProps;
+    className?: string;
+    height?: number;
+    isDisabled?: boolean;
+};
+export declare const EntitySelector: ({ entity, entityTypesUris, mode, max, onChange, onCreate, metadata, globalSearchRequestOptions, attributeTypesSelectionStrategy, disableLinkClick, ...otherProps }: Props) => JSX.Element;
+export {};

package/esm/EntitySelector/EntitySelector.js

@@ -21,10 +21,9 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import React, { useState, useMemo } from 'react';
-import PropTypes from 'prop-types';
 import i18n from 'ui-i18n';
 import { isEmpty, prop } from 'ramda';
-import { typeAheadSearch, getEntityType, MetadataType, ConnectionEntityType, ModeType, isTempUri, isAvailableEntityType } from '@reltio/mdm-sdk';
+import { typeAheadSearch, getEntityType, isTempUri, isAvailableEntityType } from '@reltio/mdm-sdk';
 import { EmptyStub } from '../core';
 import { DropDownSelector } from '../DropDownSelector';
 import { EntityOption } from './components/EntityOption';
@@ -78,16 +77,3 @@ export var EntitySelector = function (_a) {
         isTempEntity && (React.createElement("div", { className: styles.creatorWrapper },
             React.createElement(EntityCreator, { mode: mode, attributeTypesSelectionStrategy: attributeTypesSelectionStrategy, entityType: currentEntityType, entityUri: entity.entityUri })))));
 };
-EntitySelector.propTypes = {
-    entity: ConnectionEntityType,
-    entityTypesUris: PropTypes.arrayOf(PropTypes.string),
-    max: PropTypes.number,
-    mode: ModeType,
-    dispatch: PropTypes.func,
-    metadata: MetadataType,
-    onChange: PropTypes.func.isRequired,
-    onCreate: PropTypes.func,
-    attributeTypesSelectionStrategy: PropTypes.func,
-    globalSearchRequestOptions: PropTypes.object,
-    disableLinkClick: PropTypes.bool
-};

package/esm/EntitySelector/components/EntityOption/EntityOption.d.ts

@@ -1,22 +1,17 @@
-export function EntityOption({ innerRef, innerProps, selectOption, data }: {
-    innerRef: any;
-    innerProps: any;
-    selectOption: any;
-    data: any;
-}): JSX.Element;
-export namespace EntityOption {
-    namespace propTypes {
-        let innerRef: PropTypes.Requireable<any>;
-        let innerProps: PropTypes.Validator<object>;
-        let selectOption: PropTypes.Validator<(...args: any[]) => any>;
-        let data: PropTypes.Requireable<PropTypes.InferProps<{
-            uri: PropTypes.Validator<string>;
-            label: PropTypes.Validator<string>;
-            entityType: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
-                uri: PropTypes.Requireable<string>;
-                type: PropTypes.Requireable<string>;
-            }>>>;
-        }>>;
-    }
-}
-import PropTypes from 'prop-types';
+import { ForwardedRef } from 'react';
+import { MenuItemProps } from '@mui/material/MenuItem';
+import { TEntityType } from '@reltio/mdm-sdk';
+type Option = {
+    label: string;
+    uri: string;
+    entityType: TEntityType;
+    secondaryLabel?: string;
+};
+type Props = {
+    innerProps: MenuItemProps;
+    innerRef: ForwardedRef<HTMLLIElement>;
+    selectOption: (option: Option) => void;
+    data: Option;
+};
+export declare const EntityOption: ({ innerRef, innerProps, selectOption, data }: Props) => JSX.Element;
+export {};

package/esm/EntitySelector/components/EntityOption/EntityOption.js

@@ -10,10 +10,8 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import React from 'react';
-import PropTypes from 'prop-types';
 import i18n from 'ui-i18n';
 import MenuItem from '@mui/material/MenuItem';
-import { EntityType } from '@reltio/mdm-sdk';
 import { EntityTypeIcon } from '../../../EntityTypeIcon';
 import { ExpandedValueTooltip } from '../../../ExpandedValueTooltip';
 import { useStyles } from './styles';
@@ -36,19 +34,3 @@ export var EntityOption = function (_a) {
             React.createElement("span", { className: styles.emptyEntityLabel }, i18n.text('No results found'))));
     }
 };
-EntityOption.propTypes = {
-    innerRef: PropTypes.oneOfType([
-        PropTypes.oneOf([null]),
-        PropTypes.func,
-        PropTypes.shape({
-            current: PropTypes.any.isRequired
-        })
-    ]),
-    innerProps: PropTypes.object.isRequired,
-    selectOption: PropTypes.func.isRequired,
-    data: PropTypes.shape({
-        uri: PropTypes.string.isRequired,
-        label: PropTypes.string.isRequired,
-        entityType: EntityType.isRequired
-    })
-};

package/esm/ErrorWrapper/ErrorWrapper.d.ts

@@ -3,8 +3,8 @@ import { FormControlProps } from '@mui/material/FormControl';
 type Props = FormControlProps & {
     errorMessage?: string;
     classes?: {
-        root: string;
-        helperText: string;
+        root?: string;
+        helperText?: string;
     };
 };
 export declare const ErrorWrapper: React.MemoExoticComponent<({ errorMessage, children, className, classes, ...otherProps }: Props) => JSX.Element>;

package/esm/FilterEditor/FilterEditor.d.ts

@@ -1,23 +1,16 @@
-export function FilterEditor({ value, onChange, filterOptions, dataTypeDefinition, classes, valueEditorProps }: {
-    value: any;
-    onChange: any;
-    filterOptions: any;
-    dataTypeDefinition: any;
-    classes: any;
-    valueEditorProps: any;
-}): JSX.Element;
-export namespace FilterEditor {
-    namespace propTypes {
-        export { FilterType as value };
-        export let onChange: PropTypes.Requireable<(...args: any[]) => any>;
-        export let filterOptions: PropTypes.Requireable<PropTypes.InferProps<{
-            value: PropTypes.Requireable<string>;
-            label: PropTypes.Requireable<string>;
-        }>[]>;
-        export let dataTypeDefinition: PropTypes.Requireable<object>;
-        export let classes: PropTypes.Requireable<object>;
-        export let valueEditorProps: PropTypes.Requireable<object>;
-    }
-}
-import { FilterType } from '@reltio/mdm-sdk';
-import PropTypes from 'prop-types';
+import { ComponentProps } from 'react';
+import { DataTypeDefinition, FacetFilter } from '@reltio/mdm-sdk';
+import { FilterValueEditor } from '../FilterValueEditor';
+type Props = {
+    value: FacetFilter;
+    onChange: (value: FacetFilter) => void;
+    filterOptions: {
+        value: string;
+        label: string;
+    }[];
+    dataTypeDefinition: DataTypeDefinition;
+    classes: Record<string, string>;
+    ValueEditorProps: Omit<ComponentProps<typeof FilterValueEditor>, 'filter' | 'onChange' | 'dataTypeDefinition'>;
+};
+export declare const FilterEditor: ({ value, onChange, filterOptions, dataTypeDefinition, classes, ValueEditorProps }: Props) => JSX.Element;
+export {};

package/esm/FilterEditor/FilterEditor.js

@@ -10,16 +10,15 @@ var __assign = (this && this.__assign) || function () {
     return __assign.apply(this, arguments);
 };
 import React from 'react';
-import PropTypes from 'prop-types';
 import classnames from 'classnames';
 import { __, assoc, pipe } from 'ramda';
-import { checkIfOptionHasValues, FilterType } from '@reltio/mdm-sdk';
+import { checkIfOptionHasValues } from '@reltio/mdm-sdk';
 import { COMMON_TEXT_FIELD_PROPS } from '../constants';
 import { DropDownEditor } from '../DropDownEditor';
 import { FilterValueEditor } from '../FilterValueEditor';
 import { useStyles } from './styles';
 export var FilterEditor = function (_a) {
-    var value = _a.value, onChange = _a.onChange, filterOptions = _a.filterOptions, dataTypeDefinition = _a.dataTypeDefinition, classes = _a.classes, valueEditorProps = _a.valueEditorProps;
+    var value = _a.value, onChange = _a.onChange, filterOptions = _a.filterOptions, dataTypeDefinition = _a.dataTypeDefinition, classes = _a.classes, ValueEditorProps = _a.ValueEditorProps;
     var styles = useStyles();
     var firstOption = filterOptions[0];
     var filterOption = value.filter || firstOption.value;
@@ -27,16 +26,5 @@ export var FilterEditor = function (_a) {
     var canFilterAcceptValues = checkIfOptionHasValues(filterOption);
     return (React.createElement(React.Fragment, null,
         React.createElement(DropDownEditor, { TextFieldProps: COMMON_TEXT_FIELD_PROPS, className: classnames(classes.option, styles.dropDownEditor), value: filterOption, entries: filterOptions, onChange: pipe(assoc('filter', __, filter), assoc('values', []), onChange), classes: { root: classnames(styles.root, styles.selectorRoot), icon: styles.icon } }),
-        canFilterAcceptValues && (React.createElement(FilterValueEditor, __assign({ filter: filter, onChange: pipe(assoc('values', __, filter), onChange), dataTypeDefinition: dataTypeDefinition }, valueEditorProps)))));
-};
-FilterEditor.propTypes = {
-    value: FilterType,
-    onChange: PropTypes.func,
-    filterOptions: PropTypes.arrayOf(PropTypes.shape({
-        value: PropTypes.string,
-        label: PropTypes.string
-    })),
-    dataTypeDefinition: PropTypes.object,
-    classes: PropTypes.object,
-    valueEditorProps: PropTypes.object
+        canFilterAcceptValues && (React.createElement(FilterValueEditor, __assign({ filter: filter, onChange: pipe(assoc('values', __, filter), onChange), dataTypeDefinition: dataTypeDefinition }, ValueEditorProps)))));
 };

package/esm/FilterValueEditor/FilterValueEditor.d.ts

@@ -1,24 +1,14 @@
-export function FilterValueEditor({ filter: { values, fieldName, filter }, onChange, dataTypeDefinition, orientation, TextFieldProps, ...otherProps }: {
-    [x: string]: any;
-    filter: {
-        values?: any[];
-        fieldName: any;
-        filter: any;
-    };
-    onChange: any;
-    dataTypeDefinition: any;
-    orientation: any;
-    TextFieldProps: any;
-}): JSX.Element;
-export namespace FilterValueEditor {
-    namespace propTypes {
-        export { FilterType as filter };
-        export let orientation: PropTypes.Requireable<string>;
-        export let onChange: PropTypes.Requireable<(...args: any[]) => any>;
-        export let dataTypeDefinition: PropTypes.Requireable<object>;
-        export let classes: PropTypes.Requireable<object>;
-        export let TextFieldProps: PropTypes.Requireable<object>;
-    }
-}
-import { FilterType } from '@reltio/mdm-sdk';
-import PropTypes from 'prop-types';
+import { DataTypeDefinition, DatePeriod, SearchFilter, SearchValue } from '@reltio/mdm-sdk';
+import { TextFieldProps } from '@mui/material/TextField';
+type Props = {
+    filter: SearchFilter;
+    orientation?: 'horizontal' | 'vertical';
+    onChange: (value: Array<SearchValue | DatePeriod | Date>) => void;
+    dataTypeDefinition: DataTypeDefinition;
+    classes?: Record<string, string>;
+    TextFieldProps: TextFieldProps;
+    fullWidth?: boolean;
+    color?: 'primary' | 'secondary';
+};
+export declare const FilterValueEditor: ({ filter: { values, fieldName, filter }, onChange, dataTypeDefinition, orientation, TextFieldProps, ...otherProps }: Props) => JSX.Element;
+export {};

package/esm/FilterValueEditor/FilterValueEditor.js

@@ -20,10 +20,9 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import PropTypes from 'prop-types';
 import React from 'react';
 import i18n from 'ui-i18n';
-import { FilterType, isDateRangeFilterOption, isMultiValueOption, isRangeFilterOption, mapFilterValue, wrapInArray } from '@reltio/mdm-sdk';
+import { isDateRangeFilterOption, isMultiValueOption, isRangeFilterOption, mapFilterValue, wrapInArray } from '@reltio/mdm-sdk';
 import { pipe } from 'ramda';
 import { DateRangeEditor } from '../DateRangeEditor';
 import { DataTypeValueEditor } from '../DataTypeValueEditor';
@@ -45,11 +44,3 @@ export var FilterValueEditor = function (_a) {
         return (React.createElement(DataTypeValueEditor, __assign({}, otherProps, multipleProp, { fieldName: fieldName, value: value, onChange: handleChange, dataTypeDefinition: dataTypeDefinition, TextFieldProps: TextFieldProps })));
     }
 };
-FilterValueEditor.propTypes = {
-    filter: FilterType,
-    orientation: PropTypes.oneOf(['horizontal', 'vertical']),
-    onChange: PropTypes.func,
-    dataTypeDefinition: PropTypes.object,
-    classes: PropTypes.object,
-    TextFieldProps: PropTypes.object
-};

package/esm/HOCs/withFilter/ColumnFilter.js

@@ -66,7 +66,7 @@ export var ColumnFilter = function (_a) {
                 vertical: 'top',
                 horizontal: 'right'
             }, classes: { paper: styles.filterMenu }, onClose: applyChangesAndClose },
-            React.createElement(FilterEditor, { classes: { option: styles['filter-editor__option'] }, value: mdmFilter, onChange: pipe(mdmFilterToColumnFilter, setColumnFilter), filterOptions: filterOptions, dataTypeDefinition: getFilterDataTypeDefinition(mdmFilter.filter), valueEditorProps: {
+            React.createElement(FilterEditor, { classes: { option: styles['filter-editor__option'] }, value: mdmFilter, onChange: pipe(mdmFilterToColumnFilter, setColumnFilter), filterOptions: filterOptions, dataTypeDefinition: getFilterDataTypeDefinition(mdmFilter.filter), ValueEditorProps: {
                     TextFieldProps: {
                         onKeyPress: handleValueEditorKeyPress
                     },

package/esm/LookupEditor/LookupEditor.d.ts

@@ -1,33 +1,11 @@
-export function LookupEditor({ multiple, value, lookupCode: lookupTypeCode, lookups, onChange, getLookups, ...otherProps }: {
-    [x: string]: any;
-    multiple: any;
-    value: any;
-    lookupCode: any;
-    lookups: any;
-    onChange: any;
-    getLookups: any;
-}): JSX.Element;
-export namespace LookupEditor {
-    namespace propTypes {
-        let multiple: PropTypes.Requireable<boolean>;
-        let value: PropTypes.Requireable<NonNullable<PropTypes.InferProps<{
-            value: PropTypes.Requireable<string>;
-            lookupCode: PropTypes.Requireable<string>;
-        }> | PropTypes.InferProps<{
-            value: PropTypes.Requireable<string>;
-            lookupCode: PropTypes.Requireable<string>;
-        }>[]>>;
-        let lookupCode: PropTypes.Validator<string>;
-        let lookups: PropTypes.Validator<{
-            [x: string]: {
-                [x: string]: PropTypes.InferProps<{
-                    displayName: PropTypes.Requireable<string>;
-                    parent: PropTypes.Requireable<string>;
-                }>;
-            };
-        }>;
-        let onChange: PropTypes.Requireable<(...args: any[]) => any>;
-        let getLookups: PropTypes.Requireable<(...args: any[]) => any>;
-    }
-}
-import PropTypes from 'prop-types';
+import { LookupValue, Lookups } from '@reltio/mdm-sdk';
+type Props = {
+    value?: LookupValue | LookupValue[];
+    lookupCode: string;
+    lookups?: Lookups;
+    multiple?: boolean;
+    onChange?: (value: LookupValue | LookupValue[]) => void;
+    getLookups?: () => Promise<Lookups>;
+};
+export declare const LookupEditor: ({ multiple, value, lookupCode: lookupTypeCode, lookups, onChange, getLookups, ...otherProps }: Props) => JSX.Element;
+export {};

package/esm/LookupEditor/LookupEditor.js

@@ -20,12 +20,10 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import PropTypes from 'prop-types';
 import React, { useEffect } from 'react';
-import { SimpleLookupType, LookupValueType } from '@reltio/mdm-sdk';
 import { always, defaultTo, isEmpty, map, path, pipe, pluck, prop, propEq } from 'ramda';
-import { buildLookupEntries } from './helpers';
 import { GroupedDropDownEditor } from './components/GroupedDropDownEditor';
+import { buildLookupEntries } from './helpers';
 export var LookupEditor = function (_a) {
     var multiple = _a.multiple, value = _a.value, lookupTypeCode = _a.lookupCode, lookups = _a.lookups, onChange = _a.onChange, getLookups = _a.getLookups, otherProps = __rest(_a, ["multiple", "value", "lookupCode", "lookups", "onChange", "getLookups"]);
     var codeToLookup = function (lookupCode) { return ({
@@ -43,11 +41,3 @@ export var LookupEditor = function (_a) {
     value = defaultTo(multiple ? [] : {}, value);
     return multiple ? (React.createElement(GroupedDropDownEditor, __assign({}, commonProps, { value: pluck('lookupCode', value), getValuePlaceholder: function (lookupCode) { return value.find(propEq('lookupCode', lookupCode)).value; }, onChange: pipe(map(codeToLookup), onChange) }))) : (React.createElement(GroupedDropDownEditor, __assign({}, commonProps, { value: prop('lookupCode', value), getValuePlaceholder: always(prop('value', value)), onChange: pipe(codeToLookup, onChange) })));
 };
-LookupEditor.propTypes = {
-    multiple: PropTypes.bool,
-    value: PropTypes.oneOfType([LookupValueType, PropTypes.arrayOf(LookupValueType)]),
-    lookupCode: PropTypes.string.isRequired,
-    lookups: PropTypes.objectOf(PropTypes.objectOf(SimpleLookupType)).isRequired,
-    onChange: PropTypes.func,
-    getLookups: PropTypes.func
-};

package/esm/LookupEditor/components/GroupedDropDownEditor/GroupedDropDownEditor.d.ts

@@ -1,21 +1,11 @@
-export const MENU_ITEM_OFFSET: 25;
-export function GroupedDropDownEditor({ value, entries, classes, ...otherProps }: {
-    [x: string]: any;
-    value: any;
-    entries: any;
-    classes: any;
-}): JSX.Element;
-export namespace GroupedDropDownEditor {
-    namespace propTypes {
-        let value: PropTypes.Requireable<NonNullable<NonNullable<string | number | object>>>;
-        let entries: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
-            value: PropTypes.Validator<NonNullable<NonNullable<string | number | object>>>;
-            label: PropTypes.Requireable<string>;
-        }> | PropTypes.InferProps<{
-            label: PropTypes.Validator<string>;
-            values: PropTypes.Validator<object[]>;
-        }>>[]>;
-        let classes: PropTypes.Requireable<object>;
-    }
-}
-import PropTypes from 'prop-types';
+import { ComponentProps } from 'react';
+import MultipliableSelect from '../../../components/MultipliableSelect/MultipliableSelect';
+import { DropDownGroupEntryType, DropDownEntryType } from '../../../types';
+export declare const MENU_ITEM_OFFSET = 25;
+type Props = {
+    value?: string | string[];
+    entries: DropDownEntryType[] | DropDownGroupEntryType[];
+    classes?: Record<string, string>;
+} & ComponentProps<typeof MultipliableSelect>;
+export declare const GroupedDropDownEditor: ({ value, entries, classes, ...otherProps }: Props) => JSX.Element;
+export {};

package/esm/LookupEditor/components/GroupedDropDownEditor/GroupedDropDownEditor.js

@@ -21,14 +21,12 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 import React from 'react';
-import PropTypes from 'prop-types';
 import classnames from 'classnames';
 import i18n from 'ui-i18n';
 import { isNil, pipe, prop } from 'ramda';
 import { wrapInArrayIfNeeded } from '@reltio/mdm-sdk';
 import CheckIcon from '@mui/icons-material/Check';
 import MenuItem from '@mui/material/MenuItem';
-import { DropDownEntryType, DropDownGroupEntryType, SelectValueType } from '../../../constants/prop-types';
 import MultipliableSelect from '../../../components/MultipliableSelect/MultipliableSelect';
 import { findEntryByValue, flattenGroupedEntries } from './helpers';
 import { useStyles } from './styles';
@@ -47,8 +45,3 @@ export var GroupedDropDownEditor = function (_a) {
             label || value.toString()));
     })) : (React.createElement(MenuItem, { className: styles.emptyLabel, disabled: true }, i18n.text('No results found')))));
 };
-GroupedDropDownEditor.propTypes = {
-    value: PropTypes.oneOfType([SelectValueType, PropTypes.arrayOf(SelectValueType)]),
-    entries: PropTypes.arrayOf(PropTypes.oneOfType([DropDownEntryType, DropDownGroupEntryType])).isRequired,
-    classes: PropTypes.object
-};

package/esm/LookupEditor/components/GroupedDropDownEditor/helpers.d.ts

@@ -1,2 +1,9 @@
-export const flattenGroupedEntries: any;
-export const findEntryByValue: any;
+import { CurriedFunction2, PrimitiveValue } from '@reltio/mdm-sdk';
+import { DropDownGroupEntryType, DropDownEntryType } from '../../../types';
+type FlattenEntry = DropDownEntryType & {
+    depth: number;
+    isGroup?: boolean;
+};
+export declare const flattenGroupedEntries: (entries: DropDownEntryType[] | DropDownGroupEntryType[]) => FlattenEntry[];
+export declare const findEntryByValue: CurriedFunction2<Array<FlattenEntry>, PrimitiveValue, FlattenEntry>;
+export {};

package/esm/LookupEditor/components/GroupedDropDownEditor/helpers.js

@@ -22,12 +22,12 @@ import { chain, curry, has } from 'ramda';
 var isGroupEntry = has('values');
 var flattenEntry = curry(function (depth, entry) {
     return isGroupEntry(entry)
-        ? __spreadArray([{ label: entry.label, depth: depth, isGroup: true }], chain(flattenEntry(depth + 1), entry.values), true) : __assign(__assign({}, entry), { depth: depth });
+        ? __spreadArray([
+            { label: entry.label, depth: depth, isGroup: true }
+        ], chain(flattenEntry(depth + 1), entry.values), true) : __assign(__assign({}, entry), { depth: depth });
 });
 export var flattenGroupedEntries = chain(flattenEntry(0));
-export var findEntryByValue = curry(function (entries, _value) {
-    return entries.find(function (_a) {
-        var isGroup = _a.isGroup, value = _a.value;
-        return !isGroup && value === _value;
-    });
-});
+export var findEntryByValue = curry(function (entries, _value) { return entries.find(function (_a) {
+    var isGroup = _a.isGroup, value = _a.value;
+    return !isGroup && value === _value;
+}); });

package/esm/LookupEditor/components/GroupedDropDownEditor/styles.d.ts

@@ -1 +1 @@
-export const useStyles: (props?: any) => import("@mui/styles").ClassNameMap<"icon" | "root" | "checkIcon" | "emptyLabel">;
+export declare const useStyles: (props?: any) => import("@mui/styles").ClassNameMap<"icon" | "root" | "checkIcon" | "emptyLabel">;