@contrail/cli 1.0.54 → 1.0.56

package/lib/cli.js

@@ -1,6 +1,6 @@
 import { create } from './apps/create-app/create';
 import { deployApp, removeApp } from './apps/deploy-app/deploy';
-import { getTypes } from './types/types-extractor';
+import { getAll } from './types/types-extractor';
 import { uploadTypes } from './types/types-uploader';
 import { UploadOptionSets } from './types/option-set-uploader';
 import { ParseOptionSetsLocalFiles } from './types/option-set-parser';
@@ -18,6 +18,11 @@ import { cliInstallWorkflowTemplateDefinitions, listWorkflowTemplateDefinitions
 import { configureProject } from './projects/project-uploader';
 import { ListProjects, ExportProject } from './projects/project-exporter';
 import { Load, UploadAndLoad } from './loader-process/loader-process';
+import { uploadUsageInfo } from './types/usage-info-uploader';
+import { uploadRuleSets } from './types/rule-set-uploader';
+import { UploadOptionSetHierarchies } from './types/option-set-hierarchy-uploader';
+import { uploadTypePropertyPolicies } from './types/type-property-policy-uploader';
+import { uploadAll } from './types/allUploader';
 const cliUsage = require('command-line-usage');
 /**
  *  Built using documentation here:
@@ -79,7 +84,11 @@ export async function cli(args) {
         case 'types': {
             switch (command) {
                 case 'getAll': {
-                    getTypes(args);
+                    getAll(args);
+                    break;
+                }
+                case 'uploadAll': {
+                    uploadAll();
                     break;
                 }
                 case 'uploadTypes': {
@@ -106,6 +115,22 @@ export async function cli(args) {
                     ExportOptionSetsHierarchies();
                     break;
                 }
+                case 'uploadOptionSetsHierarchies': {
+                    UploadOptionSetHierarchies(args);
+                    break;
+                }
+                case 'uploadRuleSets': {
+                    uploadRuleSets(args);
+                    break;
+                }
+                case 'uploadUsageInfo': {
+                    uploadUsageInfo(args);
+                    break;
+                }
+                case 'uploadTypePropertyPolicies': {
+                    uploadTypePropertyPolicies(args);
+                    break;
+                }
                 case 'parseTypesFromLocalFiles': {
                     ParseTypesFromLocalFiles(args);
                     break;
@@ -403,6 +428,30 @@ const helpSections = [
                 name: 'exportOptionSetsHierarchies',
                 summary: 'export OptionSetHierarchies into CSVs.\n'
             },
+            {
+                name: 'uploadAll',
+                summary: 'Upload an extracted archive of types:getAll.'
+            },
+            {
+                name: 'uploadOptionSetsHierarchies',
+                summary: 'Upload an extracted option set hierarchies.'
+            },
+            {
+                name: 'uploadRuleSets',
+                summary: 'Upload an extracted rule set.'
+            },
+            {
+                name: 'uploadUsageInfo',
+                summary: 'Upload extracted usage info.'
+            },
+            {
+                name: 'uploadTypePropertyPolicies',
+                summary: 'Upload type property policies.'
+            },
+            {
+                name: 'uploadOptionSetsHierarchyLocalFiles <File Paths> <name>',
+                summary: 'upload CSV files into OptionSetHierarchies.'
+            },
             {
                 name: 'parseTypesFromLocalFiles <File Paths>',
                 summary: 'Parse CSV files into Types and OptionSets from local files.\n'

package/lib/types/allUploader.d.ts

@@ -0,0 +1 @@
+export declare function uploadAll(): Promise<void>;

package/lib/types/allUploader.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { authUser } from '../auth/login';
+import { UploadOptionSets } from './option-set-uploader';
+import { UploadOptionSetHierarchies } from './option-set-hierarchy-uploader';
+import { uploadTypes } from './types-uploader';
+import { uploadUsageInfo } from './usage-info-uploader';
+import { uploadRuleSets } from './rule-set-uploader';
+import { uploadTypePropertyPolicies } from './type-property-policy-uploader';
+export async function uploadAll() {
+    try {
+        await authUser();
+        await UploadOptionSets(null);
+        await UploadOptionSetHierarchies(null);
+        await uploadTypes();
+        await uploadUsageInfo(null);
+        await uploadRuleSets(null);
+        await uploadTypePropertyPolicies(null);
+    }
+    catch (e) {
+        console.log(`%s Types Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Types Upload Complete.', chalk.green.bold('COMPLETE'));
+}

package/lib/types/option-set-hierarchy-uploader.d.ts

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

package/lib/types/option-set-hierarchy-uploader.js

@@ -0,0 +1,113 @@
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import * as path from 'path';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+const yaml = require('js-yaml');
+export async function UploadOptionSetHierarchies(args) {
+    try {
+        await authUser();
+        console.log('%s Uploading', chalk.yellow.bold('OPTION SET HIERARCHIES'));
+        const optionSetHierarchies = await loadOptionSetHierarchies();
+        await uploadOptionSetHierarchies(optionSetHierarchies);
+        console.log('%s Uploaded', chalk.yellow.bold('OPTION SET HIERARCHIES'));
+    }
+    catch (e) {
+        console.log(`%s Option set hierarchy Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Option set hierarchy Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadOptionSetHierarchies() {
+    const TARGET_DIR = process.cwd();
+    try {
+        const files = fs.readdirSync(path.join(TARGET_DIR, 'option-set-hierarchies'));
+        const OSHs = [];
+        for (const file of files) {
+            OSHs.push(yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'option-set-hierarchies', file), 'utf8')));
+        }
+        return OSHs;
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function uploadOptionSetHierarchies(loadedOSHs) {
+    const optionSets = await new Entities().get({
+        entityName: 'type-property-option-set',
+    });
+    const currentOSHs = await new Entities().get({
+        entityName: 'option-set-hierarchy',
+    });
+    const optionSetsByName = {};
+    for (const optionSet of optionSets) {
+        optionSetsByName[optionSet.name] = optionSet;
+    }
+    const currentOSHByName = {};
+    for (const currentOSH of currentOSHs) {
+        currentOSHByName[currentOSH.name] = currentOSH;
+    }
+    const loadedOSHByName = {};
+    for (const loadedOSH of loadedOSHs) {
+        loadedOSHByName[loadedOSH.name] = loadedOSH;
+    }
+    console.debug('current OSH:', currentOSHs);
+    console.debug('loaded OSH:', loadedOSHs);
+    for (const osh of loadedOSHs) {
+        try {
+            const found = currentOSHByName[osh.name];
+            if (!found) {
+                if (!transformOSHNameToID(osh.hierarchy, optionSets)) {
+                    continue;
+                }
+                console.log('Creating: ', osh);
+                await new Entities().create({
+                    entityName: 'option-set-hierarchy',
+                    object: osh
+                });
+            }
+            else {
+                if (!transformOSHNameToID(osh.hierarchy, optionSets)) {
+                    continue;
+                }
+                console.log('Updating: ', osh);
+                await new Entities().update({
+                    entityName: 'option-set-hierarchy',
+                    id: found.id,
+                    object: osh,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading option set hierarchy: ${err}`);
+        }
+    }
+    for (const currentOSH of currentOSHs) {
+        try {
+            const found = loadedOSHByName[currentOSH.name];
+            if (!found) {
+                console.log('Deleting: ', currentOSH.name);
+                await new Entities().delete({
+                    entityName: 'option-set-hierarchy',
+                    id: currentOSH.id,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting Option set hierarchy: ${err}`);
+        }
+    }
+}
+// transforms the passed hierarchy from names to ids, and returns true if operation succeeded.
+function transformOSHNameToID(hierarchy, optionSets) {
+    console.log('passed hierarhy:', hierarchy);
+    for (let i = 0; i < hierarchy.length; i++) {
+        const os = optionSets.find(os => os.name === hierarchy[i]);
+        if (!os) {
+            console.error('could not find option set with name', hierarchy[i], ' at position', i, 'skipping...');
+            return false;
+        }
+        hierarchy[i] = os.id;
+    }
+    return true;
+}

package/lib/types/option-set-uploader.js

@@ -1,6 +1,6 @@
 import { Entities } from '@contrail/sdk';
 import fs from 'fs';
-import { getSeparatorByPlatform } from '../common';
+import * as path from 'path';
 import { authUser } from '../auth/login';
 import chalk from 'chalk';
 const yaml = require('js-yaml');
@@ -21,9 +21,12 @@ export async function UploadOptionSets(args) {
 function loadOptionSets() {
     const TARGET_DIR = process.cwd();
     try {
-        const separator = getSeparatorByPlatform();
-        const doc = yaml.load(fs.readFileSync(TARGET_DIR + separator + 'option_sets.yml', 'utf8'));
-        return doc.optionSets;
+        const files = fs.readdirSync(path.join(TARGET_DIR, 'option-sets'));
+        const optionSets = [];
+        for (const file of files) {
+            optionSets.push(yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'option-sets', file), 'utf8')));
+        }
+        return optionSets;
     }
     catch (e) {
         throw new Error(`ERROR PARSING YAML: ${e}`);

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

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

package/lib/types/rule-set-uploader.js

@@ -0,0 +1,172 @@
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import * as path from 'path';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+const yaml = require('js-yaml');
+export async function uploadRuleSets(args) {
+    try {
+        await authUser();
+        console.log('%s Uploading', chalk.yellow.bold('RULE SET'));
+        const [reducedRuleSets, reducedRuleSetLinks] = await loadReducedRuleSets();
+        await uploadRuleSetObjects(reducedRuleSets);
+        await uploadRuleSetLinkObjects(reducedRuleSetLinks);
+        console.log('%s Uploaded', chalk.yellow.bold('RULE SET'));
+    }
+    catch (e) {
+        console.log(`%s Rule Set Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Rule set Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadReducedRuleSets() {
+    const ruleSets = [];
+    let ruleSetLinks = [];
+    const TARGET_DIR = process.cwd();
+    try {
+        const files = fs.readdirSync(path.join(TARGET_DIR, 'rule-sets'));
+        for (const file of files) {
+            ruleSets.push(yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'rule-sets', file), 'utf8')));
+        }
+        ruleSetLinks = yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'rule-set-links.yml'), 'utf8'));
+        return [ruleSets, ruleSetLinks];
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function uploadRuleSetObjects(reducedRuleSets) {
+    const currentRuleSets = await new Entities().get({
+        entityName: 'type-rule-set',
+    });
+    const currentRuleSetsByName = {};
+    for (const currentRuleSet of currentRuleSets) {
+        currentRuleSetsByName[currentRuleSet.name] = currentRuleSet;
+    }
+    const loadedRuleSetsByName = {};
+    for (const loadedRuleSet of reducedRuleSets) {
+        loadedRuleSetsByName[loadedRuleSet.name] = loadedRuleSet;
+    }
+    console.debug('current rule sets:', currentRuleSets);
+    console.debug('reduced rule sets:', reducedRuleSets);
+    for (const reducedRuleSet of reducedRuleSets) {
+        try {
+            const found = currentRuleSetsByName[reducedRuleSet.name];
+            if (!found) {
+                console.log('Creating: ', reducedRuleSet.name);
+                await new Entities().create({
+                    entityName: 'type-rule-set',
+                    object: reducedRuleSet
+                });
+            }
+            else {
+                console.log('Updating: ', reducedRuleSet.name);
+                await new Entities().update({
+                    entityName: 'type-rule-set',
+                    id: found.id,
+                    object: reducedRuleSet,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading rule sets: ${err}`);
+        }
+    }
+    for (const currentRuleSet of currentRuleSets) {
+        try {
+            const found = loadedRuleSetsByName[currentRuleSet.name];
+            if (!found) {
+                console.log('Deleting: ', currentRuleSet.name);
+                await new Entities().delete({
+                    entityName: 'type-rule-set',
+                    id: currentRuleSet.id,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting rule set: ${err}`);
+        }
+    }
+}
+async function uploadRuleSetLinkObjects(loadedRuleSetLinks) {
+    const types = await new Entities().get({
+        entityName: 'type',
+    });
+    const currentRuleSets = await new Entities().get({
+        entityName: 'type-rule-set',
+    });
+    const currentRuleSetLinks = await new Entities().get({
+        entityName: 'type-rule-set-link',
+    });
+    const currentLinksHashes = {};
+    for (const currentLink of currentRuleSetLinks) {
+        const foundType = types.find(t => t.id === currentLink.typeId);
+        const foundRuleSet = currentRuleSets.find(rs => rs.id === currentLink.typeRuleSetId);
+        const hash = `${foundType.slug}|${foundRuleSet.name}`;
+        currentLinksHashes[hash] = currentLink;
+    }
+    const reducedLinksByHashes = {};
+    for (const loadedLink of loadedRuleSetLinks) {
+        const hash = `${loadedLink.type}|${loadedLink.ruleSet}`;
+        reducedLinksByHashes[hash] = loadedLink;
+    }
+    console.debug('current rule set links:', currentLinksHashes);
+    console.debug('reduced rule set links:', reducedLinksByHashes);
+    for (const loadedRuleSetLink of loadedRuleSetLinks) {
+        try {
+            const found = currentLinksHashes[`${loadedRuleSetLink.type}|${loadedRuleSetLink.ruleSet}`];
+            if (!found) {
+                if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) {
+                    continue;
+                }
+                console.log('Creating: ', loadedRuleSetLink);
+                await new Entities().create({
+                    entityName: 'type-rule-set-link',
+                    object: {
+                        typeRuleSetId: loadedRuleSetLink.ruleSet,
+                        typeId: loadedRuleSetLink.type,
+                    },
+                });
+            }
+            else {
+                if (!transformReducedLink(loadedRuleSetLink, types, currentRuleSets)) {
+                    continue;
+                }
+                console.log('skipping updating existing rule set link: ', loadedRuleSetLink);
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading rule set links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                console.log('Deleting: ', currentLinkHash);
+                await new Entities().delete({
+                    entityName: 'type-rule-set-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(ruleSetLink, types, ruleSets) {
+    const foundType = types.find(t => t.slug === ruleSetLink.type);
+    if (!foundType) {
+        console.error('Could not find type with name', ruleSetLink.type);
+        return false;
+    }
+    ruleSetLink.type = foundType.id;
+    const foundRuleSet = ruleSets.find(rs => rs.name === ruleSetLink.ruleSet);
+    if (!foundRuleSet) {
+        console.error('Could not find rule set with name', foundType.ruleSet);
+        return false;
+    }
+    ruleSetLink.ruleSet = foundRuleSet.id;
+    return true;
+}

package/lib/types/type-property-policy-uploader.d.ts

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

package/lib/types/type-property-policy-uploader.js

@@ -0,0 +1,178 @@
+import { Entities } from '@contrail/sdk';
+import fs from 'fs';
+import * as path from 'path';
+import { authUser } from '../auth/login';
+import chalk from 'chalk';
+import { getTypes } from './types-extractor';
+const yaml = require('js-yaml');
+export async function uploadTypePropertyPolicies(args) {
+    try {
+        await authUser();
+        console.log('%s Uploading', chalk.yellow.bold('TYPE PROPERTY POLICY'));
+        const [reducedTypePropertyPolicies, reducedTypePropertyPolicyLinks] = await loadTPPolicies();
+        await uploadTPPolicyObjects(reducedTypePropertyPolicies);
+        await uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks);
+        console.log('%s Uploaded', chalk.yellow.bold('TYPE PROPERTY POLICY'));
+    }
+    catch (e) {
+        console.log(`%s Type Property Policy Upload Failed. ${e}`, chalk.red.bold('FAIL'));
+        return;
+    }
+    console.log('%s Type Property Policy Upload Complete.', chalk.green.bold('COMPLETE'));
+}
+function loadTPPolicies() {
+    const tpps = [];
+    let tppLinks = [];
+    const TARGET_DIR = process.cwd();
+    try {
+        const files = fs.readdirSync(path.join(TARGET_DIR, 'type-property-policies'));
+        for (const file of files) {
+            tpps.push(yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'type-property-policies', file), 'utf8')));
+        }
+        tppLinks = yaml.load(fs.readFileSync(path.join(TARGET_DIR, 'type-property-policy-links.yml'), 'utf8'));
+        return [tpps, tppLinks];
+    }
+    catch (e) {
+        throw new Error(`ERROR PARSING YAML: ${e}`);
+    }
+}
+async function uploadTPPolicyObjects(reducedTypePropertyPolicies) {
+    const currentTPPolicies = await new Entities().get({
+        entityName: 'type-property-policy',
+    });
+    const currentTPPByLabel = {};
+    for (const currentTPP of currentTPPolicies) {
+        currentTPPByLabel[currentTPP.label] = currentTPP;
+    }
+    const loadedTPPByName = {};
+    for (const loadedTPP of reducedTypePropertyPolicies) {
+        loadedTPPByName[loadedTPP.label] = loadedTPP;
+    }
+    console.debug('current tp policy:', currentTPPolicies);
+    console.debug('reduced tp policy:', reducedTypePropertyPolicies);
+    for (const [label, loadedTPP] of Object.entries(loadedTPPByName)) {
+        try {
+            const found = currentTPPByLabel[label];
+            if (!found) {
+                console.log('Creating: ', label);
+                await new Entities().create({
+                    entityName: 'type-property-policy',
+                    object: loadedTPP
+                });
+            }
+            else {
+                console.log('Updating: ', label);
+                await new Entities().update({
+                    entityName: 'type-property-policy',
+                    id: found.id,
+                    object: loadedTPP,
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading Type Property Policy: ${err}`);
+        }
+    }
+    for (const [label, currentTPP] of Object.entries(currentTPPByLabel)) {
+        try {
+            const found = loadedTPPByName[label];
+            if (!found) {
+                console.log('Deleting: ', label);
+                await new Entities().delete({
+                    entityName: 'type-property-policy',
+                    id: currentTPP['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Type Property Policy: ${err}`);
+        }
+    }
+}
+async function uploadTypePropertyPolicyLinks(reducedTypePropertyPolicyLinks) {
+    const typesWithProperties = await getTypes();
+    const typeProperties = typesWithProperties
+        .filter(t => !!t.typeProperties)
+        .map(t => t.typeProperties)
+        .reduce((a, b) => a.concat(b));
+    const currentTPPs = await new Entities().get({
+        entityName: 'type-property-policy',
+    });
+    const currentTPPLinks = await new Entities().get({
+        entityName: 'type-property-policy-link',
+    });
+    const currentLinksHashes = {};
+    for (const currentLink of currentTPPLinks) {
+        const foundTypeProperty = typeProperties.find(tp => tp.id === currentLink.typePropertyId);
+        const foundTPP = currentTPPs.find(tpp => tpp.id === currentLink.typePropertyPolicyId);
+        if (!foundTypeProperty || !foundTPP) {
+            console.log('skipping unhashable, invalid policy link:', currentLink);
+        }
+        const hash = `${foundTypeProperty.slug}|${foundTPP.label}`;
+        currentLinksHashes[hash] = currentLink;
+    }
+    const reducedLinksByHashes = {};
+    for (const loadedLink of reducedTypePropertyPolicyLinks) {
+        const hash = `${loadedLink.typePropertySlug}|${loadedLink.typePropertyPolicyLabel}`;
+        reducedLinksByHashes[hash] = loadedLink;
+    }
+    console.debug('current type property policy links:', currentLinksHashes);
+    console.debug('reduced type property policy links:', reducedLinksByHashes);
+    for (const loadedTPPLink of reducedTypePropertyPolicyLinks) {
+        try {
+            const found = currentLinksHashes[`${loadedTPPLink.typePropertySlug}|${loadedTPPLink.typePropertyPolicyLabel}`];
+            if (!found) {
+                if (!transformReducedLink(loadedTPPLink, typeProperties, currentTPPs)) {
+                    continue;
+                }
+                console.log('Creating: ', loadedTPPLink);
+                await new Entities().create({
+                    entityName: 'type-property-policy-link',
+                    object: {
+                        typePropertyPolicyId: loadedTPPLink.typePropertyPolicyId,
+                        typePropertyId: loadedTPPLink.typePropertyId,
+                    },
+                });
+            }
+            else {
+                if (!transformReducedLink(loadedTPPLink, typeProperties, currentTPPs)) {
+                    continue;
+                }
+                console.log('skipping existing link: ', loadedTPPLink);
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Uploading type property policy links: ${err}`);
+        }
+    }
+    for (const [currentLinkHash, currentLink] of Object.entries(currentLinksHashes)) {
+        try {
+            const found = reducedLinksByHashes[currentLinkHash];
+            if (!found) {
+                console.log('Deleting: ', currentLinkHash);
+                await new Entities().delete({
+                    entityName: 'type-property-policy-link',
+                    id: currentLink['id'],
+                });
+            }
+        }
+        catch (err) {
+            throw new Error(`Error Deleting rule set link: ${err}`);
+        }
+    }
+}
+function transformReducedLink(TPPLink, typeProperties, typePropertyPolicies) {
+    const foundTP = typeProperties.find(tp => tp.slug === TPPLink.typePropertySlug);
+    if (!foundTP) {
+        console.error('Could not find type property with label', TPPLink.typePropertySlug);
+        return false;
+    }
+    TPPLink.typePropertyId = foundTP.id;
+    const foundTPP = typePropertyPolicies.find(tpp => tpp.label === TPPLink.typePropertyPolicyLabel);
+    if (!foundTPP) {
+        console.error('Could not find type property policy with label', TPPLink.typePropertyPolicyLabel);
+        return false;
+    }
+    TPPLink.typePropertyPolicyId = foundTPP.id;
+    return true;
+}

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

@@ -1,2 +1,51 @@
-export declare function getTypes(args: any): Promise<void>;
-export declare function getReducedTypes(optionSets: any): Promise<any[]>;
+export interface DataHolder {
+    types: any[];
+    optionSets: any[];
+    optionSetHierarchies: any[];
+    ruleSets: any[];
+    ruleSetLinks: any[];
+    usageInfo: any[];
+    typePropertyPolicies: any[];
+    typePropertyPolicyLinks: any[];
+}
+export declare function getAll(args: any): Promise<void>;
+/**
+ *  stores reduced option sets and returns full option sets */
+export declare function getOptionSets(): Promise<any>;
+export declare function getTypes(): Promise<any[]>;
+export declare function reduceTypes(dataHolder: DataHolder): any[];
+export declare function reduceData(data: DataHolder): {
+    reducedTypes: any[];
+    reducedOptionSets: {
+        name: any;
+        isArchived: any;
+        optionSet: any;
+    }[];
+    reducedOptionSetHierarchies: {
+        hierarchy: any;
+        options: any;
+        name: any;
+    }[];
+    reducedRuleSets: {
+        ruleSet: any;
+        name: any;
+    }[];
+    reducedRuleSetLinks: any[];
+    reducedUsageInfo: {
+        used: any;
+        editable: any;
+        typeSlug: any;
+        typePropertySlug: any;
+    }[];
+    reducedTypePropertyPolicies: {
+        label: any;
+        policy: {
+            version: any;
+            statements: any;
+        };
+    }[];
+    reducedTypePropertyPolicyLinks: {
+        typePropertySlug: any;
+        typePropertyPolicyLabel: any;
+    }[];
+};