@omnia/tooling-composers 8.0.192-dev → 8.0.193-dev

package/internal-do-not-import-from-here/BlockingComposer.d.ts

@@ -1,9 +1,10 @@
+import { guid } from "@omnia/fx-models";
 export interface IBlockingComposer {
     /** Block a manifest.
         E.g. Provide omnia service id and manifest id for the target manifest you want to block
     */
-    externalManifest: (omniaServiceId: string, manifestId: string) => IBlockingComposer;
+    externalManifest: (omniaServiceId: guid, manifestId: guid) => IBlockingComposer;
 }
 export declare class BlockingComposer implements IBlockingComposer {
-    externalManifest: (omniaServiceId: string, manifestId: string) => this;
+    externalManifest: (omniaServiceId: guid, manifestId: guid) => this;
 }

package/internal-do-not-import-from-here/BlockingRegistry.d.ts

@@ -1,8 +1,8 @@
-import { ClientManifest, GuidValue } from '../../fx-models';
+import { ClientManifest, guid } from '../../fx-models';
 export declare class BlockingRegistry {
     private static BlockedManifests;
-    static addBlockedManifest: (omniaServiceId: string, manifestId: string) => void;
-    static getClientManifests: (currentServiceId: GuidValue) => Array<ClientManifest>;
+    static addBlockedManifest: (omniaServiceId: guid, manifestId: guid) => void;
+    static getClientManifests: (currentServiceId: guid) => Array<ClientManifest>;
     static clearState: () => void;
     private static Subscription;
 }

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockingRegistry = void 0;
 const ManifestRegistry_1 = require("./ManifestRegistry");
