@omnia/tooling-composers 8.0.128-dev → 8.0.129-dev

package/internal-do-not-import-from-here/ManifestGroupRegistry.js

@@ -62,99 +62,99 @@ class ManifestGroupRegistry {
             ManifestGroupRegistry._registeredManifestProvider = false;
         };
     }
-}
-exports.ManifestGroupRegistry = ManifestGroupRegistry;
-ManifestGroupRegistry.ManifestGroupRegistrations = new Map();
-ManifestGroupRegistry._registeredManifestProvider = false;
-ManifestGroupRegistry.registerManifestGroup = (manifest, groupOptions) => {
-    ManifestGroupRegistry.ensureCorrectManifest(manifest);
-    if (!groupOptions) {
-        throw new Error("Can't register component with missing groupOptions");
-    }
-    if (!groupOptions.webComponentManifestIds) {
-        groupOptions.webComponentManifestIds = [];
-    }
-    if (!groupOptions.resourceManifestIds) {
-        groupOptions.resourceManifestIds = [];
-    }
-    if (groupOptions.webComponentManifestIds.length <= 0 &&
-        groupOptions.resourceManifestIds.length <= 0) {
-        throw new Error("Can't register manifest group with missing mandatory attributes, select either webcomponents or resources to include in group: " + JSON.stringify(groupOptions));
-    }
-    if (ManifestGroupRegistry.ManifestGroupRegistrations.get(manifest.resourceId)) {
-        throw new Error("Can't re-register resource manifest group on manifest with id: " + manifest.resourceId +
-            " current info: " + JSON.stringify(ManifestGroupRegistry.ManifestGroupRegistrations.get(manifest.resourceId)));
-    }
-    try {
-        ManifestGroupRegistry.ManifestGroupRegistrations.set(manifest.resourceId, new ManifestGroupRegistration(groupOptions, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath(), manifest));
-    }
-    catch (e) {
-        ManifestGroupRegistry.ManifestGroupRegistrations.set(manifest.resourceId, null);
-    }
-};
-ManifestGroupRegistry.newCombinedRules = (manifest, rules) => {
-    if (rules) {
+    static { this.ManifestGroupRegistrations = new Map(); }
+    static { this._registeredManifestProvider = false; }
+    static { this.registerManifestGroup = (manifest, groupOptions) => {
         ManifestGroupRegistry.ensureCorrectManifest(manifest);
-        Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
-        let registration = ManifestGroupRegistry.ManifestGroupRegistrations.get(manifest.resourceId);
-        if (registration != null) {
-            registration.loadRules = rules;
+        if (!groupOptions) {
+            throw new Error("Can't register component with missing groupOptions");
         }
-        else {
-            throw new Error("Can't add load rules for component group manifest with id: " + manifest.resourceId + " a component group has not been registered");
+        if (!groupOptions.webComponentManifestIds) {
+            groupOptions.webComponentManifestIds = [];
         }
-    }
-};
-ManifestGroupRegistry.getManifestGroupRegistrations = () => {
-    let registrations = new Map();
-    for (const regis of ManifestGroupRegistry.ManifestGroupRegistrations) {
-        registrations.set(regis[0], regis[1]);
-    }
-    return registrations;
-};
-ManifestGroupRegistry.getRegistrations = () => {
-    let groupRegistrations = [];
-    for (const regis of ManifestGroupRegistry.ManifestGroupRegistrations) {
-        const groupRegistration = regis[1];
-        for (let webComponentManifestIdToInclude of groupRegistration.manifestGroupOptions.webComponentManifestIds) {
-            let registeredManifest = LoadableManifestRegistry_1.LoadableManifestRegistry.getRegisteredManifest(webComponentManifestIdToInclude);
-            if (!registeredManifest) {
-                throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is referencing manifest id: " + webComponentManifestIdToInclude + " which has not been registered.");
+        if (!groupOptions.resourceManifestIds) {
+            groupOptions.resourceManifestIds = [];
+        }
+        if (groupOptions.webComponentManifestIds.length <= 0 &&
+            groupOptions.resourceManifestIds.length <= 0) {
+            throw new Error("Can't register manifest group with missing mandatory attributes, select either webcomponents or resources to include in group: " + JSON.stringify(groupOptions));
+        }
+        if (ManifestGroupRegistry.ManifestGroupRegistrations.get(manifest.resourceId)) {
+            throw new Error("Can't re-register resource manifest group on manifest with id: " + manifest.resourceId +
+                " current info: " + JSON.stringify(ManifestGroupRegistry.ManifestGroupRegistrations.get(manifest.resourceId)));
+        }
+        try {
+            ManifestGroupRegistry.ManifestGroupRegistrations.set(manifest.resourceId, new ManifestGroupRegistration(groupOptions, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath(), manifest));
+        }
+        catch (e) {
+            ManifestGroupRegistry.ManifestGroupRegistrations.set(manifest.resourceId, null);
+        }
+    }; }
+    static { this.newCombinedRules = (manifest, rules) => {
+        if (rules) {
+            ManifestGroupRegistry.ensureCorrectManifest(manifest);
+            Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
+            let registration = ManifestGroupRegistry.ManifestGroupRegistrations.get(manifest.resourceId);
+            if (registration != null) {
+                registration.loadRules = rules;
             }
-            if (registeredManifest.manifestType != Enums_1.ClientManifestTypes.Component) {
-                throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is adding manifest id: " + webComponentManifestIdToInclude + " as a web component to group manifest, but it's not of webcomponent type.");
+            else {
+                throw new Error("Can't add load rules for component group manifest with id: " + manifest.resourceId + " a component group has not been registered");
             }
         }
-        for (let resourceManifestIdToInclude of groupRegistration.manifestGroupOptions.resourceManifestIds) {
-            let registeredManifest = LoadableManifestRegistry_1.LoadableManifestRegistry.getRegisteredManifest(resourceManifestIdToInclude);
-            if (!registeredManifest) {
-                throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is referencing manifest id: " + resourceManifestIdToInclude + " which has not been registered.");
+    }; }
+    static { this.getManifestGroupRegistrations = () => {
+        let registrations = new Map();
+        for (const regis of ManifestGroupRegistry.ManifestGroupRegistrations) {
+            registrations.set(regis[0], regis[1]);
+        }
+        return registrations;
+    }; }
+    static { this.getRegistrations = () => {
+        let groupRegistrations = [];
+        for (const regis of ManifestGroupRegistry.ManifestGroupRegistrations) {
+            const groupRegistration = regis[1];
+            for (let webComponentManifestIdToInclude of groupRegistration.manifestGroupOptions.webComponentManifestIds) {
+                let registeredManifest = LoadableManifestRegistry_1.LoadableManifestRegistry.getRegisteredManifest(webComponentManifestIdToInclude);
+                if (!registeredManifest) {
+                    throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is referencing manifest id: " + webComponentManifestIdToInclude + " which has not been registered.");
+                }
+                if (registeredManifest.manifestType != Enums_1.ClientManifestTypes.Component) {
+                    throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is adding manifest id: " + webComponentManifestIdToInclude + " as a web component to group manifest, but it's not of webcomponent type.");
+                }
             }
-            if (registeredManifest.manifestType != Enums_1.ClientManifestTypes.Resource) {
-                throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is adding manifest id: " + resourceManifestIdToInclude + " as a resource to group manifest, but it's not of rescource type.");
+            for (let resourceManifestIdToInclude of groupRegistration.manifestGroupOptions.resourceManifestIds) {
+                let registeredManifest = LoadableManifestRegistry_1.LoadableManifestRegistry.getRegisteredManifest(resourceManifestIdToInclude);
+                if (!registeredManifest) {
+                    throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is referencing manifest id: " + resourceManifestIdToInclude + " which has not been registered.");
+                }
+                if (registeredManifest.manifestType != Enums_1.ClientManifestTypes.Resource) {
+                    throw new Error("Error, manifest: " + groupRegistration.manifestPath + " is adding manifest id: " + resourceManifestIdToInclude + " as a resource to group manifest, but it's not of rescource type.");
+                }
             }
+            groupRegistrations.push({
+                resourceId: groupRegistration.manifest.resourceId,
+                resourceName: groupRegistration.manifest.resourceName,
+                manifestIdsInGroup: groupRegistration.manifestGroupOptions.webComponentManifestIds.concat(groupRegistration.manifestGroupOptions.resourceManifestIds),
+            });
         }
-        groupRegistrations.push({
-            resourceId: groupRegistration.manifest.resourceId,
-            resourceName: groupRegistration.manifest.resourceName,
-            manifestIdsInGroup: groupRegistration.manifestGroupOptions.webComponentManifestIds.concat(groupRegistration.manifestGroupOptions.resourceManifestIds),
-        });
-    }
-    if (!ManifestGroupRegistry._registeredManifestProvider) {
-        ManifestGroupRegistry._registeredManifestProvider = true;
-        LoadableManifestRegistry_1.LoadableManifestRegistry.registerManifestProvider(new ManifestGroupRegistry());
-    }
-    return groupRegistrations;
-};
-ManifestGroupRegistry.ensureCorrectManifest = (manifest) => {
-    if (!manifest ||
-        !manifest.manifestType ||
-        manifest.manifestType !== Enums_1.ClientManifestTypes.ManifestGroup) {
-        throw new Error("Manifest :" + JSON.stringify(manifest) + " can't be used as component manifest. Mandatory properties maybe missing or the manifest is not of component type");
-    }
-    manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
-};
-ManifestGroupRegistry.clearManifestGroupRegistrations = () => {
-    ManifestGroupRegistry.ManifestGroupRegistrations = new Map();
-};
-ManifestGroupRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(() => { return new Array(); }, ManifestGroupRegistry.clearManifestGroupRegistrations));
+        if (!ManifestGroupRegistry._registeredManifestProvider) {
+            ManifestGroupRegistry._registeredManifestProvider = true;
+            LoadableManifestRegistry_1.LoadableManifestRegistry.registerManifestProvider(new ManifestGroupRegistry());
+        }
+        return groupRegistrations;
+    }; }
+    static { this.ensureCorrectManifest = (manifest) => {
+        if (!manifest ||
+            !manifest.manifestType ||
+            manifest.manifestType !== Enums_1.ClientManifestTypes.ManifestGroup) {
+            throw new Error("Manifest :" + JSON.stringify(manifest) + " can't be used as component manifest. Mandatory properties maybe missing or the manifest is not of component type");
+        }
+        manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
+    }; }
+    static { this.clearManifestGroupRegistrations = () => {
+        ManifestGroupRegistry.ManifestGroupRegistrations = new Map();
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(() => { return new Array(); }, ManifestGroupRegistry.clearManifestGroupRegistrations)); }
+}
+exports.ManifestGroupRegistry = ManifestGroupRegistry;

package/internal-do-not-import-from-here/ManifestRegistry.js

@@ -18,94 +18,94 @@ class StaticServerManifestProviderProxy {
 }
 exports.StaticServerManifestProviderProxy = StaticServerManifestProviderProxy;
 class ManifestRegistry {
-}
-exports.ManifestRegistry = ManifestRegistry;
-ManifestRegistry.CurrentManifestPath = null;
-ManifestRegistry.ClientManifestProviders = [];
-ManifestRegistry.ServerManifestProviders = [];
-ManifestRegistry.ResetableManifestProviders = [];
-ManifestRegistry.registerClientManifestProvider = (provider) => {
-    if (!provider) {
-        throw new Error("Unexpected state, client manifest provider can't be null/undefined");
-    }
-    ManifestRegistry.ClientManifestProviders.push(provider);
-    ManifestRegistry.addResetableProvider(provider);
-};
-ManifestRegistry.registerServerManifestProvider = (provider) => {
-    if (!provider) {
-        throw new Error("Unexpected state, server manifest provider can't be null/undefined");
-    }
-    ManifestRegistry.ServerManifestProviders.push(provider);
-    ManifestRegistry.addResetableProvider(provider);
-};
-ManifestRegistry.setCurrentManifestPath = (manifestPath = null) => {
-    ManifestRegistry.CurrentManifestPath = manifestPath;
-};
-ManifestRegistry.getCurrentManifestPath = () => {
-    if (!ManifestRegistry.CurrentManifestPath) {
-        throw new Error("Unexpected usage, build step should set CurrentManifestPath before triggering manifest registration (build configuration error)");
-    }
-    return ManifestRegistry.CurrentManifestPath;
-};
-ManifestRegistry.getClientManifests = (currentServiceId) => {
-    currentServiceId = Utils_1.Utils.ensureValidServiceId(currentServiceId, "Can't get client manifests for service id undefined/empty/null");
-    const manifestsByTarget = {
-        [models_1.ClientManifestTargetTypes.public]: {
-            target: models_1.ClientManifestTargetTypes.public,
-            omniaServiceId: currentServiceId
+    static { this.CurrentManifestPath = null; }
+    static { this.ClientManifestProviders = []; }
+    static { this.ServerManifestProviders = []; }
+    static { this.ResetableManifestProviders = []; }
+    static { this.registerClientManifestProvider = (provider) => {
+        if (!provider) {
+            throw new Error("Unexpected state, client manifest provider can't be null/undefined");
+        }
+        ManifestRegistry.ClientManifestProviders.push(provider);
+        ManifestRegistry.addResetableProvider(provider);
+    }; }
+    static { this.registerServerManifestProvider = (provider) => {
+        if (!provider) {
+            throw new Error("Unexpected state, server manifest provider can't be null/undefined");
         }
-    };
-    for (let provider of ManifestRegistry.ClientManifestProviders) {
-        let providerManifests = provider.getClientManifests(currentServiceId);
-        for (let m of providerManifests) {
-            let target = manifestsByTarget[models_1.ClientManifestTargetTypes.public]; // default is public target
-            if (m.target) {
-                if (manifestsByTarget[m.target] === undefined) {
-                    manifestsByTarget[m.target] = { target: m.target, omniaServiceId: currentServiceId };
+        ManifestRegistry.ServerManifestProviders.push(provider);
+        ManifestRegistry.addResetableProvider(provider);
+    }; }
+    static { this.setCurrentManifestPath = (manifestPath = null) => {
+        ManifestRegistry.CurrentManifestPath = manifestPath;
+    }; }
+    static { this.getCurrentManifestPath = () => {
+        if (!ManifestRegistry.CurrentManifestPath) {
+            throw new Error("Unexpected usage, build step should set CurrentManifestPath before triggering manifest registration (build configuration error)");
+        }
+        return ManifestRegistry.CurrentManifestPath;
+    }; }
+    static { this.getClientManifests = (currentServiceId) => {
+        currentServiceId = Utils_1.Utils.ensureValidServiceId(currentServiceId, "Can't get client manifests for service id undefined/empty/null");
+        const manifestsByTarget = {
+            [models_1.ClientManifestTargetTypes.public]: {
+                target: models_1.ClientManifestTargetTypes.public,
+                omniaServiceId: currentServiceId
+            }
+        };
+        for (let provider of ManifestRegistry.ClientManifestProviders) {
+            let providerManifests = provider.getClientManifests(currentServiceId);
+            for (let m of providerManifests) {
+                let target = manifestsByTarget[models_1.ClientManifestTargetTypes.public]; // default is public target
+                if (m.target) {
+                    if (manifestsByTarget[m.target] === undefined) {
+                        manifestsByTarget[m.target] = { target: m.target, omniaServiceId: currentServiceId };
+                    }
+                    target = manifestsByTarget[m.target];
+                    delete m.target;
+                }
+                if (target[m.manifestType] == null) {
+                    target[m.manifestType] = [];
                 }
-                target = manifestsByTarget[m.target];
-                delete m.target;
+                target[m.manifestType].push(m);
             }
-            if (target[m.manifestType] == null) {
-                target[m.manifestType] = [];
+        }
+        return manifestsByTarget;
+    }; }
+    static { this.getServerManifests = (currentOmniaServiceId) => {
+        currentOmniaServiceId = Utils_1.Utils.ensureValidServiceId(currentOmniaServiceId, "Can't get server manifests for omnia service id undefined/empty/null");
+        let manifestsByType = {};
+        for (let provider of ManifestRegistry.ServerManifestProviders) {
+            let providerManifests = provider.getServerManifests(currentOmniaServiceId);
+            for (let m of providerManifests) {
+                if (manifestsByType[m.manifestType] == null) {
+                    manifestsByType[m.manifestType] = [];
+                }
+                manifestsByType[m.manifestType].push(m);
             }
-            target[m.manifestType].push(m);
         }
-    }
-    return manifestsByTarget;
-};
-ManifestRegistry.getServerManifests = (currentOmniaServiceId) => {
-    currentOmniaServiceId = Utils_1.Utils.ensureValidServiceId(currentOmniaServiceId, "Can't get server manifests for omnia service id undefined/empty/null");
-    let manifestsByType = {};
-    for (let provider of ManifestRegistry.ServerManifestProviders) {
-        let providerManifests = provider.getServerManifests(currentOmniaServiceId);
-        for (let m of providerManifests) {
-            if (manifestsByType[m.manifestType] == null) {
-                manifestsByType[m.manifestType] = [];
+        return manifestsByType;
+    }; }
+    static { this.clearState = () => {
+        for (let p of ManifestRegistry.ResetableManifestProviders) {
+            p.clearState();
+        }
+    }; }
+    static { this.addResetableProvider = (provider) => {
+        if (!provider ||
+            provider.clearState == null) {
+            throw new Error("Unexpected state, manifest provider can't have clearstate null/undefined");
+        }
+        let alreadyRegistered = false;
+        for (let p of ManifestRegistry.ResetableManifestProviders) {
+            if (p.clearState === provider.clearState) {
+                alreadyRegistered = true;
+                break;
             }
-            manifestsByType[m.manifestType].push(m);
         }
-    }
-    return manifestsByType;
-};
-ManifestRegistry.clearState = () => {
-    for (let p of ManifestRegistry.ResetableManifestProviders) {
-        p.clearState();
-    }
-};
-ManifestRegistry.addResetableProvider = (provider) => {
-    if (!provider ||
-        provider.clearState == null) {
-        throw new Error("Unexpected state, manifest provider can't have clearstate null/undefined");
-    }
-    let alreadyRegistered = false;
-    for (let p of ManifestRegistry.ResetableManifestProviders) {
-        if (p.clearState === provider.clearState) {
-            alreadyRegistered = true;
-            break;
+        if (!alreadyRegistered) {
+            ManifestRegistry.ResetableManifestProviders.push(provider);
         }
-    }
-    if (!alreadyRegistered) {
-        ManifestRegistry.ResetableManifestProviders.push(provider);
-    }
-};
+    }; }
+}
+exports.ManifestRegistry = ManifestRegistry;

package/internal-do-not-import-from-here/RequestedResourcesRegistry.js

@@ -7,59 +7,59 @@ const ManifestRegistry_1 = require("./ManifestRegistry");
 const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
 const models_1 = require("../../fx-models");
 class RequestedResourcesRegistry {
+    static { this.RequestedResources = {}; }
+    static { this.AddSql = (option) => {
+        if (!models_1.Guid.isValid(option.uniqueId)) {
+            throw new Error("Can't add request for sql resource, without valid guid as unqieId: " + JSON.stringify(option));
+        }
+        if (RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] != null) {
+            throw new Error("Can't add request for sql resource, the uniqueid has already been added." + JSON.stringify(option));
+        }
+        let manifest = {
+            manifestType: index_1.ServerManifestTypes.ResourceRequest,
+            resourceType: index_1.RequestedResourceTypes.SqlDatabase
+        };
+        let sqlResourceManifest = (0, deep_extend_1.default)(manifest, option);
+        RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = sqlResourceManifest;
+    }; }
+    static { this.AddPersistentDisk = (option) => {
+        if (!models_1.Guid.isValid(option.uniqueId)) {
+            throw new Error("Can't add request for persistent disk resource, without valid guid as unqieId: " + JSON.stringify(option));
+        }
+        if (RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] != null) {
+            throw new Error("Can't add request for persistent disk resource, the uniqueid has already been added." + JSON.stringify(option));
+        }
+        let manifest = {
+            manifestType: index_1.ServerManifestTypes.ResourceRequest,
+            resourceType: index_1.RequestedResourceTypes.PersistentDisk
+        };
+        let persistentDiskResourceManifest = (0, deep_extend_1.default)(manifest, option);
+        RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = persistentDiskResourceManifest;
+    }; }
+    static { this.AddSqlElasticPool = (option) => {
+        if (!models_1.Guid.isValid(option.uniqueId)) {
+            throw new Error("Can't add request for sql elastic pool resource, without valid guid as unqieId: " + JSON.stringify(option));
+        }
+        if (RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] != null) {
+            throw new Error("Can't add request for sql elastic pool resource, the uniqueid has already been added." + JSON.stringify(option));
+        }
+        let manifest = {
+            manifestType: index_1.ServerManifestTypes.ResourceRequest,
+            resourceType: index_1.RequestedResourceTypes.SqlElasticPoolDatabase
+        };
+        let sqlElasticPoolResourceManifest = (0, deep_extend_1.default)(manifest, option);
+        RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = sqlElasticPoolResourceManifest;
+    }; }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        for (let key in RequestedResourcesRegistry.RequestedResources) {
+            serverManifests.push(RequestedResourcesRegistry.RequestedResources[key]);
+        }
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        RequestedResourcesRegistry.RequestedResources = {};
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(RequestedResourcesRegistry.getServerManifests, RequestedResourcesRegistry.clearState)); }
 }
 exports.RequestedResourcesRegistry = RequestedResourcesRegistry;
-RequestedResourcesRegistry.RequestedResources = {};
-RequestedResourcesRegistry.AddSql = (option) => {
-    if (!models_1.Guid.isValid(option.uniqueId)) {
-        throw new Error("Can't add request for sql resource, without valid guid as unqieId: " + JSON.stringify(option));
-    }
-    if (RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] != null) {
-        throw new Error("Can't add request for sql resource, the uniqueid has already been added." + JSON.stringify(option));
-    }
-    let manifest = {
-        manifestType: index_1.ServerManifestTypes.ResourceRequest,
-        resourceType: index_1.RequestedResourceTypes.SqlDatabase
-    };
-    let sqlResourceManifest = (0, deep_extend_1.default)(manifest, option);
-    RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = sqlResourceManifest;
-};
-RequestedResourcesRegistry.AddPersistentDisk = (option) => {
-    if (!models_1.Guid.isValid(option.uniqueId)) {
-        throw new Error("Can't add request for persistent disk resource, without valid guid as unqieId: " + JSON.stringify(option));
-    }
-    if (RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] != null) {
-        throw new Error("Can't add request for persistent disk resource, the uniqueid has already been added." + JSON.stringify(option));
-    }
-    let manifest = {
-        manifestType: index_1.ServerManifestTypes.ResourceRequest,
-        resourceType: index_1.RequestedResourceTypes.PersistentDisk
-    };
-    let persistentDiskResourceManifest = (0, deep_extend_1.default)(manifest, option);
-    RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = persistentDiskResourceManifest;
-};
-RequestedResourcesRegistry.AddSqlElasticPool = (option) => {
-    if (!models_1.Guid.isValid(option.uniqueId)) {
-        throw new Error("Can't add request for sql elastic pool resource, without valid guid as unqieId: " + JSON.stringify(option));
-    }
-    if (RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] != null) {
-        throw new Error("Can't add request for sql elastic pool resource, the uniqueid has already been added." + JSON.stringify(option));
-    }
-    let manifest = {
-        manifestType: index_1.ServerManifestTypes.ResourceRequest,
-        resourceType: index_1.RequestedResourceTypes.SqlElasticPoolDatabase
-    };
-    let sqlElasticPoolResourceManifest = (0, deep_extend_1.default)(manifest, option);
-    RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = sqlElasticPoolResourceManifest;
-};
-RequestedResourcesRegistry.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    for (let key in RequestedResourcesRegistry.RequestedResources) {
-        serverManifests.push(RequestedResourcesRegistry.RequestedResources[key]);
-    }
-    return serverManifests;
-};
-RequestedResourcesRegistry.clearState = () => {
-    RequestedResourcesRegistry.RequestedResources = {};
-};
-RequestedResourcesRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(RequestedResourcesRegistry.getServerManifests, RequestedResourcesRegistry.clearState));

package/internal-do-not-import-from-here/RequiredAzureAdAppPermissionRegistry.js

@@ -4,6 +4,7 @@ exports.RequiredAzureAdAppPermissionRegistry = void 0;
 const index_1 = require("./models/index");
 const ManifestRegistry_1 = require("./ManifestRegistry");
 class RequiredAzureAdAppPermissionRegistry {
+    static { this.RequiredApis = {}; }
     static addApiPermission(customApiPermisisonInfo) {
         if (customApiPermisisonInfo == null) {
             return this;
@@ -20,17 +21,16 @@ class RequiredAzureAdAppPermissionRegistry {
             }
         }
     }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        for (let key in RequiredAzureAdAppPermissionRegistry.RequiredApis) {
+            serverManifests.push(RequiredAzureAdAppPermissionRegistry.RequiredApis[key]);
+        }
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        RequiredAzureAdAppPermissionRegistry.RequiredApis = {};
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(RequiredAzureAdAppPermissionRegistry.getServerManifests, RequiredAzureAdAppPermissionRegistry.clearState)); }
 }
 exports.RequiredAzureAdAppPermissionRegistry = RequiredAzureAdAppPermissionRegistry;
-RequiredAzureAdAppPermissionRegistry.RequiredApis = {};
-RequiredAzureAdAppPermissionRegistry.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    for (let key in RequiredAzureAdAppPermissionRegistry.RequiredApis) {
-        serverManifests.push(RequiredAzureAdAppPermissionRegistry.RequiredApis[key]);
-    }
-    return serverManifests;
-};
-RequiredAzureAdAppPermissionRegistry.clearState = () => {
-    RequiredAzureAdAppPermissionRegistry.RequiredApis = {};
-};
-RequiredAzureAdAppPermissionRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(RequiredAzureAdAppPermissionRegistry.getServerManifests, RequiredAzureAdAppPermissionRegistry.clearState));