@omnia/fx 8.0.191-dev → 8.0.193-dev

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

@@ -1,13 +1,13 @@
-import { InstanceLifetimes, GuidValue, StoreDefintion as OmniaStoreDefinition, StateMutation, MutatableState, IMessageBusSubscriptionHandler } from "../models";
+import { InstanceLifetimes, StoreDefintion as OmniaStoreDefinition, StateMutation, MutatableState, guid, IMessageBusSubscriptionHandler } from "../models";
 export declare enum StoreLogTypes {
     mutation = "Mutation",
     action = "Action"
 }
 export interface StoreLog {
-    id: GuidValue;
+    id: guid;
     name: string;
     type: StoreLogTypes;
-    storeId: GuidValue;
+    storeId: guid;
     storeName: string;
     createdAt: Date;
     object: StateMutation<any>;
@@ -27,7 +27,7 @@ export declare class StoreLogger {
     private _logState;
     enabled: boolean;
     constructor(logState: Array<StoreLog>);
-    add(id: GuidValue, name: string, type: StoreLogTypes, storeId: GuidValue, storeName: string, object: StateMutationLog): void;
+    add(id: guid, name: string, type: StoreLogTypes, storeId: guid, storeName: string, object: StateMutationLog): void;
     enable(): void;
     disable(): void;
     get log(): Array<StoreLog>;
@@ -41,7 +41,7 @@ export declare abstract class Store {
     private _storeDefinition;
     private _disposed;
     constructor(storeDefinition?: Omit<OmniaStoreDefinition, "id">);
-    protected get id(): GuidValue;
+    protected get id(): guid;
     /**
      *  Triggers when the store is ready to be used
      * */

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

@@ -1,4 +1,4 @@
-import { GuidValue, TargetingProperty, TargetingPropertyData, TargetingPropertyResult, TargetingPropertyQuery, TargetingPropertyFlatResult } from "../models";
+import { guid, TargetingProperty, TargetingPropertyData, TargetingPropertyResult, TargetingPropertyQuery, TargetingPropertyFlatResult } from "../models";
 import { Store } from "./Store";
 import { TargetingPropertyService } from "../services/TargetingPropertyService";
 export declare class TargetingPropertyStore extends Store {
@@ -11,8 +11,8 @@ export declare class TargetingPropertyStore extends Store {
     }>;
     getters: {
         properties: () => TargetingProperty<TargetingPropertyData>[];
-        propertiesForEnterpriseProperty: (enterprisePropertyDefinitionId: GuidValue) => TargetingProperty<TargetingPropertyData>[];
-        property: (id: GuidValue) => TargetingProperty<TargetingPropertyData>;
+        propertiesForEnterpriseProperty: (enterprisePropertyDefinitionId: guid) => TargetingProperty<TargetingPropertyData>[];
+        property: (id: guid) => TargetingProperty<TargetingPropertyData>;
         userTargetingResult: (queries: TargetingPropertyQuery[]) => TargetingPropertyFlatResult[];
     };
     mutations: {};
@@ -20,10 +20,10 @@ export declare class TargetingPropertyStore extends Store {
         ensureLoadData: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
         addTargetingProperty: import("./Store").StoreAction<unknown, (property: TargetingProperty<TargetingPropertyData>) => void, (result: unknown, property: TargetingProperty<TargetingPropertyData>) => void, (failureReason: any, property: TargetingProperty<TargetingPropertyData>) => void, (property: TargetingProperty<TargetingPropertyData>) => Promise<unknown>>;
         updateTargetingProperty: import("./Store").StoreAction<unknown, (property: TargetingProperty<TargetingPropertyData>) => void, (result: unknown, property: TargetingProperty<TargetingPropertyData>) => void, (failureReason: any, property: TargetingProperty<TargetingPropertyData>) => void, (property: TargetingProperty<TargetingPropertyData>) => Promise<unknown>>;
-        removeTargetingProperty: import("./Store").StoreAction<unknown, (propertyId: GuidValue) => void, (result: unknown, propertyId: GuidValue) => void, (failureReason: any, propertyId: GuidValue) => void, (propertyId: GuidValue) => Promise<unknown>>;
+        removeTargetingProperty: import("./Store").StoreAction<unknown, (propertyId: guid) => void, (result: unknown, propertyId: guid) => void, (failureReason: any, propertyId: guid) => void, (propertyId: guid) => Promise<unknown>>;
         ensureUserTargetingResult: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
-        terminateTargetingProperty: import("./Store").StoreAction<unknown, (propertyId: GuidValue) => void, (result: unknown, propertyId: GuidValue) => void, (failureReason: any, propertyId: GuidValue) => void, (propertyId: GuidValue) => Promise<unknown>>;
-        restoreTargetingProperty: import("./Store").StoreAction<unknown, (propertyId: GuidValue) => void, (result: unknown, propertyId: GuidValue) => void, (failureReason: any, propertyId: GuidValue) => void, (propertyId: GuidValue) => Promise<unknown>>;
+        terminateTargetingProperty: import("./Store").StoreAction<unknown, (propertyId: guid) => void, (result: unknown, propertyId: guid) => void, (failureReason: any, propertyId: guid) => void, (propertyId: guid) => Promise<unknown>>;
+        restoreTargetingProperty: import("./Store").StoreAction<unknown, (propertyId: guid) => void, (result: unknown, propertyId: guid) => void, (failureReason: any, propertyId: guid) => void, (propertyId: guid) => Promise<unknown>>;
     };
     onActivated(): void;
     onDisposing(): void;

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

@@ -1,4 +1,4 @@
-import { GroupIdentity, GuidValue, Identity, IdentityProperty, UserIdentityPropertyDefinition, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity, LanguagePropertyValue } from "@omnia/fx-models";
+import { GroupIdentity, Identity, IdentityProperty, UserIdentityPropertyDefinition, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity, guid, LanguagePropertyValue } from "@omnia/fx-models";
 import { MediaPickerService, UserPresenceStatus } from "../services";
 import { Store } from "./Store";
 export declare class UserIdentityStore extends Store {
@@ -54,9 +54,9 @@ export declare class UserIdentityStore extends Store {
             [groupUid: string]: boolean;
         }>>;
         getUserGroups: import("./Store").StoreAction<unknown, (user: UserIdentity) => void, (result: GroupIdentity[], user: UserIdentity) => void, (failureReason: any, user: UserIdentity) => void, (user: UserIdentity) => Promise<GroupIdentity[]>>;
-        getIdentitiesWithProviderIdentities: import("./Store").StoreAction<unknown, (providerId: GuidValue, userIds: GuidValue[]) => void, (result: {
+        getIdentitiesWithProviderIdentities: import("./Store").StoreAction<unknown, (providerId: guid, userIds: guid[]) => void, (result: {
             [userIdentityUid: string]: Identity;
-        }, providerId: GuidValue, userIds: GuidValue[]) => void, (failureReason: any, providerId: GuidValue, userIds: GuidValue[]) => void, (providerId: GuidValue, userIds: GuidValue[]) => Promise<{
+        }, providerId: guid, userIds: guid[]) => void, (failureReason: any, providerId: guid, userIds: guid[]) => void, (providerId: guid, userIds: guid[]) => Promise<{
             [userIdentityUid: string]: Identity;
         }>>;
         setUiLanguage: import("./Store").StoreAction<unknown, (uiLanguage: LanguagePropertyValue) => void, (result: ResolvedUserIdentity, uiLanguage: LanguagePropertyValue) => void, (failureReason: any, uiLanguage: LanguagePropertyValue) => void, (uiLanguage: LanguagePropertyValue) => Promise<ResolvedUserIdentity>>;

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

@@ -1,4 +1,4 @@
-import { Future, GuidValue, IResolvedIdentity, Identity, IdentityQuery, ItemQueryResult, UserIdentityQuery } from "@omnia/fx-models";
+import { Future, guid, IResolvedIdentity, Identity, IdentityQuery, ItemQueryResult, UserIdentityQuery } from "@omnia/fx-models";
 import { IdentityService } from "../services";
 import { IIdentityPickerStore, IdentityStore } from "./IdentityStore";
 import { Store } from "./Store";
@@ -7,8 +7,8 @@ export declare class UserTypeIdentityStore extends Store {
     private identityStore;
     private userTypeIdentitiesState;
     getters: {
-        createIdentityPickerStore: (userType: GuidValue) => UserTypeIdentityPickerStore;
-        getIdentitiesOfUserType: (userType: GuidValue) => ItemQueryResult<IResolvedIdentity>;
+        createIdentityPickerStore: (userType: guid) => UserTypeIdentityPickerStore;
+        getIdentitiesOfUserType: (userType: guid) => ItemQueryResult<IResolvedIdentity>;
     };
     actions: {
         resolveIdentities: import("./Store").StoreAction<unknown, (identities: Identity[]) => void, (result: {
@@ -16,8 +16,8 @@ export declare class UserTypeIdentityStore extends Store {
         }, identities: Identity[]) => void, (failureReason: any, identities: Identity[]) => void, (identities: Identity[]) => Promise<{
             [uid: string]: IResolvedIdentity;
         }>>;
-        query: import("./Store").StoreAction<unknown, (query: IdentityQuery, userTypeId: GuidValue) => void, (result: ItemQueryResult<IResolvedIdentity>, query: IdentityQuery, userTypeId: GuidValue) => void, (failureReason: any, query: IdentityQuery, userTypeId: GuidValue) => void, (query: IdentityQuery, userTypeId: GuidValue) => Future<ItemQueryResult<IResolvedIdentity>>>;
-        ensureUserTypeIdentities: import("./Store").StoreAction<unknown, (query: UserIdentityQuery, userType: GuidValue) => void, (result: ItemQueryResult<IResolvedIdentity>, query: UserIdentityQuery, userType: GuidValue) => void, (failureReason: any, query: UserIdentityQuery, userType: GuidValue) => void, (query: UserIdentityQuery, userType: GuidValue) => Promise<ItemQueryResult<IResolvedIdentity>>>;
+        query: import("./Store").StoreAction<unknown, (query: IdentityQuery, userTypeId: guid) => void, (result: ItemQueryResult<IResolvedIdentity>, query: IdentityQuery, userTypeId: guid) => void, (failureReason: any, query: IdentityQuery, userTypeId: guid) => void, (query: IdentityQuery, userTypeId: guid) => Future<ItemQueryResult<IResolvedIdentity>>>;
+        ensureUserTypeIdentities: import("./Store").StoreAction<unknown, (query: UserIdentityQuery, userType: guid) => void, (result: ItemQueryResult<IResolvedIdentity>, query: UserIdentityQuery, userType: guid) => void, (failureReason: any, query: UserIdentityQuery, userType: guid) => void, (query: UserIdentityQuery, userType: guid) => Promise<ItemQueryResult<IResolvedIdentity>>>;
     };
     protected onActivated(): void;
 }
@@ -26,7 +26,7 @@ export declare class UserTypeIdentityPickerStore extends Store implements IIdent
     private identityStore;
     private identityService;
     private userType;
-    constructor(userTypeIdentityStore: UserTypeIdentityStore, identityStore: IdentityStore, identityService: IdentityService, userType: GuidValue);
+    constructor(userTypeIdentityStore: UserTypeIdentityStore, identityStore: IdentityStore, identityService: IdentityService, userType: guid);
     getters: {
         getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
     };

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

@@ -1,5 +1,5 @@
 import { SubscriptionHandler } from "../core";
-import { VersionedAlternateLayout, VersionedLayout, VersionedLayoutId, VersionedLayoutDefinition, DisplayBreakpointVersionedAlternateLayoutMapping, GuidValue, ICheckedoutVersionedData, IVersionedData, IVersionedDataIdentifier, IVersionReference, LatestReferenceResponse } from "../models";
+import { VersionedAlternateLayout, VersionedLayout, VersionedLayoutId, VersionedLayoutDefinition, DisplayBreakpointVersionedAlternateLayoutMapping, guid, ICheckedoutVersionedData, IVersionedData, IVersionedDataIdentifier, IVersionReference, LatestReferenceResponse } from "../models";
 import { Store } from "./Store";
 export declare class VersionedLayoutStore extends Store {
     private versionedLayoutService;
@@ -11,16 +11,16 @@ export declare class VersionedLayoutStore extends Store {
         getLayoutByIdentifer: (identifier: IVersionedDataIdentifier) => VersionedLayout;
         getLayoutDefinition: (version: IVersionReference) => IVersionedData<VersionedLayoutDefinition>;
         getLatestRef: (dataIdentifier: IVersionedDataIdentifier) => LatestReferenceResponse;
-        getAppScopedLayoutWithDefinition: <Definition extends VersionedLayoutDefinition>(appInstanceId: GuidValue, definition: new () => Definition) => VersionedLayout[];
+        getAppScopedLayoutWithDefinition: <Definition extends VersionedLayoutDefinition>(appInstanceId: guid, definition: new () => Definition) => VersionedLayout[];
         getTenantScopedLayoutWithDefinition: <Definition_1 extends VersionedLayoutDefinition>(definition: new () => Definition_1) => VersionedLayout[];
-        getBusinessProfileScopedLayoutWithDefinition: <Definition_2 extends VersionedLayoutDefinition>(businessProfileId: GuidValue, definition: new () => Definition_2) => VersionedLayout[];
+        getBusinessProfileScopedLayoutWithDefinition: <Definition_2 extends VersionedLayoutDefinition>(businessProfileId: guid, definition: new () => Definition_2) => VersionedLayout[];
     };
     mutations: {
         addOrUpdateLayouts: import("./Store").StoreMutation<(...versionedLayouts: VersionedLayout[]) => void, (...args: VersionedLayout[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
         addOrUpdateDefinitions: import("./Store").StoreMutation<(...definitions: IVersionedData<VersionedLayoutDefinition>[]) => void, (...args: IVersionedData<VersionedLayoutDefinition>[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
     actions: {
-        ensureLoadForApp: import("./Store").StoreAction<unknown, (appInstanceId: GuidValue) => void, (result: void, appInstanceId: GuidValue) => void, (failureReason: any, appInstanceId: GuidValue) => void, (appInstanceId: GuidValue) => Promise<void>>;
+        ensureLoadForApp: import("./Store").StoreAction<unknown, (appInstanceId: guid) => void, (result: void, appInstanceId: guid) => void, (failureReason: any, appInstanceId: guid) => void, (appInstanceId: guid) => Promise<void>>;
         ensureLoadForTenant: import("./Store").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
         ensureLoadLayoutDefinitionLatestRef: import("./Store").StoreAction<unknown, (dataIdentifier: IVersionedDataIdentifier, useCache?: unknown) => void, (result: void, dataIdentifier: IVersionedDataIdentifier, useCache?: unknown) => void, (failureReason: any, dataIdentifier: IVersionedDataIdentifier, useCache?: unknown) => void, (dataIdentifier: IVersionedDataIdentifier, useCache?: unknown) => Promise<void>>;
         ensureLoadByIdentifier: import("./Store").StoreAction<unknown, (identifier: IVersionedDataIdentifier, useCache?: unknown) => void, (result: void, identifier: IVersionedDataIdentifier, useCache?: unknown) => void, (failureReason: any, identifier: IVersionedDataIdentifier, useCache?: unknown) => void, (identifier: IVersionedDataIdentifier, useCache?: unknown) => Promise<void>>;
@@ -28,20 +28,20 @@ export declare class VersionedLayoutStore extends Store {
         ensureLoadDefinition: import("./Store").StoreAction<unknown, (version: IVersionReference) => void, (result: void, version: IVersionReference) => void, (failureReason: any, version: IVersionReference) => void, (version: IVersionReference) => Promise<void>>;
         ensureLoadDefinitionWithParentLayout: import("./Store").StoreAction<unknown, (version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (result: unknown, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (failureReason: any, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => Promise<unknown>>;
         ensureLoadDisplayBreakpointMapping: import("./Store").StoreAction<unknown, (versionedLayout: VersionedLayout, useCache?: unknown) => void, (result: DisplayBreakpointVersionedAlternateLayoutMapping, versionedLayout: VersionedLayout, useCache?: unknown) => void, (failureReason: any, versionedLayout: VersionedLayout, useCache?: unknown) => void, (versionedLayout: VersionedLayout, useCache?: unknown) => Promise<DisplayBreakpointVersionedAlternateLayoutMapping>>;
-        ensureLoadByProfileAndTypeId: import("./Store").StoreAction<unknown, (businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (result: void, businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (failureReason: any, businessProfileId: GuidValue, layoutTypeId: GuidValue) => void, (businessProfileId: GuidValue, layoutTypeId: GuidValue) => Promise<void>>;
-        ensureLoadByTypeIds: import("./Store").StoreAction<unknown, (layoutTypeIds: GuidValue[]) => void, (result: void, layoutTypeIds: GuidValue[]) => void, (failureReason: any, layoutTypeIds: GuidValue[]) => void, (layoutTypeIds: GuidValue[]) => Promise<void>>;
+        ensureLoadByProfileAndTypeId: import("./Store").StoreAction<unknown, (businessProfileId: guid, layoutTypeId: guid) => void, (result: void, businessProfileId: guid, layoutTypeId: guid) => void, (failureReason: any, businessProfileId: guid, layoutTypeId: guid) => void, (businessProfileId: guid, layoutTypeId: guid) => Promise<void>>;
+        ensureLoadByTypeIds: import("./Store").StoreAction<unknown, (layoutTypeIds: guid[]) => void, (result: void, layoutTypeIds: guid[]) => void, (failureReason: any, layoutTypeIds: guid[]) => void, (layoutTypeIds: guid[]) => Promise<void>>;
         setDisplayBreakpointMapping: import("./Store").StoreAction<unknown, (versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (result: void, versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (failureReason: any, versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => void, (versionedLayout: VersionedLayout, mapping: DisplayBreakpointVersionedAlternateLayoutMapping) => Promise<void>>;
-        createAppScoped: import("./Store").StoreAction<unknown, (appInstanceId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
+        createAppScoped: import("./Store").StoreAction<unknown, (appInstanceId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
-        }, appInstanceId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (failureReason: any, appInstanceId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (appInstanceId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<{
+        }, appInstanceId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (failureReason: any, appInstanceId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (appInstanceId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<{
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
         }>>;
-        createBusinessProfileScoped: import("./Store").StoreAction<unknown, (businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
+        createBusinessProfileScoped: import("./Store").StoreAction<unknown, (businessProfileId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
-        }, businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (failureReason: any, businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (businessProfileId: GuidValue, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<{
+        }, businessProfileId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (failureReason: any, businessProfileId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (businessProfileId: guid, definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => Promise<{
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
         }>>;

package/internal-do-not-import-from-here/stores/mediapicker/MediaPickerGalleryStore.d.ts

@@ -1,10 +1,10 @@
-import { GuidValue, IMediaPickerGalleryHandler, ImageMetaData, MediaGallery, MediaPickerImageTransformationResult, MediaPickerMediaItem, MediaPickerStorageProviderContext, MediaState } from "@omnia/fx-models";
+import { guid, IMediaPickerGalleryHandler, ImageMetaData, MediaGallery, MediaPickerImageTransformationResult, MediaPickerMediaItem, MediaPickerStorageProviderContext, MediaState } from "@omnia/fx-models";
 export declare function useMediaPickerStorageProviderContext(): MediaPickerStorageProviderContext;
 export declare const GalleryStore: () => {
     state: {
         selectedMediaGallery: MediaGallery;
         editingMediaIndex: number;
-        editingMediaId: GuidValue;
+        editingMediaId: guid;
         preSelectedImageMetaData: ImageMetaData;
         mediaStates: MediaState[];
         finishItemCount: number;
@@ -26,7 +26,7 @@ export declare const GalleryStore: () => {
                 subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             addOrUpdateItem: {
-                subscribe(fn: (mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: guid) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             updateImageTransformed: {
                 subscribe(fn: (transformation: MediaPickerImageTransformationResult) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -61,7 +61,7 @@ export declare const GalleryStore: () => {
                 subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             addOrUpdateItem: {
-                subscribe(fn: (result: void, mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (result: void, mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: guid) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             updateImageTransformed: {
                 subscribe(fn: (result: void, transformation: MediaPickerImageTransformationResult) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -96,7 +96,7 @@ export declare const GalleryStore: () => {
                 subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             addOrUpdateItem: {
-                subscribe(fn: (failureReason: any, mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+                subscribe(fn: (failureReason: any, mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: guid) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
             };
             updateImageTransformed: {
                 subscribe(fn: (failureReason: any, transformation: MediaPickerImageTransformationResult) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
@@ -131,7 +131,7 @@ export declare const GalleryStore: () => {
          * @param item the item to be added to the gallery, this can be a video or an image
          * @param id The id of the media state
          */
-        addOrUpdateItem(mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: GuidValue): void;
+        addOrUpdateItem(mediaState: MediaState, galleryHandler: IMediaPickerGalleryHandler, id: guid): void;
         /**
          * @description this is the method that gets called from the image transformer
          * @param transformation the transformation result from the image transformer
@@ -148,7 +148,7 @@ export declare const GalleryStore: () => {
     events: {
         onMutatedSelectedMediaGallery: import("../../core").MessageBusExposeOnlySubscription<MediaGallery>;
         onMutatedEditingMediaIndex: import("../../core").MessageBusExposeOnlySubscription<number>;
-        onMutatedEditingMediaId: import("../../core").MessageBusExposeOnlySubscription<GuidValue>;
+        onMutatedEditingMediaId: import("../../core").MessageBusExposeOnlySubscription<guid>;
         onMutatedPreSelectedImageMetaData: import("../../core").MessageBusExposeOnlySubscription<ImageMetaData>;
         onMutatedMediaStates: import("../../core").MessageBusExposeOnlySubscription<MediaState[]>;
         onMutatedFinishItemCount: import("../../core").MessageBusExposeOnlySubscription<number>;
@@ -164,7 +164,7 @@ export declare const GalleryStore: () => {
     mutate: {
         selectedMediaGallery: (value: MediaGallery | ((prev: MediaGallery) => MediaGallery)) => void;
         editingMediaIndex: (value: number | ((prev: number) => number)) => void;
-        editingMediaId: (value: GuidValue | ((prev: GuidValue) => GuidValue)) => void;
+        editingMediaId: (value: guid | ((prev: guid) => guid)) => void;
         preSelectedImageMetaData: (value: ImageMetaData | ((prev: ImageMetaData) => ImageMetaData)) => void;
         mediaStates: (value: MediaState[] | ((prev: MediaState[]) => MediaState[])) => void;
         finishItemCount: (value: number | ((prev: number) => number)) => void;

package/internal-do-not-import-from-here/stores/mediapicker/ProviderStore.d.ts

@@ -1,4 +1,4 @@
-import { GuidValue, IMediaPickerImageProviderHandler, IMediaPickerProviderHandler, ImageInformation, ImageItem, MediaItem, MediaPickerBase64Image, MediaPickerImageScaling, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerMessage, MediaPickerProvider, VideoInformation, VideoItem } from "@omnia/fx-models";
+import { guid, IMediaPickerImageProviderHandler, IMediaPickerProviderHandler, ImageInformation, ImageItem, MediaItem, MediaPickerBase64Image, MediaPickerImageScaling, MediaPickerLimitedSizeSettings, MediaPickerMedia, MediaPickerMessage, MediaPickerProvider, VideoInformation, VideoItem } from "@omnia/fx-models";
 export declare const ProviderStore: () => {
     state: {
         showImageTransformer: boolean;
@@ -222,16 +222,16 @@ export declare const ProviderStore: () => {
         statusMessage: (value: MediaPickerMessage | ((prev: MediaPickerMessage) => MediaPickerMessage)) => void;
     };
     get: {
-        providerById(id: GuidValue): MediaPickerProvider;
+        providerById(id: guid): MediaPickerProvider;
         activeProvider(): {
-            id: GuidValue;
+            id: guid;
             category: string;
             name: string;
             icon: import("@omnia/fx-models").IIcon;
             hasEditorForMedia(media: import("@omnia/fx-models").MediaPickerVideo | import("@omnia/fx-models").MediaPickerPersistedImage): boolean;
             sortOrder?: number;
             selectableMediaTypes: import("@omnia/fx-models").MediaPickerEnums.OmniaMediaTypes[];
-            providerComponentManifestId: GuidValue;
+            providerComponentManifestId: guid;
             supportGalleryFeature: boolean;
         };
     };

package/internal-do-not-import-from-here/stores/mediapicker/constants.d.ts

@@ -1,2 +1,2 @@
-import { GuidValue } from "../../models";
-export declare const KEEP_ORIGINAL_SIZE_OPTION_VALUE: GuidValue;
+import { guid } from "../../models";
+export declare const KEEP_ORIGINAL_SIZE_OPTION_VALUE: guid;

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

@@ -1,8 +1,8 @@
-import { DbQueryFilterEngineContext } from "@omnia/fx-models";
+import { DbQueryFilterEngineContext, guid } from "@omnia/fx-models";
 export declare class AppRollupFilterEngineContext extends DbQueryFilterEngineContext {
-    componentId: string;
-    uniqueId: string;
-    constructor(componentId: string);
+    componentId: guid;
+    uniqueId: guid;
+    constructor(componentId: guid);
     readonly supportFullTextSearch: boolean;
     getAvailableProperties(): import("@omnia/fx-models").EnterprisePropertyDefinition[];
 }

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

@@ -1,9 +1,9 @@
-import { BlockLayoutSettings, BlockRenderingModes, Breakpoint, GuidValue, IBlockInstance, ILayoutMediaContext, ILayoutFileContext, IMessageBusTopicSubscription, MultilingualString } from "../models";
+import { BlockLayoutSettings, BlockRenderingModes, Breakpoint, guid, IBlockInstance, ILayoutMediaContext, ILayoutFileContext, IMessageBusTopicSubscription, MultilingualString } from "../models";
 export declare class BlockInstance<TSettings = void> implements IBlockInstance<TSettings> {
     setSearchValue: (value: MultilingualString) => void;
-    id: string;
-    manifestId: GuidValue;
-    layoutDefinitionId: GuidValue;
+    id: guid;
+    manifestId: guid;
+    layoutDefinitionId: guid;
     mode: BlockRenderingModes;
     hide: boolean;
     clickProtection: {

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

@@ -69,7 +69,7 @@ type VuetifySlots<T> = {
 type VuetifyValue<T> = T extends {
     value?: any;
 } ? T["value"] : T;
-import { VTooltip, VTextarea, VSwitch, VRadioGroup, VLazy, VForm, VTextField, VBtn, VBtnToggle, VBtnGroup, VNavigationDrawer, VList, VListItem, VListGroup, VListImg, VListItemAction, VListItemTitle, VListItemSubtitle, VListItemMedia, VListSubheader, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VCard, VCardActions, VCardItem, VCardSubtitle, VCardText, VCardTitle, VExpansionPanels, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VAutocomplete, VMenu, VTable, VCheckbox, VCheckboxBtn, VVirtualScroll, VChip, VSelect, VBadge, VCol, VPagination, VRating, VRangeSlider, VSnackbar, VRadio, VSlideGroup, VSlideGroupItem } from "vuetify/components";
+import { VTooltip, VTextarea, VSwitch, VRadioGroup, VLazy, VForm, VTextField, VBtn, VBtnToggle, VBtnGroup, VNavigationDrawer, VList, VListItem, VListGroup, VListImg, VListItemAction, VListItemTitle, VListItemSubtitle, VListItemMedia, VListSubheader, VDialog, VDialogBottomTransition, VDialogTopTransition, VDialogTransition, VCard, VCardActions, VCardItem, VCardSubtitle, VCardText, VCardTitle, VExpansionPanels, VExpansionPanel, VExpansionPanelText, VExpansionPanelTitle, VAutocomplete, VMenu, VTable, VCheckbox, VCheckboxBtn, VVirtualScroll, VChip, VSelect, VBadge, VCol, VPagination, VRating, VRangeSlider, VSnackbar, VRadio, VSlideGroup, VSlideGroupItem, VStepper, VStepperHeader, VStepperWindow, VStepperActions, VStepperWindowItem, VStepperItem } from "vuetify/components";
 import { Intersect } from "vuetify/directives";
 import { VDataTable, VDataTableRow, VDataTableRows, VDataTableVirtual, VDataTableServer, VInfiniteScroll, VDatePicker, VFab, VSpeedDial } from "vuetify/components";
 import { VCalendar } from "vuetify/labs/VCalendar";
@@ -291,6 +291,24 @@ declare global {
             "v-slide-group-item": VuetifyProps<Pick<VSlideGroupItem, "$props">> & {
                 [name: string]: any;
             };
+            "v-stepper": VuetifyProps<Pick<VStepper, "$props">> & {
+                [name: string]: any;
+            };
+            "v-stepper-header": VuetifyProps<Pick<VStepperHeader, "$props">> & {
+                [name: string]: any;
+            };
+            "v-stepper-window": VuetifyProps<Pick<VStepperWindow, "$props">> & {
+                [name: string]: any;
+            };
+            "v-stepper-actions": VuetifyProps<Pick<VStepperActions, "$props">> & {
+                [name: string]: any;
+            };
+            "v-stepper-item": VuetifyProps<Pick<VStepperItem, "$props">> & {
+                [name: string]: any;
+            };
+            "v-stepper-window-item": VuetifyProps<Pick<VStepperWindowItem, "$props">> & {
+                [name: string]: any;
+            };
         }
     }
 }

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

@@ -1,7 +1,7 @@
 import { SubscriptionHandler } from "@omnia/fx";
 import { ComponentInjectOptions, ComponentObjectPropsOptions, ComponentOptions, ComponentOptionsBase, ComponentOptionsMixin, ComponentPropsOptions, ComponentPublicInstance, ComputedOptions, CreateComponentPublicInstance, DefineComponent, EmitsOptions, ExtractDefaultPropTypes, MethodOptions, ObjectEmitsOptions, Prop, PropType, RenderFunction, Slot, SlotsType, VNode, VNodeArrayChildren, VNodeProps, VNodeTypes, WatchStopHandle, watch, watchEffect } from "vue";
 import { LooseRequired, Prettify, UnionToIntersection } from "@vue/shared";
-import { ColorSchemaTypes, ComponentBundleManifest, Directives, GuidValue } from "@omnia/fx-models";
+import { ColorSchemaTypes, ComponentBundleManifest, Directives, guid } from "@omnia/fx-models";
 import { ColorSchemaStoreType, VueComponentBaseProps } from ".";
 import { IValidator } from "./models/Validation";
 import { useColorSchemaSetup } from "./use/UseColorSchemaSetup";
@@ -290,8 +290,8 @@ export declare function defineVue(): {
         };
     };
 };
-export declare function getElementName(componentManifestId: GuidValue): string;
-export declare function createVueNode(element: VNodeTypes | GuidValue, props?: RawProps, children?: RawChildren | RawSlots): VNode;
+export declare function getElementName(componentManifestId: guid): string;
+export declare function createVueNode(element: VNodeTypes | guid, props?: RawProps, children?: RawChildren | RawSlots): VNode;
 export declare function internalDVCByFS(injectOptions: any, options: any, extraOptions: any, register: any): (props: ConstructComponentProps<Record<string, any>>) => {
     $: import("vue").ComponentInternalInstance;
     $data: {};

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

@@ -1,7 +1,7 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { VueComponentBaseProps } from "./VueComponentBase";
 export type TsxAllowUnknowProperties<T extends {}> = T & Omit<VueComponentBaseProps, "placeholder" | "key" | "onChange" | "property"> & {
-    key?: string | number | GuidValue;
+    key?: string | number | guid;
     dark?: boolean;
     ref?: string;
     slot?: string;

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

@@ -1,7 +1,7 @@
 import { Events, HTMLAttributes, VNode, VNodeArrayChildren, VNodeProps, VNodeRef } from "vue";
 import { Vue } from "./decorators";
 import * as models from "../models";
-import { GuidValue } from "../models";
+import { guid } from "../models";
 import { ConfirmDialogOptions, ConfirmDialogResponse } from "./confirmdialog/IVueConfirmDialog";
 import { ITheming } from "./theming";
 type VuetifyThemeItem = string | number | {
@@ -115,10 +115,10 @@ export interface IVueComponentBase<Props = VueComponentBaseProps, EventsWithOn =
     $confirm: {
         open: (options?: ConfirmDialogOptions) => Promise<ConfirmDialogResponse>;
     };
-    createVueNode(element: string | models.GuidValue, props?: RawProps, children?: () => RawChildren): VNode;
+    createVueNode(element: string | models.guid, props?: RawProps, children?: () => RawChildren): VNode;
 }
 export type VueComponentBaseProps = Pick<HTMLAttributes, "id" | "class" | "style" | "onClick" | "tabindex"> & Pick<EventHandlers<Events>, "onKeydown" | "onKeyup" | "onKeypress"> & {
-    key?: string | number | symbol | GuidValue;
+    key?: string | number | symbol | guid;
     $children?: any;
     ref?: VNodeRef | string;
     slot?: string;
@@ -150,8 +150,8 @@ export declare class VueComponentBase<Props = VueComponentBaseProps | {}, Events
     };
     resetValidation(): void;
     validate(): Promise<boolean>;
-    createVueNode(element: string | models.GuidValue, props?: RawProps, children?: () => RawChildren): VNode;
-    getElementNameByManifestId(manifestId: models.GuidValue): string;
+    createVueNode(element: string | models.guid, props?: RawProps, children?: () => RawChildren): VNode;
+    getElementNameByManifestId(manifestId: models.guid): string;
 }
 export declare function getVuetifyAppClasses(): string;
 export interface VueComponentConnectProps {

package/internal-do-not-import-from-here/ux/actionhandler/ActionHandler.d.ts

@@ -1,5 +1,5 @@
 import { MessageBusTopicMediator } from "@omnia/fx";
-import { ActionHandler, ActionRegistration, ActionHandlerRegistrationId, ApiPath, GuidValue, IActionHandlerInstance, IActionHandlerInstanceProperties, IActionHandlerSettings, IExtendApiManifestWithConfiguration, IMessageBusTopicPublishSubscriber, MultilingualString } from "@omnia/fx-models";
+import { ActionHandler, ActionRegistration, ActionHandlerRegistrationId, ApiPath, guid, IActionHandlerInstance, IActionHandlerInstanceProperties, IActionHandlerSettings, IExtendApiManifestWithConfiguration, IMessageBusTopicPublishSubscriber, MultilingualString } from "@omnia/fx-models";
 import { MessageBusExposeOnlySubscription } from "../../core";
 export interface IActionHandlerTriggeredRendererComponent {
     actionHandler: ActionHandlerInstance;
@@ -37,7 +37,7 @@ export declare abstract class ActionHandlerBase<TSettings extends IActionHandler
     abstract onTriggered(renderingCallback: (elementName: string, themeTargetId?: string, domProps?: Object) => void): any;
     abstract onDisposing(): any;
     constructor();
-    id: GuidValue;
+    id: guid;
     typeId: ActionHandlerRegistrationId;
     toolTip: MultilingualString;
     settings: IActionHandlerSettings;
@@ -70,7 +70,7 @@ export declare class ActionHandlerInstance implements IActionHandlerInstance {
     private instance;
     private actionHandlerStore;
     constructor(instance: ActionHandlerBase, actionHandler: ActionHandler);
-    id: GuidValue;
+    id: guid;
     typeId: ActionHandlerRegistrationId;
     toolTip: MultilingualString;
     settings: IActionHandlerSettings;

package/internal-do-not-import-from-here/ux/admin/AdminRouter.d.ts

@@ -1,4 +1,4 @@
-import { AdminRoute, TokenBasedRouteStateData, GuidValue } from "../../models";
+import { AdminRoute, TokenBasedRouteStateData, guid } from "../../models";
 import { TokenBasedRouter } from "../TokenBasedRouter";
 declare class InternalAdminRouter extends TokenBasedRouter<AdminRoute, TokenBasedRouteStateData> {
     private static manifestIdReg;
@@ -20,7 +20,7 @@ declare class InternalAdminRouter extends TokenBasedRouter<AdminRoute, TokenBase
     * Override protected function logic
     */
     protected protectedClearRoute(): void;
-    navigateRoot(title: string, manifestId: GuidValue, urlSegment?: string): void;
+    navigateRoot(title: string, manifestId: guid, urlSegment?: string): void;
     navigatePath(title: string, path: string): void;
     clearRoute(): void;
     get parentRouterTitle(): string;

package/internal-do-not-import-from-here/ux/admin/BusinessProfileRouter.d.ts

@@ -1,4 +1,4 @@
-import { BusinessProfileRoute, TokenBasedRouteStateData, GuidValue } from "../../models";
+import { BusinessProfileRoute, TokenBasedRouteStateData, guid } from "../../models";
 import { TokenBasedRouter } from "../TokenBasedRouter";
 declare class InternalBusinessProfileRouter extends TokenBasedRouter<BusinessProfileRoute, TokenBasedRouteStateData> {
     private static profileIdReg;
@@ -19,7 +19,7 @@ declare class InternalBusinessProfileRouter extends TokenBasedRouter<BusinessPro
     * Override protected function logic
     */
     protected protectedClearRoute(): void;
-    navigateBusinessProfile(title: string, profileId: GuidValue): void;
+    navigateBusinessProfile(title: string, profileId: guid): void;
     clearRoute(): void;
 }
 export declare const BusinessProfileRouter: InternalBusinessProfileRouter;

package/internal-do-not-import-from-here/ux/admin/queryableproperties/IQueryablePropertiesJourney.d.ts

@@ -1,10 +1,10 @@
-import { EnterprisePropertyDefinition, GuidValue } from "../../../models";
+import { EnterprisePropertyDefinition, guid } from "../../../models";
 export interface IQueryablePropertiesJourneyState {
     selectedProperty: EnterprisePropertyDefinition;
 }
 export interface IQueryablePropertiesJourney {
     additionalTitle?: string;
     tableName?: string;
-    serviceId: GuidValue;
-    additionalBuiltInProperties?: Array<GuidValue>;
+    serviceId: guid;
+    additionalBuiltInProperties?: Array<guid>;
 }

package/internal-do-not-import-from-here/ux/admin/queryableproperties/QueryablePropertiesAddBlade.d.ts

@@ -1,8 +1,8 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
         additionalBuiltInProperties: {
-            type: import("vue").PropType<GuidValue[]>;
+            type: import("vue").PropType<guid[]>;
             required: false;
         };
         tableName: {
@@ -10,12 +10,12 @@ declare const _default: {
             required: true;
         };
         serviceId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
     }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
         additionalBuiltInProperties: {
-            type: import("vue").PropType<GuidValue[]>;
+            type: import("vue").PropType<guid[]>;
             required: false;
         };
         tableName: {
@@ -23,7 +23,7 @@ declare const _default: {
             required: true;
         };
         serviceId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
     }>>, {}, true, {}, {}, {
@@ -35,7 +35,7 @@ declare const _default: {
         Defaults: {};
     }, Readonly<import("vue").ExtractPropTypes<{
         additionalBuiltInProperties: {
-            type: import("vue").PropType<GuidValue[]>;
+            type: import("vue").PropType<guid[]>;
             required: false;
         };
         tableName: {
@@ -43,7 +43,7 @@ declare const _default: {
             required: true;
         };
         serviceId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
             required: true;
         };
     }>>, () => JSX.Element, {}, {}, {}, {}>;
@@ -52,7 +52,7 @@ declare const _default: {
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     additionalBuiltInProperties: {
-        type: import("vue").PropType<GuidValue[]>;
+        type: import("vue").PropType<guid[]>;
         required: false;
     };
     tableName: {
@@ -60,15 +60,15 @@ declare const _default: {
         required: true;
     };
     serviceId: {
-        type: import("vue").PropType<GuidValue>;
+        type: import("vue").PropType<guid>;
         required: true;
     };
 }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{
-        serviceId: GuidValue;
+        serviceId: guid;
         tableName: string;
     } & {
-        additionalBuiltInProperties?: GuidValue[];
+        additionalBuiltInProperties?: guid[];
     }>, never>;
 };
 export default _default;