-const Utils_1 = require("./Utils");
 //import { BlockedBundleManifest, ClientManifest } from "./models";
 const Enums_1 = require("./models/Enums");
 class BlockInformation {
@@ -19,8 +18,10 @@ class BlockInformation {
 class BlockingRegistry {
     static { this.BlockedManifests = []; }
     static { this.addBlockedManifest = (omniaServiceId, manifestId) => {
-        omniaServiceId = Utils_1.Utils.ensureValidServiceId(omniaServiceId);
-        manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
+        //TODO if you find this probably you found that we have som uppercase guids.
+        //The tooling should always enforce lowercase 
+        //omniaServiceId = Utils.ensureValidServiceId(omniaServiceId);
+        //manifestId = Utils.ensureValidManifestId(manifestId);
         BlockingRegistry.BlockedManifests.push(new BlockInformation({
             omniaServiceId: omniaServiceId,
             resourceId: manifestId,

package/internal-do-not-import-from-here/CombinableSecurityProviderComposer.d.ts

@@ -1,5 +1,6 @@
 import { IComposerDone } from "./Composer";
 import { SecurityProviderRule } from "./models/index";
+import { guid } from "@omnia/fx-models";
 export interface ILogicalOperatorSelector<T> extends IComposerDone<T> {
     and: () => ICompletableCombinableSecurityProviderComposer<T>;
     or: () => ICompletableCombinableSecurityProviderComposer<T>;
@@ -19,7 +20,7 @@ export declare class SecurityProviderCombinableRuleComposer<T> implements ICombi
     private selectedLogicalOperator?;
     constructor(newRuleCb: (allRules: Array<SecurityProviderRule>) => void, composerForDone: T);
     done: () => T;
-    hasAccessToProvider: (securityProviderId: string) => this;
+    hasAccessToProvider: (securityProviderId: guid) => this;
     and: () => this;
     or: () => this;
 }

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

@@ -17,8 +17,8 @@ class SecurityProviderCombinableRuleComposer {
             if (!securityProviderId) {
                 throw new Error("Can't add security provider rule with id null/empty/undefined");
             }
-            if (!fx_models_1.Guid.isValid(securityProviderId)) {
-                throw new Error("Can't add security provider rule with id: " + securityProviderId + " must be a valid Guid");
+            if (!(0, fx_models_1.isValidGuid)(securityProviderId)) {
+                throw new Error("Can't add security provider rule with id: " + securityProviderId + " must be a valid guid");
             }
             if (this.selectedLogicalOperator == null &&
                 this.rules.length > 0) {

package/internal-do-not-import-from-here/ComponentComposer.d.ts

@@ -1,6 +1,6 @@
 import { ElementOptions } from "./models";
 import { CombinableRuleComposer, ICombinableRuleComposer } from "./CombinableRuleComposer";
-import { WebComponentDefinition, OmniaBlock } from '../../fx-models';
+import { WebComponentDefinition, OmniaBlock, guid } from '../../fx-models';
 import { ComposerBase, IComposerBase } from './ComposerBase';
 export interface IWebComponentComposer extends IComposerBase<IWebComponentComposer> {
     /**
@@ -17,7 +17,7 @@ export interface IWebComponentComposer extends IComposerBase<IWebComponentCompos
 export declare class ComponentComposer extends ComposerBase<IWebComponentComposer> implements IWebComponentComposer {
     done: () => IWebComponentComposer;
     private ruleComposer;
-    constructor(manifestId: string, manifestName?: string);
+    constructor(manifestId: guid, manifestName?: string);
     withDefinition: (definition: WebComponentDefinition) => this;
     registerComponent: (componentOptions: ElementOptions) => this;
     withLoadRules: () => CombinableRuleComposer<IWebComponentComposer>;

package/internal-do-not-import-from-here/ComponentRegistry.d.ts

@@ -1,6 +1,6 @@
 import { IClientLoadableManifestProvider, ResourceManifest } from "./LoadableManifestRegistry";
 import { ResourceBuildOptions, ElementOptions } from "./models/index";
-import { ComponentBundleManifest, ClientResolvableLoadRule, WebComponentDefinition, GuidValue } from '../../fx-models';
+import { ComponentBundleManifest, ClientResolvableLoadRule, WebComponentDefinition, guid } from '../../fx-models';
 export declare class ComponentRegistration {
     componentOptions: ElementOptions;
     manifestPath: string;
@@ -21,7 +21,7 @@ export declare class ComponentRegistry implements IClientLoadableManifestProvide
     static newCombinedRules: (manifest: ResourceManifest, rules: Array<ClientResolvableLoadRule>) => void;
     static getRegistrations: () => Array<ComponentRegistration>;
     static getComponentRegistrations: () => Array<ComponentRegistration>;
-    getClientLoadableManifests: (currentServiceId: GuidValue) => Array<ComponentBundleManifest>;
+    getClientLoadableManifests: (currentServiceId: guid) => Array<ComponentBundleManifest>;
     clearState: () => void;
     private static ensureCorrectManifest;
 }

package/internal-do-not-import-from-here/Composer.d.ts

@@ -4,7 +4,7 @@ import { IResourcesComposer, IReOpendedResourcesComposer } from "./ResourcesComp
 import { IWebComponentComposer } from "./ComponentComposer";
 import { IManifestGroupComposer } from "./ManifestGroupComposer";
 import { IRegisterService } from './ServiceComposer';
-import { Guid, GuidValue } from '../../fx-models';
+import { guid } from '../../fx-models';
 import { IClientServiceConfigurator } from '.';
 export interface IComposerDone<T> {
     done: () => T;
@@ -33,7 +33,7 @@ export interface INewManifestComposer extends IRegisterService {
     * Usage: registerResourceGroup({...}).*additionalOperations
     * @param groupOptions the options for the defining the webcomponent group.
     */
-    registerResourceGroup: (groupOptions: ManifestGroupOptions<GuidValue>) => IManifestGroupComposer;
+    registerResourceGroup: (groupOptions: ManifestGroupOptions) => IManifestGroupComposer;
     /**
     * Registers a new localization manifest
     * Used to add labels for localization
@@ -55,21 +55,21 @@ export declare class Composer {
     * @param manifestId the unique id of the manifest, must be a valid guid.
     * @param name a friendly name of the manifest.
     */
-    static registerManifest: (manifestId: GuidValue, name?: string) => INewManifestComposer;
+    static registerManifest: (manifestId: guid, name?: string) => INewManifestComposer;
     /**
     * Re-opens resources manifest, so more resources can be included.
     * {param}:manifestId the unique id of the resource manifest to open, must be a valid guid.
     */
-    static openResourceManifest: (manifestId: GuidValue) => IReOpendedResourcesComposer;
+    static openResourceManifest: (manifestId: guid) => IReOpendedResourcesComposer;
     /** Add information about things you want to block.
         E.g. block a manifest from being loaded, so you can provide your own implementation
     */
     static get block(): IBlockingComposer;
     static importManifests: (folderPath: string) => {
-        configuration: <T extends IClientServiceConfigurator<Composer>>(omniaServiceId: Guid, configurationType: any) => T;
+        configuration: <T extends IClientServiceConfigurator<Composer>>(omniaServiceId: guid, configurationType: any) => T;
         done: () => {
-            registerManifest: (manifestId: GuidValue, name?: string) => INewManifestComposer;
-            openResourceManifest: (manifestId: GuidValue) => IReOpendedResourcesComposer;
+            registerManifest: (manifestId: guid, name?: string) => INewManifestComposer;
+            openResourceManifest: (manifestId: guid) => IReOpendedResourcesComposer;
             block: IBlockingComposer;
         };
     };

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

@@ -62,14 +62,14 @@ class Composer {
     * @param name a friendly name of the manifest.
     */
     static { this.registerManifest = (manifestId, name) => {
-        return new NewManifestComposer(manifestId.toString(), name);
+        return new NewManifestComposer(manifestId, name);
     }; }
     /**
     * Re-opens resources manifest, so more resources can be included.
     * {param}:manifestId the unique id of the resource manifest to open, must be a valid guid.
     */
     static { this.openResourceManifest = (manifestId) => {
-        return new ResourcesComposer_1.ReOpenedResourceComposer(manifestId.toString());
+        return new ResourcesComposer_1.ReOpenedResourceComposer(manifestId);
     }; }
     /** Add information about things you want to block.
         E.g. block a manifest from being loaded, so you can provide your own implementation

package/internal-do-not-import-from-here/ComposerBase.d.ts

@@ -1,4 +1,4 @@
-import { ApiPath, ClientManifestTargetTypes, IExtend, IExtendApiManifest, RegiterApiConfiguration } from "../../fx-models";
+import { ApiPath, ClientManifestTargetTypes, guid, IExtend, IExtendApiManifest, RegiterApiConfiguration } from "../../fx-models";
 import { ICombinableRuleComposer } from "./CombinableRuleComposer";
 import { DependencyComposer, IDependencyComposer } from "./DependencyComposer";
 import { ResourceManifest } from "./LoadableManifestRegistry";
@@ -14,8 +14,8 @@ export declare abstract class ComposerBase<TType extends IComposerBase<any>> imp
     protected manifest: ResourceManifest;
     withTarget(target: ClientManifestTargetTypes): TType;
     withNoDependency(): TType;
-    withDependency(manifestId: string): DependencyComposer<TType>;
-    withExternalDependency(omniaServiceId: string, manifestId: string): DependencyComposer<TType>;
+    withDependency(manifestId: guid): DependencyComposer<TType>;
+    withExternalDependency(omniaServiceId: guid, manifestId: guid): DependencyComposer<TType>;
     registerApi: (exp: (extend: IExtend) => Promise<any>, configuration?: RegiterApiConfiguration) => any;
     extendApi: (exp: (extend: IExtendApiManifest) => ApiPath, expRules?: (builder: ICombinableRuleComposer<TType>) => void) => any;
     disableAuth: () => any;

package/internal-do-not-import-from-here/ConfigurationClientServiceRegistry.d.ts

@@ -1,4 +1,4 @@
-import { Guid, OmniaRuntimeConfiguration } from '../../fx-models';
+import { guid, OmniaRuntimeConfiguration } from '../../fx-models';
 import { IWebAppServiceComposer } from './WebAppServiceComposer';
 export interface IClientServiceConfigurator<T> {
     done: () => T;
@@ -21,7 +21,7 @@ export declare class OmniaFxConfigurator implements IClientServiceConfigurator<I
 }
 export declare class ConfigurationClientServiceRegistry {
     private static configurations;
-    static Add<T extends IClientServiceConfigurator<any>>(omniaServiceId: Guid, configurationType: T, constructorArgs: Array<any>): IClientServiceConfigurator<any>;
+    static Add<T extends IClientServiceConfigurator<any>>(omniaServiceId: guid, configurationType: T, constructorArgs: Array<any>): IClientServiceConfigurator<any>;
     static getConfigurations(): {
         [omniaServiceId: string]: IClientServiceConfigurator<any>;
     };

package/internal-do-not-import-from-here/CustomServiceComposer.d.ts

@@ -1,11 +1,12 @@
 import { ServiceOptions } from './models';
 import { IServiceManifestComposer, ServiceManifestComposer } from './ServiceManifestComposer';
+import { guid } from '@omnia/fx-models';
 export interface ICustomServiceComposer extends IServiceManifestComposer<ICustomServiceComposer> {
     runHelm: (cmd: string) => ICustomServiceComposer;
 }
 export declare class CustomServiceComposer extends ServiceManifestComposer<CustomServiceComposer> implements ICustomServiceComposer {
     private manifestId;
     private manifestTitle;
-    constructor(manifestId: string, manifestTitle: string, serviceOptions: ServiceOptions);
+    constructor(manifestId: guid, manifestTitle: string, serviceOptions: ServiceOptions);
     runHelm(cmd: string): this;
 }

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

@@ -11,8 +11,8 @@ class CustomServiceComposer extends ServiceManifestComposer_1.ServiceManifestCom
         super(() => { return this; });
         this.manifestId = manifestId;
         this.manifestTitle = manifestTitle;
-        if (!fx_models_1.Guid.isValid(this.manifestId)) {
-            throw new Error("Can't register omnia service with id: " + this.manifestId + " must be a valid Guid");
+        if (!(0, fx_models_1.isValidGuid)(this.manifestId)) {
+            throw new Error("Can't register omnia service with id: " + this.manifestId + " must be a valid guid");
         }
         let serviceInfo = {
             description: serviceOptions.description,

package/internal-do-not-import-from-here/DependencyComposer.d.ts

@@ -1,5 +1,5 @@
 import { IComposerDone } from "./Composer";
-import { GuidValue } from '@omnia/fx-models';
+import { guid } from '@omnia/fx-models';
 export interface IDependencyComposer<T> {
     /**
     *   Add dependencies to other manifests
@@ -10,21 +10,21 @@ export interface IDependencyComposer<T> {
     *   Add dependencies to other manifests
     *   Dependent manifests will be loaded before the current manifest is loaded.
     */
-    withDependency: (manifestId: GuidValue) => ICompletableDependencyComposer<T>;
+    withDependency: (manifestId: guid) => ICompletableDependencyComposer<T>;
     /**
     *   Add dependencies to a manifest in another omnia service
     *   Dependent manifests will be loaded before the current manifest is loaded.
     */
-    withExternalDependency: (omniaServiceId: GuidValue, manifestId: GuidValue) => ICompletableDependencyComposer<T>;
+    withExternalDependency: (omniaServiceId: guid, manifestId: guid) => ICompletableDependencyComposer<T>;
 }
 export interface ICompletableDependencyComposer<T> extends IDependencyComposer<T>, IComposerDone<T> {
 }
 export declare class DependencyComposer<T> implements ICompletableDependencyComposer<T> {
     private currentManifestId;
     private composerForDone;
-    constructor(currentManifestId: GuidValue, composerForDone: T);
+    constructor(currentManifestId: guid, composerForDone: T);
     done: () => T;
     withNoDependency: () => T;
-    withDependency: (manifestId: GuidValue) => this;
-    withExternalDependency: (omniaServiceId: GuidValue, manifestId: GuidValue) => this;
+    withDependency: (manifestId: guid) => this;
+    withExternalDependency: (omniaServiceId: guid, manifestId: guid) => this;
 }

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

@@ -10,16 +10,16 @@ class DependencyComposer {
             return this.composerForDone;
         };
         this.withNoDependency = () => {
-            LoadableManifestRegistry_1.LoadableManifestRegistry.withNoDependency(this.currentManifestId.toString());
+            LoadableManifestRegistry_1.LoadableManifestRegistry.withNoDependency(this.currentManifestId);
             //Stop fluent
             return this.composerForDone;
         };
         this.withDependency = (manifestId) => {
-            LoadableManifestRegistry_1.LoadableManifestRegistry.addManifestDependency(this.currentManifestId.toString(), manifestId.toString());
+            LoadableManifestRegistry_1.LoadableManifestRegistry.addManifestDependency(this.currentManifestId, manifestId);
             return this;
         };
         this.withExternalDependency = (omniaServiceId, manifestId) => {
-            LoadableManifestRegistry_1.LoadableManifestRegistry.addManifestDependency(this.currentManifestId.toString(), manifestId.toString(), omniaServiceId.toString());
+            LoadableManifestRegistry_1.LoadableManifestRegistry.addManifestDependency(this.currentManifestId, manifestId, omniaServiceId);
             return this;
         };
     }

package/internal-do-not-import-from-here/LoadableManifestRegistry.d.ts

@@ -1,10 +1,10 @@
 import { BundleTargetTypes } from "./models/Enums";
-import { ClientManifest, LoadableBundleManifest, BundleIdentity, RegiterApiConfiguration, GuidValue } from '../../fx-models';
+import { ClientManifest, LoadableBundleManifest, BundleIdentity, RegiterApiConfiguration, guid } from '../../fx-models';
 export interface ResourceManifest extends ClientManifest {
     /**
         The unique id of the manifest, this will be the id of the resources added.
     */
-    resourceId: GuidValue;
+    resourceId: guid;
     /**
     The friendly name of the manifest
     */
@@ -40,7 +40,7 @@ export declare class StaticClientLoadableManifestProviderProxy implements IClien
     constructor(getClientLoadableManifestsFunc: (currentServiceId: string) => Array<LoadableBundleManifest>, clearStateFunc: () => void);
 }
 export interface IClientLoadableManifestProvider {
-    getClientLoadableManifests: (currentServiceId: GuidValue) => Array<LoadableBundleManifest>;
+    getClientLoadableManifests: (currentServiceId: guid) => Array<LoadableBundleManifest>;
     clearState: () => void;
 }
 export declare class LoadableManifestRegistry {
@@ -51,21 +51,21 @@ export declare class LoadableManifestRegistry {
     private static ClientManifests;
     private static RegisteredManifests;
     private static ClientManifestProviders;
-    static getRegisteredManifest: (manifestId: GuidValue) => ResourceManifest;
-    static withNoDependency: (manifestId: GuidValue) => void;
-    static isDefineWithNoDependency: (manifestId: GuidValue) => boolean;
-    static addManifestDependency: (manifestId: GuidValue, dependentOnManifestId: GuidValue, dependentManifestOmniaServiceId?: string) => void;
-    static getManifestDependencies: (manifestId: GuidValue, currentServiceId: GuidValue) => Array<BundleIdentity>;
-    static getAllManifestDependencies: () => Map<GuidValue, any[]>;
-    static addManifestVersion: (manifestId: GuidValue, type: BundleTargetTypes, version: string) => void;
-    static getManifestVersion: (manifestId: GuidValue) => {
+    static getRegisteredManifest: (manifestId: guid) => ResourceManifest;
+    static withNoDependency: (manifestId: guid) => void;
+    static isDefineWithNoDependency: (manifestId: guid) => boolean;
+    static addManifestDependency: (manifestId: guid, dependentOnManifestId: guid, dependentManifestOmniaServiceId?: guid) => void;
+    static getManifestDependencies: (manifestId: guid, currentServiceId: guid) => Array<BundleIdentity>;
+    static getAllManifestDependencies: () => Map<guid, any[]>;
+    static addManifestVersion: (manifestId: guid, type: BundleTargetTypes, version: string) => void;
+    static getManifestVersion: (manifestId: guid) => {
         [key: string]: string;
     };
-    static addManifestBundleType: (manifestId: GuidValue, type: BundleTargetTypes) => void;
-    static getManifestBundleTypes: (manifestId: GuidValue) => Array<BundleTargetTypes>;
-    static registerManifest: (manifest: ResourceManifest) => Map<GuidValue, ResourceManifest>;
+    static addManifestBundleType: (manifestId: guid, type: BundleTargetTypes) => void;
+    static getManifestBundleTypes: (manifestId: guid) => Array<BundleTargetTypes>;
+    static registerManifest: (manifest: ResourceManifest) => Map<guid, ResourceManifest>;
     static registerManifestProvider: (provider: IClientLoadableManifestProvider) => void;
-    static getClientManifests: (currentServiceId: GuidValue) => Array<ClientManifest>;
+    static getClientManifests: (currentServiceId: guid) => Array<ClientManifest>;
     static clearState: () => void;
     private static validateDependencies;
     private static addClientManifest;

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

@@ -46,7 +46,7 @@ class CircularDependencyValidator {
                     console.log(this.manifestId, dependency, this.dependency);
                     throw new Error("Have a exception");
                 }
-                if (this.CurrentDependencyChain.indexOf(dependency.manifestId.toString()) > -1) {
+                if (this.CurrentDependencyChain.indexOf(dependency.manifestId) > -1) {
                     return;
                 }
                 else {

package/internal-do-not-import-from-here/ManifestGroupComposer.d.ts

@@ -1,6 +1,7 @@
 import { IDependencyComposer, DependencyComposer } from "./DependencyComposer";
 import { ISecurityComposer, ManifestGroupOptions } from "./models";
 import { CombinableRuleComposer, ICombinableRuleComposer } from "./CombinableRuleComposer";
+import { guid } from '../../fx-models';
 export interface IManifestGroupComposer extends IDependencyComposer<IManifestGroupComposer>, ISecurityComposer<IManifestGroupComposer> {
     /** Add a rule(s) when the component group should be loaded
         Make sure to add rules which is not to generic, i.e. only load when needed
@@ -11,12 +12,12 @@ export interface IManifestGroupComposer extends IDependencyComposer<IManifestGro
 export declare class ManifestGroupComposer implements IManifestGroupComposer {
     private manifest;
     private ruleComposer;
-    constructor(manifestId: string, manifestName?: string);
+    constructor(manifestId: guid, manifestName?: string);
     registerManifestGroup: (groupOptions: ManifestGroupOptions) => this;
     withLoadRules: () => CombinableRuleComposer<IManifestGroupComposer>;
     withNoDependency: () => this;
-    withDependency: (manifestId: string) => DependencyComposer<this>;
-    withExternalDependency: (omniaServiceId: string, manifestId: string) => DependencyComposer<this>;
+    withDependency: (manifestId: guid) => DependencyComposer<this>;
+    withExternalDependency: (omniaServiceId: guid, manifestId: guid) => DependencyComposer<this>;
     disableAuth: () => any;
     private persistCombinedRules;
 }

package/internal-do-not-import-from-here/ManifestGroupRegistry.d.ts

@@ -1,5 +1,5 @@
 import { IClientLoadableManifestProvider, ResourceManifest } from "./LoadableManifestRegistry";
-import { ClientResolvableLoadRule, GroupedBundleManifest, GuidValue } from '../../fx-models';
+import { ClientResolvableLoadRule, GroupedBundleManifest, guid } from '../../fx-models';
 import { ManifestGroupOptions } from './models';
 export declare class ManifestGroupRegistration {
     manifestGroupOptions: ManifestGroupOptions;
@@ -9,7 +9,7 @@ export declare class ManifestGroupRegistration {
     constructor(manifestGroupOptions: ManifestGroupOptions, manifestPath: string, manifest: ResourceManifest);
 }
 export interface ManifestGroupDescription {
-    resourceId: GuidValue;
+    resourceId: guid;
     resourceName?: string;
     manifestIdsInGroup: Array<string>;
 }
@@ -20,7 +20,7 @@ export declare class ManifestGroupRegistry implements IClientLoadableManifestPro
     static newCombinedRules: (manifest: ResourceManifest, rules: Array<ClientResolvableLoadRule>) => void;
     static getManifestGroupRegistrations: () => any;
     static getRegistrations: () => Array<ManifestGroupDescription>;
-    getClientLoadableManifests: (currentServiceId: GuidValue) => Array<GroupedBundleManifest>;
+    getClientLoadableManifests: (currentServiceId: guid) => Array<GroupedBundleManifest>;
     clearState: () => void;
     private static ensureCorrectManifest;
     private static clearManifestGroupRegistrations;

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

@@ -13,12 +13,12 @@ class ManifestGroupRegistration {
         this.manifest = manifest;
         this.loadRules = [];
         // ensure is string value
-        if (this.manifestGroupOptions.resourceManifestIds) {
-            this.manifestGroupOptions.resourceManifestIds = this.manifestGroupOptions.resourceManifestIds.map(r => r.toString());
-        }
-        if (this.manifestGroupOptions.webComponentManifestIds) {
-            this.manifestGroupOptions.webComponentManifestIds = this.manifestGroupOptions.webComponentManifestIds.map(r => r.toString());
-        }
+        // if (this.manifestGroupOptions.resourceManifestIds) {
+        //     this.manifestGroupOptions.resourceManifestIds = this.manifestGroupOptions.resourceManifestIds
+        // }
+        // if (this.manifestGroupOptions.webComponentManifestIds) {
+        //     this.manifestGroupOptions.webComponentManifestIds = this.manifestGroupOptions.webComponentManifestIds.map(r => r)
+        // }
     }
 }
 exports.ManifestGroupRegistration = ManifestGroupRegistration;

package/internal-do-not-import-from-here/ManifestRegistry.d.ts

@@ -1,18 +1,18 @@
 import { ServerManifest, ServerManifestByTypeCollection } from "./models/index";
-import { ClientManifest, ClientManifestByTargetCollection, GuidValue } from '../../fx-models';
+import { ClientManifest, ClientManifestByTargetCollection, guid } from '../../fx-models';
 export interface IResetableProvider {
     clearState: () => void;
 }
 export interface IClientManifestProvider extends IResetableProvider {
-    getClientManifests: (currentServiceId: GuidValue) => Array<ClientManifest>;
+    getClientManifests: (currentServiceId: guid) => Array<ClientManifest>;
 }
 export interface IServerManifestProvider extends IResetableProvider {
-    getServerManifests: (currentServiceId: GuidValue) => Array<ServerManifest>;
+    getServerManifests: (currentServiceId: guid) => Array<ServerManifest>;
 }
 export declare class StaticClientManifestProviderProxy implements IClientManifestProvider {
-    getClientManifests: (currentServiceId: GuidValue) => ClientManifest[];
+    getClientManifests: (currentServiceId: guid) => ClientManifest[];
     clearState: () => void;
-    constructor(getClientManifestsFunc: (currentServiceId: GuidValue) => Array<ClientManifest>, clearStateFunc: () => void);
+    constructor(getClientManifestsFunc: (currentServiceId: guid) => Array<ClientManifest>, clearStateFunc: () => void);
 }
 export declare class StaticServerManifestProviderProxy implements IServerManifestProvider {
     getServerManifests: (currentOmniaServiceId: string) => ServerManifest[];
@@ -28,8 +28,8 @@ export declare class ManifestRegistry {
     static registerServerManifestProvider: (provider: IServerManifestProvider) => void;
     static setCurrentManifestPath: (manifestPath?: string) => void;
     static getCurrentManifestPath: () => string;
-    static getClientManifests: (currentServiceId: GuidValue) => ClientManifestByTargetCollection;
-    static getServerManifests: (currentOmniaServiceId: string) => ServerManifestByTypeCollection;
+    static getClientManifests: (currentServiceId: guid) => ClientManifestByTargetCollection;
+    static getServerManifests: (currentOmniaServiceId: guid) => ServerManifestByTypeCollection;
     static clearState: () => void;
     private static addResetableProvider;
 }

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

@@ -9,7 +9,7 @@ const models_1 = require("../../fx-models");
 class RequestedResourcesRegistry {
     static { this.RequestedResources = {}; }
     static { this.AddSql = (option) => {
-        if (!models_1.Guid.isValid(option.uniqueId)) {
+        if (!(0, models_1.isValidGuid)(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) {
@@ -23,7 +23,7 @@ class RequestedResourcesRegistry {
         RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = sqlResourceManifest;
     }; }
     static { this.AddPersistentDisk = (option) => {
-        if (!models_1.Guid.isValid(option.uniqueId)) {
+        if (!(0, models_1.isValidGuid)(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) {
@@ -37,7 +37,7 @@ class RequestedResourcesRegistry {
         RequestedResourcesRegistry.RequestedResources[option.uniqueId.toString()] = persistentDiskResourceManifest;
     }; }
     static { this.AddSqlElasticPool = (option) => {
-        if (!models_1.Guid.isValid(option.uniqueId)) {
+        if (!(0, models_1.isValidGuid)(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) {

package/internal-do-not-import-from-here/ResourceRegistry.d.ts

@@ -1,6 +1,6 @@
 import { OrderOptions, ResourcesOptions, ResourceBuildOptions } from "./models/index";
 import { ResourceManifest, IClientLoadableManifestProvider } from "./LoadableManifestRegistry";
-import { ClientResolvableLoadRule, GuidValue, ResourcesBundleManifest } from '../../fx-models';
+import { ClientResolvableLoadRule, guid, ResourcesBundleManifest } from '../../fx-models';
 export interface ResourcePathsWithBuildOptions {
     paths: Array<String>;
     buildOptions: ResourceBuildOptions;
@@ -22,9 +22,9 @@ export declare class ResourceRegistry implements IClientLoadableManifestProvider
     static addBuildOptions: (manifest: ResourceManifest, buildOptions: ResourceBuildOptions) => void;
     static newCombinedRules: (manifest: ResourceManifest, rules: Array<ClientResolvableLoadRule>) => void;
     static addExtendApiRules: (manifest: ResourceManifest, rules: Array<ClientResolvableLoadRule>) => void;
-    static getRegisteredResourceBundles: (pathJoiner: (path1: any, path2: any) => string[]) => Map<GuidValue, ResourcePathsWithBuildOptions>;
-    static getResourceRegistrations: () => Map<GuidValue, ResourceRegistration[]>;
-    getClientLoadableManifests: (currentServiceId: GuidValue) => Array<ResourcesBundleManifest>;
+    static getRegisteredResourceBundles: (pathJoiner: (path1: any, path2: any) => string[]) => Map<guid, ResourcePathsWithBuildOptions>;
+    static getResourceRegistrations: () => Map<guid, ResourceRegistration[]>;
+    getClientLoadableManifests: (currentServiceId: guid) => Array<ResourcesBundleManifest>;
     clearState: () => void;
     private static ensureCorrectManifest;
 }

package/internal-do-not-import-from-here/ResourcesComposer.d.ts

@@ -2,6 +2,7 @@ import { DependencyComposer } from "./DependencyComposer";
 import { OrderOptions, ResourcesOptions, ILocalizationComposer, LocalizationOptions } from "./models";
 import { ICombinableRuleComposer, CombinableRuleComposer } from "./CombinableRuleComposer";
 import { Localization } from "./LocalizationComposer";
+import { guid } from '../../fx-models';
 import { ComposerBase, IComposerBase } from "./ComposerBase";
 export interface IReOpendedResourcesComposer {
     /** Add more resources to the opened manifest */
@@ -29,7 +30,7 @@ export interface IResourcesComposer extends IComposerBase<IResourcesComposer> {
 export declare class ReOpenedResourceComposer implements IReOpendedResourcesComposer, IReOpendedResourcesOrderingComposer {
     private manifest;
     private manifestId;
-    constructor(manifestId: string);
+    constructor(manifestId: guid);
     registerResource: (resourcesOptions: ResourcesOptions) => this;
     orderUsing: (orderOption: OrderOptions) => void;
     registerLocalization: (localizationOptions: LocalizationOptions) => Localization;
@@ -37,11 +38,11 @@ export declare class ReOpenedResourceComposer implements IReOpendedResourcesComp
 export declare class ResourcesComposer extends ComposerBase<IResourcesComposer> implements IResourcesComposer {
     private manifestName?;
     private ruleComposer;
-    constructor(manifestId: string, manifestName?: string);
+    constructor(manifestId: guid, manifestName?: string);
     registerResource: (resourcesOptions: ResourcesOptions) => this;
     withLoadRules: () => CombinableRuleComposer<IResourcesComposer>;
     withNoDependency: () => this;
-    withDependency: (manifestId: string) => DependencyComposer<this>;
-    withExternalDependency: (omniaServiceId: string, manifestId: string) => DependencyComposer<this>;
+    withDependency: (manifestId: guid) => DependencyComposer<this>;
+    withExternalDependency: (omniaServiceId: guid, manifestId: guid) => DependencyComposer<this>;
     private persistCombinedRules;
 }

package/internal-do-not-import-from-here/ServiceAppRegistry.d.ts

@@ -1,8 +1,8 @@
 import { ServiceAppDefinitionOption } from './models/index';
-import { GuidValue } from '../../fx-models';
+import { guid } from '../../fx-models';
 export declare class ServiceAppRegistry {
     private static AddedAppDefinitions;
-    static AddAppDefinition: (appDefinitionId: GuidValue, option: ServiceAppDefinitionOption) => void;
+    static AddAppDefinition: (appDefinitionId: guid, option: ServiceAppDefinitionOption) => void;
     private static getServerManifests;
     private static clearState;
     private static ServerSubscription;

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

@@ -9,10 +9,10 @@ const models_1 = require("../../fx-models");
 class ServiceAppRegistry {
     static { this.AddedAppDefinitions = {}; }
     static { this.AddAppDefinition = (appDefinitionId, option) => {
-        if (appDefinitionId == models_1.Guid.empty) {
-            throw new Error("Can't add app definition with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        if (appDefinitionId === models_1.emptyGuid) {
+            throw new Error("Can't add app definition with id: emptyGuid. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
         }
-        if (ServiceAppRegistry.AddedAppDefinitions[appDefinitionId.toString()] != null) {
+        if (ServiceAppRegistry.AddedAppDefinitions[appDefinitionId] != null) {
             throw new Error("Can't add app definition id " + appDefinitionId + ", an app definition with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
         }
         let manifest = {
@@ -20,7 +20,7 @@ class ServiceAppRegistry {
         };
         let appManifest = (0, deep_extend_1.default)(manifest, option);
         appManifest.uniqueId = appDefinitionId;
-        ServiceAppRegistry.AddedAppDefinitions[appDefinitionId.toString()] = appManifest;
+        ServiceAppRegistry.AddedAppDefinitions[appDefinitionId] = appManifest;
     }; }
     static { this.getServerManifests = (currentServiceId) => {
         let serverManifests = new Array();

package/internal-do-not-import-from-here/ServiceComposer.d.ts

@@ -2,6 +2,7 @@ import { ServiceOptions } from './models';
 import { IWebAppServiceComposer } from './WebAppServiceComposer';
 import { IWorkerServiceComposer } from './WorkerServiceComposer';
 import { ICustomServiceComposer } from './CustomServiceComposer';
+import { guid } from '@omnia/fx-models';
 export interface IRegisterService {
     /** Specify service type for this omnia service project.
     E.g. A service could be a worker, doing simple async jobs, worker queues etc
@@ -27,7 +28,7 @@ export declare class ServiceComposer implements IServiceComposer {
     private manifestId;
     private manifestName;
     private serviceInfo;
-    constructor(manifestId: string, manifestName: string, serviceInfo: ServiceOptions);
+    constructor(manifestId: guid, manifestName: string, serviceInfo: ServiceOptions);
     AsWebApp: () => IWebAppServiceComposer;
     AsWorker: () => IWorkerServiceComposer;
     AsCustom: () => ICustomServiceComposer;

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

@@ -20,8 +20,8 @@ class ServiceComposer {
         this.AsCustom = () => {
             return new CustomServiceComposer_1.CustomServiceComposer(this.manifestId, this.manifestName, this.serviceInfo);
         };
-        if (!fx_models_1.Guid.isValid(this.manifestId)) {
-            throw new Error("Can't register service with id: " + this.manifestId + " must be a valid Guid");
+        if (!(0, fx_models_1.isValidGuid)(this.manifestId)) {
+            throw new Error("Can't register service with id: " + this.manifestId + " must be a valid guid");
         }
     }
 }

package/internal-do-not-import-from-here/ServiceFeatureRegistry.d.ts

@@ -1,8 +1,8 @@
 import { ServiceFeatureOption } from './models/index';
-import { GuidValue } from '../../fx-models';
+import { guid } from '../../fx-models';
 export declare class ServiceFeatureRegistry {
     private static AddedFeatures;
-    static AddFeature: (featureId: GuidValue, option: ServiceFeatureOption) => void;
+    static AddFeature: (featureId: guid, option: ServiceFeatureOption) => void;
     private static getServerManifests;
     private static clearState;
     private static ServerSubscription;

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

@@ -10,8 +10,8 @@ const AzureAdAppPermissionHelper_1 = require("./AzureAdAppPermissionHelper");
 class ServiceFeatureRegistry {
     static { this.AddedFeatures = {}; }
     static { this.AddFeature = (featureId, option) => {
-        if (featureId == models_1.Guid.empty) {
-            throw new Error("Can't add feature with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        if (featureId === models_1.emptyGuid) {
+            throw new Error("Can't add feature with id: emptyGuid. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
         }
         if (ServiceFeatureRegistry.AddedFeatures[featureId.toString()] != null) {
             throw new Error("Can't add feature id " + featureId + ", a feature with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());

package/internal-do-not-import-from-here/ServiceRoleRegistry.d.ts

@@ -1,8 +1,8 @@
 import { ServiceRoleDefinitionOption } from './models/index';
-import { GuidValue } from '../../fx-models';
+import { guid } from '../../fx-models';
 export declare class ServiceRoleRegistry {
     private static AddedRoleDefinitions;
-    static AddRoleDefinition: (roleDefinitionId: GuidValue, option: ServiceRoleDefinitionOption) => void;
+    static AddRoleDefinition: (roleDefinitionId: guid, option: ServiceRoleDefinitionOption) => void;
     private static getServerManifests;
     private static clearState;
     private static ServerSubscription;

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

@@ -9,8 +9,8 @@ const models_1 = require("../../fx-models");
 class ServiceRoleRegistry {
     static { this.AddedRoleDefinitions = {}; }
     static { this.AddRoleDefinition = (roleDefinitionId, option) => {
-        if (roleDefinitionId == models_1.Guid.empty) {
-            throw new Error("Can't add role definition with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        if (roleDefinitionId === models_1.emptyGuid) {
+            throw new Error("Can't add role definition with id: emptyGuid. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
         }
         if (ServiceRoleRegistry.AddedRoleDefinitions[roleDefinitionId.toString()] != null) {
             throw new Error("Can't add role definition id " + roleDefinitionId + ", an role definition with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());

package/internal-do-not-import-from-here/Utils.d.ts

@@ -1,7 +1,7 @@
-import { ClientResolvableLoadRule, GuidValue } from '../../fx-models';
+import { ClientResolvableLoadRule, guid } from '../../fx-models';
 export declare class Utils {
-    static ensureValidManifestId: (id: GuidValue, errorMsg?: string) => string;
-    static ensureValidServiceId: (id: GuidValue, errorMsg?: string) => string;
+    static ensureValidManifestId: (id: guid, errorMsg?: string) => guid;
+    static ensureValidServiceId: (id: guid, errorMsg?: string) => guid;
     static ensureValidElementName: (name: string, errorMsg?: string) => string;
     static validateSupportedLoadRuleTypes: (rules: Array<ClientResolvableLoadRule>) => void;
     static validateSupportedLoadRuleType: (rule: ClientResolvableLoadRule) => void;

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

@@ -1,24 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
-const models_1 = require("../../fx-models");
 //import { LoadByUrlMatchingRule, DomMatchingRule, ClientResolvableLoadRule, FeatureActiveRule, LoadIfManifestLoaded } from "./models";
 class Utils {
     static { this.ensureValidManifestId = (id, errorMsg) => {
+        console.dir(id);
+        //TODO: If you end up here looking for tolowerCase bugs of guids the toooling should handle lowercase
+        //call 911-Nhan
         if (!id) {
             throw new Error(errorMsg ? errorMsg : "Invalid manifest id, can't be null/empty or undefined");
         }
-        if (!models_1.Guid.isValid(id.toString())) {
-            console.dir(id);
-            throw new Error("The manifest id must be a valid guid");
-        }
-        return id.toString().toLowerCase();
+        // if (!isValidGuid(guid)) {
+        //     throw new Error("The manifest id must be a valid guid");
+        // }
+        return id;
+        //return id.toLowerCase();
     }; }
     static { this.ensureValidServiceId = (id, errorMsg) => {
+        //TODO: If you end up here looking for tolowerCase bugs of guids the toooling should handle lowercase
+        //call 911-Nhan
         if (!id) {
             throw new Error(errorMsg ? errorMsg : "Invalid service id, can't be null/empty or undefined");
         }
-        return id.toString().toLowerCase();
+        return id;
+        //return id.toLowerCase();
     }; }
     static { this.ensureValidElementName = (name, errorMsg) => {
         if (!name) {

package/internal-do-not-import-from-here/WebAppServiceComposer.d.ts

@@ -1,6 +1,7 @@
 import { BuildOptions, ServiceOptions, RoleBasedSecurityProviderOptions, CombinedSecurityProviderOptions } from './models';
 import { ICombinableSecurityProviderComposer, SecurityProviderCombinableRuleComposer } from './CombinableSecurityProviderComposer';
 import { IServiceManifestComposer, ServiceManifestComposer } from './ServiceManifestComposer';
+import { guid } from '../../fx-models';
 import { IClientServiceConfigurator } from './ConfigurationClientServiceRegistry';
 export interface IWebAppServiceComposer extends IServiceManifestComposer<IWebAppServiceComposer> {
     /**
@@ -32,7 +33,7 @@ export interface IWebAppServiceComposer extends IServiceManifestComposer<IWebApp
 export declare class WebAppServiceComposer extends ServiceManifestComposer<WebAppServiceComposer> implements IWebAppServiceComposer {
     private manifestId;
     private manifestTitle;
-    constructor(manifestId: string, manifestTitle: string, serviceOptions: ServiceOptions);
+    constructor(manifestId: guid, manifestTitle: string, serviceOptions: ServiceOptions);
     configuration: <T extends IClientServiceConfigurator<IWebAppServiceComposer>>(configurationType: any) => T;
     withBuildOptions: (options: BuildOptions) => this;
     AddRoleBasedSecurityProvider: (options: RoleBasedSecurityProviderOptions) => this;

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

@@ -16,7 +16,7 @@ class WebAppServiceComposer extends ServiceManifestComposer_1.ServiceManifestCom
         this.manifestId = manifestId;
         this.manifestTitle = manifestTitle;
         this.configuration = (configurationType) => {
-            return ConfigurationClientServiceRegistry_1.ConfigurationClientServiceRegistry.Add(new models_2.Guid(this.manifestId), configurationType, [this]);
+            return ConfigurationClientServiceRegistry_1.ConfigurationClientServiceRegistry.Add(this.manifestId, configurationType, [this]);
         };
         this.withBuildOptions = (options) => {
             BuildConfigurationRegistry_1.BuildConfigurationRegistry.AddBuildOptions(options);
@@ -31,8 +31,8 @@ class WebAppServiceComposer extends ServiceManifestComposer_1.ServiceManifestCom
             if (!validScope) {
                 throw new Error("Can't add role based security provider with scope: " + options.scope + " it's not a valid scope value");
             }
-            if (!models_2.Guid.isValid(options.providerId)) {
-                throw new Error("Can't add role based security provider with id: " + options.providerId + " must be a valid Guid");
+            if (!(0, models_2.isValidGuid)(options.providerId)) {
+                throw new Error("Can't add role based security provider with id: " + options.providerId + " must be a valid guid");
             }
             if (!options.roleName) {
                 throw new Error("Can't add role based security provider with out valid role name: " + JSON.stringify(options));
@@ -50,8 +50,8 @@ class WebAppServiceComposer extends ServiceManifestComposer_1.ServiceManifestCom
             if (!options) {
                 throw new Error("Can't add combined security provider with missing options");
             }
-            if (!models_2.Guid.isValid(options.providerId)) {
-                throw new Error("Can't add combined security provider with id: " + options.providerId + " must be a valid Guid");
+            if (!(0, models_2.isValidGuid)(options.providerId)) {
+                throw new Error("Can't add combined security provider with id: " + options.providerId + " must be a valid guid");
             }
             let combinedProvider = {
                 providerId: options.providerId,
@@ -64,8 +64,8 @@ class WebAppServiceComposer extends ServiceManifestComposer_1.ServiceManifestCom
             SecurityProviderManifestRegistry_1.SecurityProviderManifestRegistry.AddSecurityProvider(combinedProvider);
             return new CombinableSecurityProviderComposer_1.SecurityProviderCombinableRuleComposer(cbNewRule, this);
         };
-        if (!models_2.Guid.isValid(this.manifestId)) {
-            throw new Error("Can't register omnia service with id: " + this.manifestId + " must be a valid Guid");
+        if (!(0, models_2.isValidGuid)(this.manifestId)) {
+            throw new Error("Can't register omnia service with id: " + this.manifestId + " must be a valid guid");
         }
         let serviceInfo = {
             description: serviceOptions.description,

package/internal-do-not-import-from-here/WorkerServiceComposer.d.ts

@@ -1,5 +1,6 @@
 import { ServiceOptions } from './models';
 import { IServiceManifestComposer, ServiceManifestComposer } from './ServiceManifestComposer';
+import { guid } from '@omnia/fx-models';
 export interface IWorkerServiceComposer extends IServiceManifestComposer<IWorkerServiceComposer> {
     /**
      * This service is not deployed as standard, the exact behavior can be decided at deploy time for each optional service.
@@ -10,6 +11,6 @@ export interface IWorkerServiceComposer extends IServiceManifestComposer<IWorker
 export declare class WorkerServiceComposer extends ServiceManifestComposer<IWorkerServiceComposer> implements IWorkerServiceComposer {
     private manifestId;
     private manifestTitle;
-    constructor(manifestId: string, manifestTitle: string, serviceOptions: ServiceOptions);
+    constructor(manifestId: guid, manifestTitle: string, serviceOptions: ServiceOptions);
     isOptionalService(): this;
 }

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

@@ -11,8 +11,8 @@ class WorkerServiceComposer extends ServiceManifestComposer_1.ServiceManifestCom
         super(() => { return this; });
         this.manifestId = manifestId;
         this.manifestTitle = manifestTitle;
-        if (!fx_models_1.Guid.isValid(this.manifestId)) {
-            throw new Error("Can't register omnia service with id: " + this.manifestId + " must be a valid Guid");
+        if (!(0, fx_models_1.isValidGuid)(this.manifestId)) {
+            throw new Error("Can't register omnia service with id: " + this.manifestId + " must be a valid guid");
         }
         let serviceInfo = {
             description: serviceOptions.description,

package/internal-do-not-import-from-here/models/Build.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue } from '@omnia/fx-models';
+import { guid } from '@omnia/fx-models';
 export interface BuildOptions {
     /**
     * enable tree shaking for dead-code elimination.
@@ -54,7 +54,7 @@ export interface BuildOptions {
     /**
     * Create dynamic documentaion with manifest id.
     */
-    docResourceManifestId?: GuidValue;
+    docResourceManifestId?: guid;
     /**
     * Create a namespace to element name.
     */
@@ -79,7 +79,7 @@ export interface BundleOptions {
         /**
         * The chunk name of the commons chunk. If set to manifest id, will append content to that manifest.
         */
-        name: GuidValue;
+        name: guid;
         /**
         * The minimum number of chunks which need to contain a module before it's moved into the commons chunk. Default value is 2.
         */

package/internal-do-not-import-from-here/models/ManifestGroupComposer.d.ts

@@ -1,7 +1,7 @@
-import { GuidValue } from "@omnia/fx-models";
-export interface ManifestGroupOptions<T extends string | GuidValue = string> {
+import { guid } from "@omnia/fx-models";
+export interface ManifestGroupOptions {
     /** The manifest id's of the webcomponent's to include in this group */
-    webComponentManifestIds?: Array<T>;
+    webComponentManifestIds?: Array<guid>;
     /** The manifest id's of the resources to include in this group */
-    resourceManifestIds?: Array<T>;
+    resourceManifestIds?: Array<guid>;
 }

package/internal-do-not-import-from-here/models/ServerManifests.d.ts

@@ -3,7 +3,7 @@ import { SecurityProviderTypes, SecurityRoleScopes, RuleLogicalOperator, Service
 import { IIcon } from '../../../fx-models/Icon';
 import { ServiceParam } from '../../../fx-models/ServiceParam';
 import { FeatureUIOption, IFeatureConfiguration } from '../../../fx-models/Feature';
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { OmniaBackendRuntimes, OmniaRoleTypes, PersistentDiskTypes } from "../../../fx-models/Enums";
 import { AzureAdAppPermissionInfo, AzureAdAppResourceAccessWithAlternate } from "../../../fx-models/AzureAdAppPermissions";
 import { AzureAdAppPermissionOption } from "../AzureAdAppPermissionHelper";
@@ -58,7 +58,7 @@ export interface ServiceFeatureOption {
      * PermissionRole
      * Permission Role required for activating/upgrading/deactivating feature
      * */
-    permissionRole: GuidValue;
+    permissionRole: guid;
     /**
      * UIOptions
      * Optional - used to specify the client-side control which will display the wizard when activating/upgrading/deactivating feature
@@ -73,7 +73,7 @@ export interface ServiceFeatureOption {
     * requiresLicense
     * Optional - Specify license id(s) if the feature requires license to be activated
     * */
-    requiresLicense?: Array<GuidValue>;
+    requiresLicense?: Array<guid>;
     /**
     * requiresBackendEnvironment
     * Optional - Specify Backend runtime evironment to be activated
@@ -89,16 +89,16 @@ export interface ServiceFeatureOption {
     configuration?: IFeatureConfiguration;
 }
 export interface ServiceFeatureManifest extends Omit<ServiceFeatureOption, 'requiresAzureAdAppPermissions'>, ServerManifest {
-    uniqueId: GuidValue;
+    uniqueId: guid;
     requiresAzureAdAppPermissions?: AzureAdAppPermissionInfo[];
 }
 export interface AppResourceType {
-    id: GuidValue;
+    id: guid;
     title: string;
     icon: IIcon;
     parameters: Array<ServiceParam>;
     providedParameters: Array<ServiceParam>;
-    requiredFeatures?: Array<GuidValue>;
+    requiredFeatures?: Array<guid>;
     requiredEnvironments?: Array<string>;
 }
 export interface ServiceAppDefinitionOption {
@@ -118,7 +118,7 @@ export interface ServiceAppDefinitionOption {
     * requiresLicense
     * Optional - Specify license id(s) if the app requires license
     * */
-    requiresLicense?: Array<GuidValue>;
+    requiresLicense?: Array<guid>;
     /**
      * Hidden
      * Optional - used to specify whether the app is hidden in the UI and only available to be activated from api
@@ -130,7 +130,7 @@ export interface ServiceAppDefinitionOption {
     resourceTypes: AppResourceType[];
 }
 export interface ServiceAppDefinitionManifest extends ServiceAppDefinitionOption, ServerManifest {
-    uniqueId: GuidValue;
+    uniqueId: guid;
 }
 export interface ServiceRoleDefinitionOption {
     name: string;
@@ -138,25 +138,25 @@ export interface ServiceRoleDefinitionOption {
     resourceEvaluatorType?: string;
     roleType: OmniaRoleTypes;
     parameters?: ServiceParam[];
-    parentRole?: GuidValue;
+    parentRole?: guid;
     rules?: SecurityRule[];
-    editableRoles?: GuidValue[];
-    systemDefinedRuleMappingRoles?: GuidValue[];
+    editableRoles?: guid[];
+    systemDefinedRuleMappingRoles?: guid[];
     isBindable?: boolean;
     isExtensionOnly?: boolean;
 }
 export interface ServiceRoleDefinitionManifest extends ServiceRoleDefinitionOption, ServerManifest {
-    uniqueId: GuidValue;
+    uniqueId: guid;
 }
 export interface SecurityRule {
-    roleId: GuidValue;
+    roleId: guid;
     logicalOperator: "OR" | "AND";
 }
 export interface RequestedResourceManifest extends ServerManifest {
     resourceType: RequestedResourceTypes;
 }
 export interface ResourceOptionBase {
-    uniqueId: GuidValue;
+    uniqueId: guid;
 }
 export interface SqlResourceOption extends ResourceOptionBase {
 }
@@ -164,7 +164,7 @@ export interface PersistentDiskResourceOption extends ResourceOptionBase {
     type?: PersistentDiskTypes;
 }
 export interface SqlElasticPoolResourceOption extends ResourceOptionBase {
-    elasticPoolId: GuidValue;
+    elasticPoolId: guid;
 }
 export interface SqlResourceManifest extends SqlResourceOption, RequestedResourceManifest {
 }
@@ -183,7 +183,7 @@ export interface SecurityProviderManifest extends ServerManifest {
 }
 export interface AzureAdAppPermissionManifest extends ServerManifest {
     name?: string;
-    resourceAppId: GuidValue;
+    resourceAppId: guid;
     resourceAccess: AzureAdAppResourceAccessWithAlternate[];
 }
 export interface AzureAdAppPermission {
@@ -214,7 +214,7 @@ export interface ServiceOptions {
     description?: string;
 }
 export interface ServiceBase extends ServiceOptions {
-    id: string;
+    id: guid;
     title?: string;
     serviceType: ServiceTypes;
     optionalService: boolean;
@@ -225,7 +225,7 @@ export interface CustomService extends ServiceBase {
 export interface ServiceManifest extends ServiceBase, ServerManifest {
 }
 export interface SecurityProviderIdentity {
-    providerId: string;
+    providerId: guid;
 }
 export interface SecurityProvider extends SecurityProviderIdentity {
     type: SecurityProviderTypes;

package/internal-do-not-import-from-here/task.d.ts

@@ -1,4 +1,4 @@
-import { ClientManifestTargetTypes, GuidValue, LoadableBundleManifest, OmniaManifests } from '@omnia/fx-models';
+import { ClientManifestTargetTypes, guid, LoadableBundleManifest, OmniaManifests } from '@omnia/fx-models';
 declare const BuildStage: {
     BeforeScanManifests: string;
     AfterScanManifests: string;
@@ -25,9 +25,9 @@ declare function scanManifests(scanFolders?: any): void;
 declare function getManifestsPaths(urlsToSearch: any, options: any): any[];
 declare function processManifests(manifestPaths: string[]): void;
 declare function buildLocalizationFiles(): void;
-declare function getServiceId(): string;
+declare function getServiceId(): guid;
 declare function getManifestJsonByTarget(target?: ClientManifestTargetTypes): OmniaManifests;
 declare function getManifestsJson(): OmniaManifests;
 declare function updateManifestData(manifest: OmniaManifests): void;
-declare function getManifestById(id: GuidValue): LoadableBundleManifest;
+declare function getManifestById(id: guid): LoadableBundleManifest;
 export { getServiceId, getManifestById, getManifestsJson, getManifestJsonByTarget, updateManifestData, scanManifests, getManifestsPaths, processManifests, buildManifestEntries, build, bundleManifestsByWebpackEntries, buildLocalizationFiles, OmniaOutput, BuildStage };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/tooling-composers",
   "license": "MIT",
-  "version": "8.0.192-dev",
+  "version": "8.0.193-dev",
   "description": "Provide tooling to work with manifest things.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -19,8 +19,8 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "8.0.192-dev",
-    "@omnia/tooling": "8.0.192-dev",
+    "@omnia/fx-models": "8.0.193-dev",
+    "@omnia/tooling": "8.0.193-dev",
     "deep-extend": "0.6.0",
     "fs-extra": "11.1.0",
     "del": "6.0.0",