@omnia/fx 8.0.191-dev → 8.0.193-dev

package/internal-do-not-import-from-here/ux/oxide/stepper/docs/SampleComponent2.d.ts

@@ -0,0 +1,47 @@
+declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<Record<string, any>>) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}> & {
+        beforeCreate?: (() => void) | (() => void)[];
+        created?: (() => void) | (() => void)[];
+        beforeMount?: (() => void) | (() => void)[];
+        mounted?: (() => void) | (() => void)[];
+        beforeUpdate?: (() => void) | (() => void)[];
+        updated?: (() => void) | (() => void)[];
+        activated?: (() => void) | (() => void)[];
+        deactivated?: (() => void) | (() => void)[];
+        beforeDestroy?: (() => void) | (() => void)[];
+        beforeUnmount?: (() => void) | (() => void)[];
+        destroyed?: (() => void) | (() => void)[];
+        unmounted?: (() => void) | (() => void)[];
+        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+    };
+    $forceUpdate: () => void;
+    $nextTick: typeof import("vue").nextTick;
+    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: import("@omnia/fx/ux").ExtractProps<Record<string, any>> & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, string | number>;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export default _default;

package/internal-do-not-import-from-here/ux/oxide/stepper/docs/SampleComponent3.d.ts

@@ -0,0 +1,47 @@
+declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<Record<string, any>>) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
+    };
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}> & {
+        beforeCreate?: (() => void) | (() => void)[];
+        created?: (() => void) | (() => void)[];
+        beforeMount?: (() => void) | (() => void)[];
+        mounted?: (() => void) | (() => void)[];
+        beforeUpdate?: (() => void) | (() => void)[];
+        updated?: (() => void) | (() => void)[];
+        activated?: (() => void) | (() => void)[];
+        deactivated?: (() => void) | (() => void)[];
+        beforeDestroy?: (() => void) | (() => void)[];
+        beforeUnmount?: (() => void) | (() => void)[];
+        destroyed?: (() => void) | (() => void)[];
+        unmounted?: (() => void) | (() => void)[];
+        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
+    };
+    $forceUpdate: () => void;
+    $nextTick: typeof import("vue").nextTick;
+    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: import("@omnia/fx/ux").ExtractProps<Record<string, any>> & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, string | number>;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export default _default;

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

