@reltio/components 1.4.1836-hf → 1.4.1837

package/cjs/ConnectionEditor/ConnectionEditor.test.js

@@ -0,0 +1,374 @@
+"use strict";
+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);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importDefault(require("react"));
+var enzyme_1 = require("enzyme");
+var test_utils_1 = require("react-dom/test-utils");
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var MdmModuleContext_1 = require("../contexts/MdmModuleContext");
+var EditModeAttributesList_1 = require("../EditModeAttributesList");
+var EntitySelector_1 = require("../EntitySelector");
+var ConnectionRelationTypeSelector_1 = require("../ConnectionRelationTypeSelector");
+var ErrorWrapper_1 = require("../ErrorWrapper");
+var ConnectionEditor_1 = require("./ConnectionEditor");
+jest.mock('../EntitySelector', function () { return ({
+    EntitySelector: function () { return null; }
+}); });
+jest.mock('../EditModeAttributesList', function () { return ({
+    EditModeAttributesList: function () { return null; }
+}); });
+var newConnection = {
+    relation: {
+        uri: 'relations/uri$$123',
+        attributes: {},
+        type: undefined
+    },
+    entity: null
+};
+var relatedEntity = {
+    uri: 'entities/entity123',
+    type: 'configuration/entityTypes/HCP'
+};
+var metadata = {
+    uri: 'configuration',
+    entityTypes: [
+        {
+            uri: 'configuration/entityTypes/HCP'
+        },
+        {
+            uri: 'configuration/entityTypes/HCO'
+        },
+        {
+            uri: 'configuration/entityTypes/Committee'
+        },
+        {
+            uri: 'configuration/entityTypes/Location'
+        }
+    ],
+    relationTypes: [
+        {
+            uri: 'configuration/relationTypes/HeadNursing',
+            label: 'Head of Nursing',
+            startObject: {
+                objectTypeURI: 'configuration/entityTypes/HCP',
+                uri: 'configuration/relationTypes/HeadNursing/startObject'
+            },
+            endObject: {
+                objectTypeURI: 'configuration/entityTypes/HCO',
+                uri: 'configuration/relationTypes/HeadNursing/endObject'
+            },
+            attributes: [
+                {
+                    label: 'Affiliation SubType',
+                    name: 'AffiliationSubType',
+                    type: 'String',
+                    lookupCode: 'AFFILIATION_SUB_TYPE_CD',
+                    uri: 'configuration/relationTypes/HCPtoHCA/attributes/AffiliationSubType'
+                },
+                {
+                    label: 'Primary Affiliation Indicator',
+                    name: 'PrimaryAffiliationIndicator',
+                    type: 'Boolean',
+                    uri: 'configuration/relationTypes/HCPtoHCA/attributes/PrimaryAffiliationIndicator'
+                },
+                {
+                    label: 'RelFirstLevelNested',
+                    name: 'RelFirstLevelNested',
+                    type: 'Nested',
+                    uri: 'configuration/relationTypes/HCPtoHCA/attributes/RefFirstLevelNested',
+                    attributes: [
+                        {
+                            label: 'FirstLevelNestedSub1',
+                            name: 'FirstLevelNestedSub1',
+                            type: 'String',
+                            lookupCode: 'LANG_CD',
+                            uri: 'configuration/relationTypes/HCPtoHCA/attributes/RefFirstLevelNested/attributes/FirstLevelNestedSub1'
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            uri: 'configuration/relationTypes/HasAddress',
+            label: 'has address',
+            startObject: {
+                objectTypeURI: 'configuration/entityTypes/HCP',
+                uri: 'configuration/relationTypes/HasAddress/startObject'
+            },
+            endObject: {
+                objectTypeURI: 'configuration/entityTypes/Location',
+                uri: 'configuration/relationTypes/HasAddress/endObject'
+            }
+        },
+        {
+            uri: 'configuration/relationTypes/IsInCommittee',
+            label: 'is in committee',
+            startObject: {
+                objectTypeURI: 'configuration/entityTypes/Committee',
+                uri: 'configuration/relationTypes/IsInCommittee/startObject'
+            },
+            endObject: {
+                objectTypeURI: 'configuration/entityTypes/HCP',
+                uri: 'configuration/relationTypes/IsInCommittee/endObject'
+            }
+        }
+    ]
+};
+var inRelationTypes = (_a = metadata.relationTypes) === null || _a === void 0 ? void 0 : _a.slice(2, 3);
+var outRelationTypes = (_b = metadata.relationTypes) === null || _b === void 0 ? void 0 : _b.slice(0, 2);
+var initConnection = {
+    relation: {
+        attributes: {
+            FirstName: [
+                {
+                    type: 'configuration/entityTypes/HCP/attributes/FirstName',
+                    ov: true,
+                    value: 'HCP_5',
+                    uri: 'entities/19oYeyx1/attributes/FirstName/1dg2njmxf'
+                }
+            ]
+        },
+        uri: 'relation/uri',
+        type: 'configuration/relationTypes/HeadNursing',
+        direction: 'out',
+        startDate: 123
+    },
+    entity: {
+        type: 'configuration/entityTypes/HCO',
+        uri: 'entities/uriHCO'
+    }
+};
+var props = {
+    onChangeAttribute: jest.fn(),
+    onAddAttributes: jest.fn(),
+    onRemoveAttribute: jest.fn(),
+    showEmptyEditors: true
+};
+var mdmValues = {
+    metadata: metadata,
+    globalSearchRequestOptions: {}
+};
+var setUpMount = function (extraProps) {
+    var Component = function (props) { return (react_1.default.createElement(MdmModuleContext_1.MdmModuleProvider, { values: mdmValues },
+        react_1.default.createElement(ConnectionEditor_1.ConnectionEditor, __assign({}, props)))); };
+    return (0, enzyme_1.mount)(react_1.default.createElement(Component, __assign({}, props, extraProps)));
+};
+describe('ConnectionEditor test', function () {
+    it('should render EditModeAttributesList', function () {
+        var _a;
+        var component = setUpMount({ connection: initConnection });
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList)).toHaveLength(1);
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('attrTypes')).toEqual(__spreadArray(__spreadArray([], mdm_sdk_1.ACTIVENESS_ATTR_TYPES, true), (((_a = metadata.relationTypes) === null || _a === void 0 ? void 0 : _a[0].attributes) || []), true));
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('entity')).toEqual({
+            attributes: initConnection.relation.attributes,
+            startDate: 123
+        });
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('showEmptyEditors')).toBe(true);
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('mode')).toBe('Editing');
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('parentUri')).toBe(initConnection.relation.uri);
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('onAddAttributes')).toBe(props.onAddAttributes);
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('onChangeAttribute')).toBe(props.onChangeAttribute);
+        expect(component.find(EditModeAttributesList_1.EditModeAttributesList).prop('onDeleteAttribute')).toBe(props.onRemoveAttribute);
+    });
+    it('should render ConnectionRelationTypeSelector and EntitySelector', function () {
+        var props = {
+            connection: initConnection,
+            relatedEntity: relatedEntity,
+            inRelationTypes: inRelationTypes,
+            outRelationTypes: outRelationTypes,
+            onChangeRelationType: jest.fn(),
+            onChangeEntity: jest.fn()
+        };
+        var component = setUpMount(props);
+        expect(component.find(ConnectionRelationTypeSelector_1.ConnectionRelationTypeSelector)).toHaveLength(1);
+        expect(component.find(ErrorWrapper_1.ErrorWrapper)).toHaveLength(1);
+        expect(component.find(EntitySelector_1.EntitySelector)).toHaveLength(1);
+        var compatibleRelation = {
+            relationType: initConnection.relation.type,
+            direction: initConnection.relation.direction
+        };
+        expect(component.find(ConnectionRelationTypeSelector_1.ConnectionRelationTypeSelector).prop('relation')).toEqual(compatibleRelation);
+        expect(component.find(EntitySelector_1.EntitySelector).prop('onChange')).toBe(props.onChangeEntity);
+        var compatibleEntity = {
+            entityUri: initConnection.entity.uri,
+            entityType: initConnection.entity.type,
+            entityLabel: '<No label>'
+        };
+        expect(component.find(EntitySelector_1.EntitySelector).prop('entity')).toEqual(compatibleEntity);
+        expect(component.find(EntitySelector_1.EntitySelector).prop('entityTypesUris')).toEqual(['configuration/entityTypes/HCO']);
+    });
+    it('should set entityTypesUris prop for EntitySelector', function () {
+        var props = {
+            connection: newConnection,
+            relatedEntity: relatedEntity,
+            inRelationTypes: inRelationTypes,
+            outRelationTypes: outRelationTypes,
+            onChangeRelationType: jest.fn(),
+            onChangeEntity: jest.fn()
+        };
+        var component = setUpMount(props);
+        expect(component.find(EntitySelector_1.EntitySelector).prop('entityTypesUris')).toEqual([
+            'configuration/entityTypes/HCO',
+            'configuration/entityTypes/Location',
+            'configuration/entityTypes/Committee'
+        ]);
+    });
+    it('should call onChangeRelationType for ConnectionRelationTypeSelector, if relation type was changed', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var onChangeRelationType, component, newRelationType;
+        return __generator(this, function (_a) {
+            onChangeRelationType = jest.fn();
+            component = setUpMount({
+                connection: newConnection,
+                relatedEntity: relatedEntity,
+                inRelationTypes: inRelationTypes,
+                outRelationTypes: outRelationTypes,
+                onChangeRelationType: onChangeRelationType,
+                onChangeEntity: jest.fn()
+            });
+            expect(onChangeRelationType).not.toHaveBeenCalledWith();
+            newRelationType = {
+                type: { uri: 'configuration/relationTypes/IsInCommittee' },
+                direction: mdm_sdk_1.Directions.OUT
+            };
+            (0, test_utils_1.act)(function () {
+                component.find(ConnectionRelationTypeSelector_1.ConnectionRelationTypeSelector).prop('onChange')(newRelationType);
+            });
+            component.update();
+            expect(onChangeRelationType).toHaveBeenCalledWith({
+                type: newRelationType.type.uri,
+                direction: newRelationType.direction
+            });
+            return [2 /*return*/];
+        });
+    }); });
+    it('should call onChangeRelationType on mount for ConnectionRelationTypeSelector, if available relation type is only one', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var onChangeRelationType, component;
+        return __generator(this, function (_a) {
+            onChangeRelationType = jest.fn();
+            component = setUpMount({
+                connection: newConnection,
+                relatedEntity: relatedEntity,
+                inRelationTypes: inRelationTypes === null || inRelationTypes === void 0 ? void 0 : inRelationTypes.slice(0, 1),
+                outRelationTypes: [],
+                onChangeRelationType: onChangeRelationType,
+                onChangeEntity: jest.fn()
+            });
+            expect(component.find(ConnectionRelationTypeSelector_1.ConnectionRelationTypeSelector)).toHaveLength(1);
+            expect(onChangeRelationType).toHaveBeenCalledWith({
+                type: 'configuration/relationTypes/IsInCommittee',
+                direction: 'in'
+            });
+            return [2 /*return*/];
+        });
+    }); });
+    it('should call onChangeRelationType for ConnectionRelationTypeSelector, after entity selected and compatible relation type is only one', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var onChangeRelationType, component;
+        return __generator(this, function (_a) {
+            onChangeRelationType = jest.fn();
+            component = setUpMount({
+                connection: newConnection,
+                relatedEntity: relatedEntity,
+                inRelationTypes: inRelationTypes,
+                outRelationTypes: outRelationTypes,
+                onChangeRelationType: onChangeRelationType,
+                onChangeEntity: jest.fn()
+            });
+            expect(component.find(ConnectionRelationTypeSelector_1.ConnectionRelationTypeSelector)).toHaveLength(1);
+            component.setProps({
+                connection: __assign(__assign({}, newConnection), { entity: {
+                        uri: 'entities/entityCommittee',
+                        type: 'configuration/entityTypes/Committee'
+                    } })
+            });
+            component.update();
+            expect(onChangeRelationType).toHaveBeenCalledWith({
+                type: 'configuration/relationTypes/IsInCommittee',
+                direction: 'in'
+            });
+            return [2 /*return*/];
+        });
+    }); });
+    it('should call onChangeEntity for EntitySelector', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var onChangeEntity, component, newEntity;
+        return __generator(this, function (_a) {
+            onChangeEntity = jest.fn();
+            component = setUpMount({
+                connection: newConnection,
+                relatedEntity: relatedEntity,
+                inRelationTypes: inRelationTypes,
+                outRelationTypes: outRelationTypes,
+                onChangeRelationType: jest.fn(),
+                onChangeEntity: onChangeEntity
+            });
+            newEntity = {
+                uri: 'entities/entityCommittee',
+                type: 'configuration/entityTypes/Committee'
+            };
+            (0, test_utils_1.act)(function () {
+                component.find(EntitySelector_1.EntitySelector).prop('onChange')(newEntity);
+            });
+            component.update();
+            expect(onChangeEntity).toHaveBeenCalledWith(newEntity);
+            return [2 /*return*/];
+        });
+    }); });
+});

