@contrail/cli 1.0.67 → 1.0.69

package/lib/types/types-properties-merger.js

@@ -1,75 +1,75 @@
-import { getOptionSets, getTypes, reduceData } from './types-extractor';
-import fs from 'fs';
-import { getSeparatorByPlatform } from '../common';
-import { authUser } from '../auth/login';
-import chalk from 'chalk';
-const yaml = require('js-yaml');
-export async function MergeTypeProperties(args) {
-    try {
-        if ((args === null || args === void 0 ? void 0 : args.length) < 5) {
-            throw new Error('File name must be included along with a type path.');
-        }
-        console.log('%s Importing local file', chalk.yellow.bold('TYPE PROPERTIES MERGE'));
-        const fileLocation = args[3];
-        console.log('Using File: ', fileLocation);
-        const typePaths = args.slice(4);
-        console.log('Using TypePaths: ', typePaths);
-        await mergeTypeProperties(fileLocation, typePaths);
-        console.log('%s Merged', chalk.yellow.bold('TYPE PROPERTIES MERGE'));
-    }
-    catch (e) {
-        console.log(`%s Merge Failed. ${e}`, chalk.red.bold('FAIL'));
-        return;
-    }
-    console.log('%s Merge Complete.', chalk.green.bold('COMPLETE'));
-}
-function loadTypeProperties(fileLocation) {
-    const TARGET_DIR = process.cwd();
-    try {
-        const separator = getSeparatorByPlatform();
-        const fullPath = TARGET_DIR + separator + fileLocation;
-        console.log('Getting file from path: ', fullPath);
-        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + fileLocation, 'utf8'));
-        return doc.typeProperties;
-    }
-    catch (e) {
-        throw new Error(`ERROR PARSING YAML: ${e}`);
-    }
-}
-async function mergeTypeProperties(fileLocation, typePaths) {
-    const uploadedTypeProperties = loadTypeProperties(fileLocation);
-    await authUser();
-    const data = {
-        types: await getTypes(),
-        optionSets: await getOptionSets(),
-        optionSetHierarchies: [],
-        ruleSets: [],
-        ruleSetLinks: [],
-        usageInfo: [],
-        typePropertyPolicies: [],
-        typePropertyPolicyLinks: [],
-    };
-    const reducedData = await reduceData(data);
-    for (const typePath of typePaths) {
-        const foundType = reducedData.reducedTypes.find(reducedTypes => reducedTypes.typePath === typePath);
-        if (!foundType) {
-            console.log(`%s No Type found for: ${typePath}`, chalk.red.bold('WARNING'));
-        }
-        mergeType(foundType, uploadedTypeProperties);
-    }
-    saveData({ types: reducedData.reducedTypes });
-}
-function mergeType(reducedType, typePropertiesToAdd) {
-    for (const typeProperty of typePropertiesToAdd) {
-        const found = reducedType.typeProperties.find(tp => tp.slug === typeProperty.slug);
-        if (!found) {
-            reducedType.typeProperties.push(typeProperty);
-        }
-    }
-}
-function saveData(data) {
-    const yamlStr = yaml.dump(data);
-    const CURRENT_DIR = process.cwd();
-    const separator = getSeparatorByPlatform();
-    fs.writeFileSync(CURRENT_DIR + separator + 'merged_types.yml', yamlStr, 'utf8');
-}
+import { getOptionSets, getTypes, reduceData } from './types-extractor';
+import fs from 'fs';
+import { getSeparatorByPlatform } from '../common';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+const yaml = require('js-yaml');
+export async function MergeTypeProperties(args) {
+    try {
+        if ((args === null || args === void 0 ? void 0 : args.length) < 5) {
+            throw new Error('File name must be included along with a type path.');
+        }
+        console.log('%s Importing local file', chalk.yellow.bold('TYPE PROPERTIES MERGE'));
+        const fileLocation = args[3];
+        console.log('Using File: ', fileLocation);
+        const typePaths = args.slice(4);
+        console.log('Using TypePaths: ', typePaths);
+        await mergeTypeProperties(fileLocation, typePaths);
+        console.log('%s Merged', chalk.yellow.bold('TYPE PROPERTIES MERGE'));
+    }
+    catch (e) {
+        console.log(`%s Merge Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Merge Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadTypeProperties(fileLocation) {
+    const TARGET_DIR = process.cwd();
+    try {
+        const separator = getSeparatorByPlatform();
+        const fullPath = TARGET_DIR + separator + fileLocation;
+        console.log('Getting file from path: ', fullPath);
+        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + fileLocation, 'utf8'));
+        return doc.typeProperties;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function mergeTypeProperties(fileLocation, typePaths) {
+    const uploadedTypeProperties = loadTypeProperties(fileLocation);
+    await authUser();
+    const data = {
+        types: await getTypes(),
+        optionSets: await getOptionSets(),
+        optionSetHierarchies: [],
+        ruleSets: [],
+        ruleSetLinks: [],
+        usageInfo: [],
+        typePropertyPolicies: [],
+        typePropertyPolicyLinks: [],
+    };
+    const reducedData = await reduceData(data);
+    for (const typePath of typePaths) {
+        const foundType = reducedData.reducedTypes.find(reducedTypes => reducedTypes.typePath === typePath);
+        if (!foundType) {
+            console.log(`%s No Type found for: ${typePath}`, chalk.red.bold('WARNING'));
+        }
+        mergeType(foundType, uploadedTypeProperties);
+    }
+    saveData({ types: reducedData.reducedTypes });
+}
+function mergeType(reducedType, typePropertiesToAdd) {
+    for (const typeProperty of typePropertiesToAdd) {
+        const found = reducedType.typeProperties.find(tp => tp.slug === typeProperty.slug);
+        if (!found) {
+            reducedType.typeProperties.push(typeProperty);
+        }
+    }
+}
+function saveData(data) {
+    const yamlStr = yaml.dump(data);
+    const CURRENT_DIR = process.cwd();
+    const separator = getSeparatorByPlatform();
+    fs.writeFileSync(CURRENT_DIR + separator + 'merged_types.yml', yamlStr, 'utf8');
+}

package/lib/types/types-uploader.d.ts

@@ -1 +1 @@
-export declare function uploadTypes(): Promise<void>;
+export declare function uploadTypes(): Promise<void>;

package/lib/types/types-uploader.js

@@ -1,239 +1,239 @@
-import { Entities, Request } from '@contrail/sdk';
-import chalk from 'chalk';
-import fs from 'fs';
-import { authUser } from '../auth/login';
-import * as path from 'path';
-import * as _ from 'lodash';
-import yaml from 'js-yaml';
-export async function uploadTypes() {
-    try {
-        const userConfig = await authUser();
-        console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
-        console.log('%s Uploading', chalk.yellow.bold('TYPES'));
-        await uploadReducedTypes();
-        console.log('%s Uploaded', chalk.yellow.bold('TYPES'));
-    }
-    catch (e) {
-        console.log(`%s Types Upload Failed. ${e}`, chalk.red.bold('FAIL'));
-        return;
-    }
-    console.log('%s Types Upload Complete.', chalk.green.bold('COMPLETE'));
-}
-function loadReducedTypes() {
-    const TARGET_DIR = process.cwd();
-    try {
-        const files = fs.readdirSync(path.join(TARGET_DIR, 'types'));
-        const types = [];
-        for (const file of files) {
-            types.push(...yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'types', file), 'utf8')));
-        }
-        return types;
-    }
-    catch (e) {
-        throw new Error(`ERROR PARSING YAML: ${e}`);
-    }
-}
-async function uploadReducedTypes() {
-    const types = loadReducedTypes();
-    const currentTypesWithoutProperties = await new Entities().get({
-        entityName: 'type',
-    });
-    const currentTypes = [];
-    for (const currentTypeWithoutProperties of currentTypesWithoutProperties) {
-        const typeWithProperties = await new Entities().get({
-            entityName: 'type',
-            id: currentTypeWithoutProperties.id,
-            relations: ['typeProperties'],
-        });
-        currentTypes.push(typeWithProperties);
-    }
-    const currentTypesBySlug = {};
-    for (const currentType of currentTypes) {
-        currentTypesBySlug[currentType.slug] = currentType;
-    }
-    const newTypesBySlug = {};
-    for (const type of types) {
-        newTypesBySlug[type.slug] = type;
-    }
-    for (const type of types) {
-        try {
-            const found = currentTypesBySlug[type.slug];
-            if (!found) {
-                if (!type.typePath.includes(':')) {
-                    console.log('Cannot create a base type. Skipping: ', type.slug);
-                    continue;
-                }
-                console.log('Creating Type: ', type.slug);
-                const createdType = await new Entities().create({
-                    entityName: 'type',
-                    object: {
-                        slug: type.slug,
-                        label: type.label,
-                        typePath: type.typePath,
-                        isArchived: type.isArchived,
-                    },
-                });
-                await uploadReducedTypeProperties(createdType, [], type.typeProperties);
-            }
-            else {
-                console.log('Updating Type: ', type.slug);
-                const updatedType = await new Entities().update({
-                    entityName: 'type',
-                    id: found.id,
-                    object: {
-                        slug: type.slug,
-                        label: type.label,
-                        typePath: type.typePath,
-                        isArchived: type.isArchived,
-                    },
-                });
-                await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties);
-            }
-        }
-        catch (err) {
-            console.log('Error Uploading Types: ', err);
-        }
-    }
-    for (const currentType of currentTypes) {
-        try {
-            const found = newTypesBySlug[currentType.slug];
-            if (!found) {
-                console.log('Deleting Type: ', currentType.slug);
-                await new Entities().delete({
-                    entityName: 'type',
-                    id: currentType.id,
-                });
-            }
-        }
-        catch (err) {
-            throw new Error(`Error Deleting Types: ${err}`);
-        }
-    }
-}
-async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes) {
-    const currentPropertyTypeBySlug = {};
-    for (const currentPropertyType of currentPropertyTypes) {
-        currentPropertyTypeBySlug[currentPropertyType.slug] = currentPropertyType;
-    }
-    const newPropertyTypesBySlug = {};
-    for (const newPropertyType of newPropertyTypes) {
-        newPropertyTypesBySlug[newPropertyType.slug] = newPropertyType;
-    }
-    const optionSets = await new Entities().get({
-        entityName: 'type-property-option-set',
-    });
-    const optionSetIdByName = {};
-    for (const optionSet of optionSets) {
-        optionSetIdByName[optionSet.name] = optionSet.id;
-    }
-    for (const newPropertyType of newPropertyTypes) {
-        try {
-            const found = currentPropertyTypeBySlug[newPropertyType.slug];
-            if (!found && !newPropertyType.inherited) {
-                console.log('Creating Type-Property: ', newPropertyType.slug);
-                await Request.request(`/types/${type.id}/type-properties`, {
-                    method: 'POST',
-                    body: JSON.stringify({
-                        isArchived: newPropertyType.isArchived,
-                        propertyType: newPropertyType.propertyType,
-                        slug: newPropertyType.slug,
-                        label: newPropertyType.label,
-                        editable: newPropertyType.editable,
-                        searchable: newPropertyType.searchable,
-                        core: newPropertyType.core,
-                        typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
-                        formula: newPropertyType.formula,
-                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
-                        defaultValue: newPropertyType.defaultValue,
-                        propertyLevel: newPropertyType.propertyLevel,
-                        formulaFunction: newPropertyType.formulaFunction,
-                        validationFunction: newPropertyType.validationFunction,
-                    }),
-                    headers: {
-                        Accept: 'application/json',
-                        'Content-Type': 'application/json',
-                    },
-                });
-            }
-            else if (found && !newPropertyType.inherited && !typePropertiesEqual(found, newPropertyType, optionSetIdByName)) {
-                console.log('Updating Type-Property: ', newPropertyType.slug);
-                await new Entities().update({
-                    entityName: 'type-property',
-                    id: found.id,
-                    object: {
-                        isArchived: newPropertyType.isArchived,
-                        propertyType: newPropertyType.propertyType,
-                        slug: newPropertyType.slug,
-                        label: newPropertyType.label,
-                        editable: newPropertyType.editable,
-                        searchable: newPropertyType.searchable,
-                        core: newPropertyType.core,
-                        typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
-                        formula: newPropertyType.formula,
-                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
-                        defaultValue: newPropertyType.defaultValue,
-                        propertyLevel: newPropertyType.propertyLevel,
-                        formulaFunction: newPropertyType.formulaFunction,
-                        validationFunction: newPropertyType.validationFunction,
-                    },
-                });
-            }
-        }
-        catch (err) {
-            console.log('Error Creating Properties: ', err);
-        }
-    }
-    for (const currentPropertyType of currentPropertyTypes) {
-        try {
-            const found = newPropertyTypesBySlug[currentPropertyType.slug];
-            if (!found && !currentPropertyType.inherited) {
-                console.log('Deleting Type-Property: ', currentPropertyType.slug);
-                await Request.request(`/types/${type.id}/type-properties/${currentPropertyType.id}`, {
-                    method: 'DELETE',
-                    headers: {
-                        Accept: 'application/json',
-                        'Content-Type': 'application/json',
-                    },
-                });
-            }
-        }
-        catch (err) {
-            throw new Error(`Error Deleting Properties: ${err}`);
-        }
-    }
-}
-function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName) {
-    const reducedProperty1 = {
-        isArchived: typeProperty1.isArchived,
-        propertyType: typeProperty1.propertyType,
-        slug: typeProperty1.slug,
-        label: typeProperty1.label,
-        editable: typeProperty1.editable,
-        searchable: typeProperty1.searchable,
-        core: typeProperty1.core,
-        typePropertyOptionSetId: optionSetIdByName[typeProperty1.typePropertyOptionSetName],
-        formula: typeProperty1.formula,
-        referencedTypeRootSlug: typeProperty1.referencedTypeRootSlug,
-        defaultValue: typeProperty1.defaultValue,
-        propertyLevel: typeProperty1.propertyLevel,
-        formulaFunction: typeProperty1.formulaFunction,
-        validationFunction: typeProperty1.validationFunction,
-    };
-    const reducedProperty2 = {
-        isArchived: typeProperty2.isArchived,
-        propertyType: typeProperty2.propertyType,
-        slug: typeProperty2.slug,
-        label: typeProperty2.label,
-        editable: typeProperty2.editable,
-        searchable: typeProperty2.searchable,
-        core: typeProperty2.core,
-        typePropertyOptionSetId: optionSetIdByName[typeProperty2.typePropertyOptionSetName],
-        formula: typeProperty2.formula,
-        referencedTypeRootSlug: typeProperty2.referencedTypeRootSlug,
-        defaultValue: typeProperty2.defaultValue,
-        propertyLevel: typeProperty2.propertyLevel,
-        formulaFunction: typeProperty2.formulaFunction,
-        validationFunction: typeProperty2.validationFunction,
-    };
-    return _.isEqual(reducedProperty1, reducedProperty2);
-}
+import { Entities, Request } from '@contrail/sdk';
+import chalk from 'chalk';
+import fs from 'fs';
+import { authUser } from '../auth/login';
+import * as path from 'path';
+import * as _ from 'lodash';
+import yaml from 'js-yaml';
+export async function uploadTypes() {
+    try {
+        const userConfig = await authUser();
+        console.log(`%s Getting all types for orgId: ${userConfig.orgId}`, chalk.blue.bold('START'));
+        console.log('%s Uploading', chalk.yellow.bold('TYPES'));
+        await uploadReducedTypes();
+        console.log('%s Uploaded', chalk.yellow.bold('TYPES'));
+    }
+    catch (e) {
+        console.log(`%s Types Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Types Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadReducedTypes() {
+    const TARGET_DIR = process.cwd();
+    try {
+        const files = fs.readdirSync(path.join(TARGET_DIR, 'types'));
+        const types = [];
+        for (const file of files) {
+            types.push(...yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'types', file), 'utf8')));
+        }
+        return types;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function uploadReducedTypes() {
+    const types = loadReducedTypes();
+    const currentTypesWithoutProperties = await new Entities().get({
+        entityName: 'type',
+    });
+    const currentTypes = [];
+    for (const currentTypeWithoutProperties of currentTypesWithoutProperties) {
+        const typeWithProperties = await new Entities().get({
+            entityName: 'type',
+            id: currentTypeWithoutProperties.id,
+            relations: ['typeProperties'],
+        });
+        currentTypes.push(typeWithProperties);
+    }
+    const currentTypesBySlug = {};
+    for (const currentType of currentTypes) {
+        currentTypesBySlug[currentType.slug] = currentType;
+    }
+    const newTypesBySlug = {};
+    for (const type of types) {
+        newTypesBySlug[type.slug] = type;
+    }
+    for (const type of types) {
+        try {
+            const found = currentTypesBySlug[type.slug];
+            if (!found) {
+                if (!type.typePath.includes(':')) {
+                    console.log('Cannot create a base type. Skipping: ', type.slug);
+                    continue;
+                }
+                console.log('Creating Type: ', type.slug);
+                const createdType = await new Entities().create({
+                    entityName: 'type',
+                    object: {
+                        slug: type.slug,
+                        label: type.label,
+                        typePath: type.typePath,
+                        isArchived: type.isArchived,
+                    },
+                });
+                await uploadReducedTypeProperties(createdType, [], type.typeProperties);
+            }
+            else {
+                console.log('Updating Type: ', type.slug);
+                const updatedType = await new Entities().update({
+                    entityName: 'type',
+                    id: found.id,
+                    object: {
+                        slug: type.slug,
+                        label: type.label,
+                        typePath: type.typePath,
+                        isArchived: type.isArchived,
+                    },
+                });
+                await uploadReducedTypeProperties(updatedType, found.typeProperties, type.typeProperties);
+            }
+        }
+        catch (err) {
+            console.log('Error Uploading Types: ', err);
+        }
+    }
+    for (const currentType of currentTypes) {
+        try {
+            const found = newTypesBySlug[currentType.slug];
+            if (!found) {
+                console.log('Deleting Type: ', currentType.slug);
+                await new Entities().delete({
+                    entityName: 'type',
+                    id: currentType.id,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting Types: ${err}`);
+        }
+    }
+}
+async function uploadReducedTypeProperties(type, currentPropertyTypes, newPropertyTypes) {
+    const currentPropertyTypeBySlug = {};
+    for (const currentPropertyType of currentPropertyTypes) {
+        currentPropertyTypeBySlug[currentPropertyType.slug] = currentPropertyType;
+    }
+    const newPropertyTypesBySlug = {};
+    for (const newPropertyType of newPropertyTypes) {
+        newPropertyTypesBySlug[newPropertyType.slug] = newPropertyType;
+    }
+    const optionSets = await new Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    const optionSetIdByName = {};
+    for (const optionSet of optionSets) {
+        optionSetIdByName[optionSet.name] = optionSet.id;
+    }
+    for (const newPropertyType of newPropertyTypes) {
+        try {
+            const found = currentPropertyTypeBySlug[newPropertyType.slug];
+            if (!found && !newPropertyType.inherited) {
+                console.log('Creating Type-Property: ', newPropertyType.slug);
+                await Request.request(`/types/${type.id}/type-properties`, {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        isArchived: newPropertyType.isArchived,
+                        propertyType: newPropertyType.propertyType,
+                        slug: newPropertyType.slug,
+                        label: newPropertyType.label,
+                        editable: newPropertyType.editable,
+                        searchable: newPropertyType.searchable,
+                        core: newPropertyType.core,
+                        typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
+                        formula: newPropertyType.formula,
+                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+                        defaultValue: newPropertyType.defaultValue,
+                        propertyLevel: newPropertyType.propertyLevel,
+                        formulaFunction: newPropertyType.formulaFunction,
+                        validationFunction: newPropertyType.validationFunction,
+                    }),
+                    headers: {
+                        Accept: 'application/json',
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+            else if (found && !newPropertyType.inherited && !typePropertiesEqual(found, newPropertyType, optionSetIdByName)) {
+                console.log('Updating Type-Property: ', newPropertyType.slug);
+                await new Entities().update({
+                    entityName: 'type-property',
+                    id: found.id,
+                    object: {
+                        isArchived: newPropertyType.isArchived,
+                        propertyType: newPropertyType.propertyType,
+                        slug: newPropertyType.slug,
+                        label: newPropertyType.label,
+                        editable: newPropertyType.editable,
+                        searchable: newPropertyType.searchable,
+                        core: newPropertyType.core,
+                        typePropertyOptionSetId: optionSetIdByName[newPropertyType.typePropertyOptionSetName],
+                        formula: newPropertyType.formula,
+                        referencedTypeRootSlug: newPropertyType.referencedTypeRootSlug,
+                        defaultValue: newPropertyType.defaultValue,
+                        propertyLevel: newPropertyType.propertyLevel,
+                        formulaFunction: newPropertyType.formulaFunction,
+                        validationFunction: newPropertyType.validationFunction,
+                    },
+                });
+            }
+        }
+        catch (err) {
+            console.log('Error Creating Properties: ', err);
+        }
+    }
+    for (const currentPropertyType of currentPropertyTypes) {
+        try {
+            const found = newPropertyTypesBySlug[currentPropertyType.slug];
+            if (!found && !currentPropertyType.inherited) {
+                console.log('Deleting Type-Property: ', currentPropertyType.slug);
+                await Request.request(`/types/${type.id}/type-properties/${currentPropertyType.id}`, {
+                    method: 'DELETE',
+                    headers: {
+                        Accept: 'application/json',
+                        'Content-Type': 'application/json',
+                    },
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting Properties: ${err}`);
+        }
+    }
+}
+function typePropertiesEqual(typeProperty1, typeProperty2, optionSetIdByName) {
+    const reducedProperty1 = {
+        isArchived: typeProperty1.isArchived,
+        propertyType: typeProperty1.propertyType,
+        slug: typeProperty1.slug,
+        label: typeProperty1.label,
+        editable: typeProperty1.editable,
+        searchable: typeProperty1.searchable,
+        core: typeProperty1.core,
+        typePropertyOptionSetId: optionSetIdByName[typeProperty1.typePropertyOptionSetName],
+        formula: typeProperty1.formula,
+        referencedTypeRootSlug: typeProperty1.referencedTypeRootSlug,
+        defaultValue: typeProperty1.defaultValue,
+        propertyLevel: typeProperty1.propertyLevel,
+        formulaFunction: typeProperty1.formulaFunction,
+        validationFunction: typeProperty1.validationFunction,
+    };
+    const reducedProperty2 = {
+        isArchived: typeProperty2.isArchived,
+        propertyType: typeProperty2.propertyType,
+        slug: typeProperty2.slug,
+        label: typeProperty2.label,
+        editable: typeProperty2.editable,
+        searchable: typeProperty2.searchable,
+        core: typeProperty2.core,
+        typePropertyOptionSetId: optionSetIdByName[typeProperty2.typePropertyOptionSetName],
+        formula: typeProperty2.formula,
+        referencedTypeRootSlug: typeProperty2.referencedTypeRootSlug,
+        defaultValue: typeProperty2.defaultValue,
+        propertyLevel: typeProperty2.propertyLevel,
+        formulaFunction: typeProperty2.formulaFunction,
+        validationFunction: typeProperty2.validationFunction,
+    };
+    return _.isEqual(reducedProperty1, reducedProperty2);
+}

package/lib/types/usage-info-uploader.d.ts

@@ -1 +1 @@
-export declare function uploadUsageInfo(args: any): Promise<void>;
+export declare function uploadUsageInfo(args: any): Promise<void>;