@@ -1,4 +1,4 @@
-import { GuidValue, PermissionBinding, PermissionInputSettings, RolePermissionSetting } from "@omnia/fx-models";
+import { guid, PermissionBinding, PermissionInputSettings, RolePermissionSetting } from "@omnia/fx-models";
 export interface IPermissionInputAttributes {
     disabled?: boolean;
     hideSaveButton?: boolean;
@@ -11,7 +11,7 @@ export interface IPermissionInputAttributes {
     };
     onValueUpdated?: (rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>;
     onValueUpdating?: () => Promise<void>;
-    serviceId?: GuidValue;
+    serviceId?: guid;
 }
 export interface IPermissionInputApi {
     save(): Promise<boolean>;

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

@@ -1,168 +1,88 @@
-import { IPermissionInputApi } from "@omnia/fx/ux";
-import { GuidValue, PermissionBinding, PermissionInputSettings, RolePermissionSetting } from "@omnia/fx-models";
-declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
-        dataSource: {
-            type: import("vue").PropType<{
-                [roleId: string]: PermissionBinding[];
-            }>;
-        };
-        serviceId: {
-            type: import("vue").PropType<GuidValue>;
-        };
-        disabled: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        hideSaveButton: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        onValueUpdating: {
-            type: import("vue").PropType<() => Promise<void>>;
-        };
-        onValueUpdated: {
-            type: import("vue").PropType<(rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>>;
-        };
-        contextParams: {
-            type: import("vue").PropType<{
-                [key: string]: string | number;
-            }>;
-        };
-        settings: {
-            type: import("vue").PropType<PermissionInputSettings>;
-        };
-        getApi: {
-            type: import("vue").PropType<(api: IPermissionInputApi) => void>;
-        };
-    }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-        dataSource: {
-            type: import("vue").PropType<{
-                [roleId: string]: PermissionBinding[];
-            }>;
-        };
-        serviceId: {
-            type: import("vue").PropType<GuidValue>;
-        };
-        disabled: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        hideSaveButton: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        onValueUpdating: {
-            type: import("vue").PropType<() => Promise<void>>;
-        };
-        onValueUpdated: {
-            type: import("vue").PropType<(rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>>;
-        };
-        contextParams: {
-            type: import("vue").PropType<{
-                [key: string]: string | number;
-            }>;
-        };
-        settings: {
-            type: import("vue").PropType<PermissionInputSettings>;
-        };
-        getApi: {
-            type: import("vue").PropType<(api: IPermissionInputApi) => void>;
-        };
-    }>>, {}, true, {}, {}, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{
-        dataSource: {
-            type: import("vue").PropType<{
-                [roleId: string]: PermissionBinding[];
-            }>;
-        };
-        serviceId: {
-            type: import("vue").PropType<GuidValue>;
-        };
-        disabled: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        hideSaveButton: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        onValueUpdating: {
-            type: import("vue").PropType<() => Promise<void>>;
-        };
-        onValueUpdated: {
-            type: import("vue").PropType<(rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>>;
-        };
-        contextParams: {
-            type: import("vue").PropType<{
-                [key: string]: string | number;
-            }>;
-        };
-        settings: {
-            type: import("vue").PropType<PermissionInputSettings>;
-        };
-        getApi: {
-            type: import("vue").PropType<(api: IPermissionInputApi) => void>;
-        };
-    }>>, () => JSX.Element, {}, {}, {}, {}>;
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    dataSource: {
-        type: import("vue").PropType<{
-            [roleId: string]: PermissionBinding[];
-        }>;
+import { DefineEmit, IPermissionInputApi } from "@omnia/fx/ux";
+import { PermissionBinding, PermissionInputSettings, RolePermissionSetting, guid } from "@omnia/fx-models";
+declare const _default: (props: import("@omnia/fx/ux").ConstructComponentProps<{
+    getApi?: (api: IPermissionInputApi) => void;
+} & {
+    settings?: PermissionInputSettings;
+} & {
+    contextParams?: {
+        [key: string]: string | number;
     };
-    serviceId: {
-        type: import("vue").PropType<GuidValue>;
+} & DefineEmit<"valueUpdated", (rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>> & DefineEmit<"valueUpdating", () => Promise<void>> & {
+    hideSaveButton?: boolean;
+} & {
+    disabled?: boolean;
+} & {
+    serviceId?: guid;
+} & {
+    dataSource?: {
+        [roleId: string]: PermissionBinding[];
     };
-    disabled: {
-        type: import("vue").PropType<boolean>;
-        required: false;
+}>) => {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {};
+    $attrs: {
+        [x: string]: unknown;
     };
-    hideSaveButton: {
-        type: import("vue").PropType<boolean>;
-        required: false;
+    $refs: {
+        [x: string]: unknown;
     };
-    onValueUpdating: {
-        type: import("vue").PropType<() => Promise<void>>;
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any>;
+    }>;
+    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>;
+    $emit: (event: string, ...args: any[]) => void;
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}> & {
+        beforeCreate?: (() => void) | (() => void)[];
+        created?: (() => void) | (() => void)[];
+        beforeMount?: (() => void) | (() => void)[];
+        mounted?: (() => void) | (() => void)[];
+        beforeUpdate?: (() => void) | (() => void)[];
+        updated?: (() => void) | (() => void)[];
+        activated?: (() => void) | (() => void)[];
+        deactivated?: (() => void) | (() => void)[];
+        beforeDestroy?: (() => void) | (() => void)[];
+        beforeUnmount?: (() => void) | (() => void)[];
+        destroyed?: (() => void) | (() => void)[];
+        unmounted?: (() => void) | (() => void)[];
+        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}>, info: string) => boolean | void)[];
     };
-    onValueUpdated: {
-        type: import("vue").PropType<(rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>>;
-    };
-    contextParams: {
-        type: import("vue").PropType<{
-            [key: string]: string | number;
-        }>;
-    };
-    settings: {
-        type: import("vue").PropType<PermissionInputSettings>;
-    };
-    getApi: {
-        type: import("vue").PropType<(api: IPermissionInputApi) => void>;
-    };
-}>>, () => 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;
-        disabled?: boolean;
-        settings?: PermissionInputSettings;
+    $forceUpdate: () => void;
+    $nextTick: typeof import("vue").nextTick;
+    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+} & Omit<{}, never> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {} & {
+    propsDefinition: import("@omnia/fx/ux").ExtractProps<{
         getApi?: (api: IPermissionInputApi) => void;
+    } & {
+        settings?: PermissionInputSettings;
+    } & {
         contextParams?: {
             [key: string]: string | number;
         };
-        onValueUpdated?: (rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>;
-        onValueUpdating?: () => Promise<void>;
+    } & DefineEmit<"valueUpdated", (rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>> & DefineEmit<"valueUpdating", () => Promise<void>> & {
         hideSaveButton?: boolean;
+    } & {
+        disabled?: boolean;
+    } & {
+        serviceId?: guid;
+    } & {
         dataSource?: {
             [roleId: string]: PermissionBinding[];
         };
-    }>, never>;
-};
+    }> & {
+        "v-slots"?: {
+            default?: import("vue").Slot;
+        } & {};
+    } & {
+        onValueUpdated?: (rolePermissionSetting: RolePermissionSetting[]) => any;
+        onValueUpdating?: () => any;
+    } & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "serviceId" | "disabled" | "settings" | "getApi" | "contextParams" | "hideSaveButton" | "dataSource">;
+} & import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
 export default _default;

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

@@ -1,5 +1,5 @@
 import { IPermissionInputApi } from "@omnia/fx/ux";
-import { GuidValue, PermissionBinding, RolePermissionSetting } from "@omnia/fx/models";
+import { guid, PermissionBinding, RolePermissionSetting } from "@omnia/fx/models";
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstance<Readonly<import("vue").ExtractPropTypes<{
         onValueUpdating: {
@@ -14,7 +14,7 @@ declare const _default: {
             }>;
         };
         serviceId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
         };
         disabled: {
             type: import("vue").PropType<boolean>;
@@ -45,7 +45,7 @@ declare const _default: {
             }>;
         };
         serviceId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
         };
         disabled: {
             type: import("vue").PropType<boolean>;
@@ -83,7 +83,7 @@ declare const _default: {
             }>;
         };
         serviceId: {
-            type: import("vue").PropType<GuidValue>;
+            type: import("vue").PropType<guid>;
         };
         disabled: {
             type: import("vue").PropType<boolean>;
@@ -118,7 +118,7 @@ declare const _default: {
         }>;
     };
     serviceId: {
-        type: import("vue").PropType<GuidValue>;
+        type: import("vue").PropType<guid>;
     };
     disabled: {
         type: import("vue").PropType<boolean>;
@@ -138,18 +138,18 @@ declare const _default: {
     };
 }>>, () => 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;
         disabled?: boolean;
         getApi?: (api: IPermissionInputApi) => void;
         contextParams?: {
             [key: string]: string | number;
         };
-        onValueUpdated?: (rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>;
-        onValueUpdating?: () => Promise<void>;
         hideSaveButton?: boolean;
         dataSource?: {
             [roleId: string]: PermissionBinding[];
         };
+        onValueUpdated?: (rolePermissionSetting: Array<RolePermissionSetting>) => Promise<void>;
+        onValueUpdating?: () => Promise<void>;
     }>, never>;
 };
 export default _default;

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

@@ -1,4 +1,4 @@
-import { Identity } from "@omnia/fx-models";
+import { Identity, guid } from "@omnia/fx-models";
 import { IPermissionInputAttributes, IValidator } from "@omnia/fx/ux";
 export declare function usePermissionInput(props: IPermissionInputAttributes, validator: IValidator): {
     state: import("vue").ShallowReactive<{
@@ -6,7 +6,7 @@ export declare function usePermissionInput(props: IPermissionInputAttributes, va
         errMsg: string;
         isSaving: boolean;
         result: {
-            [roleId: string]: Identity[];
+            [roleId: guid]: Identity[];
         };
         previousPromiseRejecter: () => void;
     }>;

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

@@ -1,5 +1,5 @@
 import { PostStyle } from "..";
-import { GuidValue, OmitProperties, ThemeDefinition, IPostBaseWithContext, IPostBaseContext, IPersistedPost, ResolvedUserIdentity, ReactionType } from "../../models";
+import { guid, OmitProperties, ThemeDefinition, IPostBaseWithContext, IPostBaseContext, IPersistedPost, ResolvedUserIdentity, ReactionType } from "../../models";
 import { IRichTextEditor } from "../richtexteditor";
 export interface IPostCustomSlots {
     /**
@@ -33,8 +33,8 @@ export interface PostProvider<TPostContext extends IPostBaseContext = IPostBaseC
     handler: PostHandler<TPostTypeWithContext, TPostContext>;
 }
 export interface IPostComponent {
-    omniaServiceId: GuidValue;
-    postTypeId: GuidValue;
+    omniaServiceId: guid;
+    postTypeId: guid;
     provider: PostProvider;
     richTextSettings?: OmitProperties<IRichTextEditor, "initialContent" | "onContentChange">;
     cardStyle?: ThemeDefinition;

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

@@ -1,4 +1,4 @@
-import { GuidValue, IPostBaseContext, IPostBaseWithContext, OmitProperties, ResolvedUserIdentity, ThemeDefinition } from "../../models";
+import { guid, IPostBaseContext, IPostBaseWithContext, OmitProperties, ResolvedUserIdentity, ThemeDefinition } from "../../models";
 import { IRichTextEditor } from "../richtexteditor";
 import { IPostCustomSlots, PostPermission, PostProvider } from "./IPost";
 import "./Post.css";
@@ -9,9 +9,9 @@ declare const _default: <TItem extends readonly any[], TModel extends unknown>(p
 } & {
     editContentOnTop?: boolean;
 } & {
-    omniaServiceId?: GuidValue;
+    omniaServiceId?: guid;
 } & {
-    postTypeId?: GuidValue;
+    postTypeId?: guid;
 } & {
     showMoreSize?: number;
 } & {
@@ -93,9 +93,9 @@ declare const _default: <TItem extends readonly any[], TModel extends unknown>(p
     } & {
         editContentOnTop?: boolean;
     } & {
-        omniaServiceId?: GuidValue;
+        omniaServiceId?: guid;
     } & {
-        postTypeId?: GuidValue;
+        postTypeId?: guid;
     } & {
         showMoreSize?: number;
     } & {

package/internal-do-not-import-from-here/ux/properties/models/DataSource.d.ts

@@ -1,4 +1,4 @@
-import { PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
+import { guid, PropertyDefinition } from "@omnia/fx-models";
 import { PropertyDataSourceBase, DataSourcePropertyDefinitionHandler } from "@omnia/fx/services";
 import { DataSourceProperty } from "internal/fx/models/properties/datasource/DataSourceProperty";
 import { PropertyDefinitionId } from "./Properties";
@@ -17,8 +17,8 @@ export interface IPropertyDataSourceRegistrationApi extends IRegisteredPropertyD
  * */
 export interface IRegisteredPropertyDataSourceApi {
     getDataSources(): Promise<(new () => PropertyDataSourceBase<DataSourceProperty>)[]>;
-    getDataSource(dataSourceId: PropertyDataSourceId): Promise<new () => PropertyDataSourceBase<DataSourceProperty>>;
-    getDataSourceDefinitionHandlers(dataSourceId: PropertyDataSourceId): Promise<Array<{
+    getDataSource(dataSourceId: guid): Promise<new () => PropertyDataSourceBase<DataSourceProperty>>;
+    getDataSourceDefinitionHandlers(dataSourceId: guid): Promise<Array<{
         propertyDefintionId: PropertyDefinitionId;
         handlerCtor: new () => DataSourcePropertyDefinitionHandler<PropertyDefinition<any, any, any>, DataSourceProperty, any, any>;
     }>>;
@@ -26,11 +26,11 @@ export interface IRegisteredPropertyDataSourceApi {
 export interface IPropertyDataSourceProvider {
 }
 export declare class PropertyDataSourceProviderRegistration {
-    typeId: PropertyDataSourceId;
+    typeId: guid;
     provider: new () => IPropertyDataSourceProvider;
-    constructor(typeId: PropertyDataSourceId, provider: new () => IPropertyDataSourceProvider);
+    constructor(typeId: guid, provider: new () => IPropertyDataSourceProvider);
 }
 export interface IPropertyDataSourceProviderApi {
     register(registration: PropertyDataSourceProviderRegistration): void;
-    getProvider(typeId: PropertyDataSourceId): Promise<new () => IPropertyDataSourceProvider>;
+    getProvider(typeId: guid): Promise<new () => IPropertyDataSourceProvider>;
 }

package/internal-do-not-import-from-here/ux/properties/models/Properties.d.ts

@@ -1,6 +1,6 @@
-import { GuidValue } from "@omnia/fx-models";
-export type PropertyDefinitionId = GuidValue;
-export type PropertyTypeId = GuidValue;
+import { guid } from "@omnia/fx-models";
+export type PropertyDefinitionId = guid;
+export type PropertyTypeId = guid;
 export type PropertyData = string | number | boolean | Object;
 export interface PropertySettings {
 }

package/internal-do-not-import-from-here/ux/properties/models/PropertyApi.d.ts

@@ -1,11 +1,10 @@
-import { EnterprisePropertyDefinition, IExtendApiManifestWithConfiguration, PropertyBindingProviderId, PropertyDataSourceId, PropertyDefinition, PropertyValuePrimitiveConverter } from "@omnia/fx-models";
-import { GuidValue } from "@omnia/fx-models/internal-do-not-import-from-here/shared/models";
+import { EnterprisePropertyDefinition, IExtendApiManifestWithConfiguration, PropertyBindingProviderId, guid, PropertyDefinition, PropertyValuePrimitiveConverter } from "@omnia/fx-models";
 import { VueComponentBase } from "../../VueComponentBase";
 import { PropertyDefinitionId, PropertySettings } from "./Properties";
 import { IPropertyDataSourceRegistrationApi } from "./DataSource";
 import { DataSourcePropertyDefintionHandlerId } from "@omnia/fx/services";
 import { IPropertyBindingProviderRegistrationApi } from "./PropertyBindingProvider";
-export type PropertyRegistrationId = GuidValue;
+export type PropertyRegistrationId = guid;
 export interface PropertyRegistration {
     id: PropertyRegistrationId;
     title: string;
@@ -22,18 +21,18 @@ export interface IPropertyRegistrationApi {
     register(registration: PropertyRegistration): void;
 }
 export interface IPropertyDefinitionRegistrationApi {
-    register<TPropertyDef extends PropertyDefinition<any, any, any>>(propertyDefinitionConstructor: new () => TPropertyDef, readRenderComponentManifestId: GuidValue, editRendererComponentManifestId: GuidValue, propertyValuePrimitiveConverterCtor: new () => PropertyValuePrimitiveConverter, configurationRendererComponentManifestId?: GuidValue): any;
+    register<TPropertyDef extends PropertyDefinition<any, any, any>>(propertyDefinitionConstructor: new () => TPropertyDef, readRenderComponentManifestId: guid, editRendererComponentManifestId: guid, propertyValuePrimitiveConverterCtor: new () => PropertyValuePrimitiveConverter, configurationRendererComponentManifestId?: guid): any;
     getPropertyDefinitionsByIds(propertyDefinitionIds: Array<PropertyDefinitionId>): Promise<Array<ResolvedPropertyDefinition>>;
     getPropertyDefinitions(): Promise<Array<ResolvedPropertyDefinition>>;
 }
 export interface ResolvedPropertyDefinition {
-    omniaServiceId: GuidValue;
-    propertyDefinitionId: GuidValue;
+    omniaServiceId: guid;
+    propertyDefinitionId: guid;
     propertyDefinition: new () => PropertyDefinition<any, any, any>;
-    readRenderComponentManifestId: GuidValue;
-    editRendererComponentManifestId: GuidValue;
+    readRenderComponentManifestId: guid;
+    editRendererComponentManifestId: guid;
     propertyValuePrimitiveConverterCtor: new () => PropertyValuePrimitiveConverter;
-    configurationRendererComponentManifestId?: GuidValue;
+    configurationRendererComponentManifestId?: guid;
 }
 declare module "@omnia/fx-models" {
     interface IOmniaUxApi {
@@ -54,12 +53,12 @@ declare module "@omnia/fx-models" {
                 /**
                  * Register the manifest/bundle that contains the propertydatasource
                  * */
-                registrations: IExtendApiManifestWithConfiguration<PropertyDataSourceId>;
+                registrations: IExtendApiManifestWithConfiguration<guid>;
                 /**
                  * Register any external plugin/dataSourcePropertyDefinitionHandler for a property data source
                  * */
                 pluginRegistration: IExtendApiManifestWithConfiguration<{
-                    dataSourceId: PropertyDataSourceId;
+                    dataSourceId: guid;
                     dataSourcePropertyDefinitionHandlerId: DataSourcePropertyDefintionHandlerId;
                 }>;
             };

package/internal-do-not-import-from-here/ux/properties/models/PropertyBindingProvider.d.ts

@@ -1,8 +1,8 @@
-import { IPropertyBindingProvider, Guid } from "@omnia/fx-models";
+import { IPropertyBindingProvider, guid } from "@omnia/fx-models";
 export interface IPropertyBindingProviderRegistrationApi extends IRegisteredPropertyBindingProviderApi {
     registerProvider<TPropertyBindingProvider extends IPropertyBindingProvider>(registration: new () => TPropertyBindingProvider): void;
 }
 export interface IRegisteredPropertyBindingProviderApi {
     getProviders(): Promise<(new () => IPropertyBindingProvider)[]>;
-    getProvider(providerId: Guid): Promise<(new () => IPropertyBindingProvider)>;
+    getProvider(providerId: guid): Promise<(new () => IPropertyBindingProvider)>;
 }

package/internal-do-not-import-from-here/ux/properties/models/PropertyPicker.d.ts

@@ -1,4 +1,4 @@
-import { DataSourceProperty, GuidValue, PropertyConfiguration, PropertyDataSourceId, PropertyDefinition } from "@omnia/fx-models";
+import { DataSourceProperty, guid, PropertyConfiguration, PropertyDefinition } from "@omnia/fx-models";
 import { DataSourcePropertyDefintionHandlerId } from "../../../services";
 export interface IDataSourcePropertySelection {
     dataSourceProperty: DataSourceProperty;
@@ -6,7 +6,7 @@ export interface IDataSourcePropertySelection {
     propertyConfiguration?: PropertyConfiguration<PropertyDefinition<any, any, any>>;
 }
 export interface IPropertyPicker {
-    selectableDataSources: Array<PropertyDataSourceId>;
+    selectableDataSources: Array<guid>;
     onDataSourcePropertySelected: (selection: IDataSourcePropertySelection, allowEdit: boolean) => Promise<void>;
     filled?: boolean;
     disabled?: boolean;
@@ -15,6 +15,6 @@ export interface IPropertyPicker {
     multiple?: boolean;
     hideConfiguration?: boolean;
     selectionProperty?: IDataSourcePropertySelection;
-    selectablePropertyConverters?: Array<GuidValue>;
+    selectablePropertyConverters?: Array<guid>;
     hideLabelIfSingleSource?: boolean;
 }