package/cjs/ConnectionRelationTypeSelector/ConnectionRelationTypeSelector.d.ts

@@ -0,0 +1,36 @@
+export function ConnectionRelationTypeSelector({ relation, inRelationTypes, outRelationTypes, onChange, applyFirstByDefault, reversedContextLabels, ...otherProps }: {
+    [x: string]: any;
+    relation?: {};
+    inRelationTypes?: any[];
+    outRelationTypes?: any[];
+    onChange?: any;
+    applyFirstByDefault?: boolean;
+    reversedContextLabels?: boolean;
+}): JSX.Element;
+export namespace ConnectionRelationTypeSelector {
+    namespace propTypes {
+        export let className: PropTypes.Requireable<string>;
+        export { ConnectionRelationType as relation };
+        export let inRelationTypes: PropTypes.Requireable<PropTypes.InferProps<{
+            label: PropTypes.Requireable<string>;
+            uri: PropTypes.Requireable<string>;
+            typeColor: PropTypes.Requireable<string>;
+            direction: PropTypes.Requireable<string>;
+            startObject: PropTypes.Requireable<object>;
+            endObject: PropTypes.Requireable<object>;
+        }>[]>;
+        export let outRelationTypes: PropTypes.Requireable<PropTypes.InferProps<{
+            label: PropTypes.Requireable<string>;
+            uri: PropTypes.Requireable<string>;
+            typeColor: PropTypes.Requireable<string>;
+            direction: PropTypes.Requireable<string>;
+            startObject: PropTypes.Requireable<object>;
+            endObject: PropTypes.Requireable<object>;
+        }>[]>;
+        export let applyFirstByDefault: PropTypes.Requireable<boolean>;
+        export let reversedContextLabels: PropTypes.Requireable<boolean>;
+        export let onChange: PropTypes.Requireable<(...args: any[]) => any>;
+    }
+}
+import PropTypes from 'prop-types';
+import { ConnectionRelationType } from '@reltio/mdm-sdk';

package/cjs/ConnectionRelationTypeSelector/ConnectionRelationTypeSelector.js

@@ -0,0 +1,85 @@
+"use strict";
+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);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionRelationTypeSelector = void 0;
+var react_1 = __importStar(require("react"));
+var prop_types_1 = __importDefault(require("prop-types"));
+var mdm_sdk_1 = require("@reltio/mdm-sdk");
+var ramda_1 = require("ramda");
+var useRelationTypeSelector_1 = require("../hooks/useRelationTypeSelector");
+var RelationTypeSelector_1 = require("../RelationTypeSelector");
+var ConnectionRelationTypeSelector = function (_a) {
+    var _b = _a.relation, relation = _b === void 0 ? {} : _b, _c = _a.inRelationTypes, inRelationTypes = _c === void 0 ? [] : _c, _d = _a.outRelationTypes, outRelationTypes = _d === void 0 ? [] : _d, _e = _a.onChange, onChange = _e === void 0 ? ramda_1.identity : _e, _f = _a.applyFirstByDefault, applyFirstByDefault = _f === void 0 ? false : _f, _g = _a.reversedContextLabels, reversedContextLabels = _g === void 0 ? false : _g, otherProps = __rest(_a, ["relation", "inRelationTypes", "outRelationTypes", "onChange", "applyFirstByDefault", "reversedContextLabels"]);
+    var _h = (0, useRelationTypeSelector_1.useRelationTypeSelector)({ reversedContextLabels: reversedContextLabels }), getRelationTypesOptions = _h.getRelationTypesOptions, fromEditorValue = _h.fromEditorValue, toEditorValue = _h.toEditorValue;
+    var relationsTypesOptions = (0, react_1.useMemo)(function () { return getRelationTypesOptions(inRelationTypes, outRelationTypes); }, [getRelationTypesOptions, inRelationTypes, outRelationTypes]);
+    var handleChange = (0, react_1.useCallback)((0, ramda_1.pipe)(fromEditorValue(inRelationTypes, outRelationTypes), onChange), [
+        fromEditorValue,
+        inRelationTypes,
+        outRelationTypes,
+        onChange
+    ]);
+    var hasValue = !!relation.relationType;
+    (0, react_1.useEffect)(function () {
+        if (applyFirstByDefault && relationsTypesOptions.length && !hasValue) {
+            handleChange(relationsTypesOptions[0]);
+        }
+    }, [relationsTypesOptions, applyFirstByDefault, handleChange, hasValue]);
+    return (react_1.default.createElement(RelationTypeSelector_1.RelationTypeSelector, __assign({ value: toEditorValue(relation, relationsTypesOptions), options: relationsTypesOptions, onChange: handleChange }, otherProps)));
+};
+exports.ConnectionRelationTypeSelector = ConnectionRelationTypeSelector;
+exports.ConnectionRelationTypeSelector.propTypes = {
+    className: prop_types_1.default.string,
+    relation: mdm_sdk_1.ConnectionRelationType,
+    inRelationTypes: prop_types_1.default.arrayOf(mdm_sdk_1.RelationTypeType),
+    outRelationTypes: prop_types_1.default.arrayOf(mdm_sdk_1.RelationTypeType),
+    applyFirstByDefault: prop_types_1.default.bool,
+    reversedContextLabels: prop_types_1.default.bool,
+    onChange: prop_types_1.default.func
+};

package/cjs/ConnectionRelationTypeSelector/ConnectionRelationTypeSelector.test.d.ts

@@ -0,0 +1 @@
+export {};