@omnia/fx 8.0.31-vnext → 8.0.32-dev

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

@@ -3,5 +3,5 @@ import { ExtendApiConfigurationManifest } from "../core/Extend";
 export declare class ApiHelper {
     private static _resolvableApiConfigs;
     static getExtendApiConfiguration<T>(api: ((extend: IExtendApiManifest) => IExtendApiManifestWithConfiguration<T>)): Promise<ExtendApiConfigurationManifest<T>[]>;
-    static loadExtendApiManifest<T>(api: ((extend: IExtendApiManifest) => IExtendApiManifestWithConfiguration<T>), callback: (configs: ExtendApiConfigurationManifest<T>[]) => LoadableBundleManifest): Future<void>;
+    static loadExtendApiManifest<T>(api: ((extend: IExtendApiManifest) => IExtendApiManifestWithConfiguration<T>), callback: (configs: ExtendApiConfigurationManifest<T>[]) => LoadableBundleManifest[]): Future<void>;
 }

package/internal-do-not-import-from-here/console/components/Console.d.ts

@@ -2,7 +2,52 @@ declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
         $data: {};
-        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
         $attrs: {
             [x: string]: unknown;
         };
@@ -10,13 +55,13 @@ declare const _default: {
             [x: string]: unknown;
         };
         $slots: Readonly<{
-            [name: string]: import("vue").Slot;
+            [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>, {}>;
+        $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<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & {
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & {
             beforeCreate?: (() => void) | (() => void)[];
             created?: (() => void) | (() => void)[];
             beforeMount?: (() => void) | (() => void)[];
@@ -31,7 +76,7 @@ declare const _default: {
             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)[];
+            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;
@@ -40,7 +85,7 @@ declare const _default: {
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     propsDefinition: Omit<Readonly<{} & {}>, never>;
 };
 export default _default;

package/internal-do-not-import-from-here/console/components/SocketComponent.d.ts

@@ -0,0 +1,91 @@
+declare const _default: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            style?: unknown;
+            class?: unknown;
+            key?: string | number | symbol;
+            ref?: import("vue").VNodeRef;
+            ref_for?: boolean;
+            ref_key?: string;
+            onVnodeBeforeMount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeMounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUpdate?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUpdated?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeBeforeUnmount?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+            onVnodeUnmounted?: ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+                [key: string]: any;
+            }>) => void)[];
+        };
+        $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<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, 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;
+    } & Readonly<import("vue").ExtractPropTypes<{}>> & import("vue").ShallowUnwrapRef<() => JSX.Element> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    propsDefinition: Omit<Readonly<{} & {}>, never>;
+};
+export default _default;

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

@@ -0,0 +1,12 @@
+import { GuidValue, InstanceLifetimes } from "@omnia/fx-models";
+import { SubscriptionHandler } from "./messaging";
+export interface SetupFactoryContext {
+    onDeactivated(fn: () => void): any;
+    subscriptions: SubscriptionHandler;
+}
+export declare function defineFactory<InferReturnSetup>(setup: (ctx: SetupFactoryContext, ...args: any) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): () => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1>(setup: (ctx: SetupFactoryContext, param1: T1) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: string): (param1: T1, param2: T2) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2, T3>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2, param3: T3) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1, param2: T2, param3: T3) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2, T3, T4>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2, param3: T3, param4: T4) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1, param2: T2, param3: T3, param4: T4) => InferReturnSetup;
+export declare function defineFactory<InferReturnSetup, T1, T2, T3, T4, T5>(setup: (ctx: SetupFactoryContext, param1: T1, param2: T2, param3: T3, param4: T4, param5: T5) => InferReturnSetup, lifetime: InstanceLifetimes, typeIdentifier?: GuidValue): (param1: T1, param2: T2, param3: T3, param4: T4, param5: T5) => InferReturnSetup;

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

@@ -7,7 +7,7 @@ export declare const Extend: IExtend;
 export declare function registerApi<T>(targetApi: ((extend: IExtend) => Promise<T>) | string, callback: (resolve: (value: T) => void) => void): void;
 export declare module InternalExtend {
     function getApiPathString(exp: (extend: IExtend | IExtendApiManifest) => ApiPath | IExtendApiManifestWithConfiguration<any>): string;
-    function getExtendApiConfiguration<T>(targetApi: ((extend: IExtendApiManifest) => IExtendApiManifestWithConfiguration<T>)): Promise<ExtendApiConfigurationManifest<T>[]>;
+    function getExtendApiConfiguration<T>(targetApi: (extend: IExtendApiManifest) => IExtendApiManifestWithConfiguration<T>): Promise<ExtendApiConfigurationManifest<T>[]>;
     function extendApi<T>(targetApi: ((extend: IExtend) => Promise<T>) | string, omniaServiceId: GuidValue, omniaManifestId: GuidValue, callback?: (api: T) => void | Promise<void>): void;
     function initApiHub(): Future<void>;
 }

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

@@ -1,3 +1,4 @@
+import { GuidValue } from "@omnia/fx-models";
 /**
  * Injects an instance of the specifed type. That instance maybe come from higer level relation provide it.
  *
@@ -25,4 +26,5 @@ type Class<T> = {
  * useInject<HttpClientConstructor>(HttpClient,{someConstructorArg1:"",someConstructorArg2})
  */
 export declare function useInject<TClass, TConstructor>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor): TClass;
+export declare function injectByTypeId(typeId: GuidValue): any;
 export {};

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

@@ -1,19 +1,36 @@
-type Class = {
-    new (...args: any[]): any;
+import { GuidValue } from "../models";
+type Class<T> = {
+    new (...args: any[]): T;
 };
 interface MockInstance {
     type: any;
     instance: any;
 }
+export declare class InternalServiceContainer {
+    private id;
+    private static creatingFromType;
+    private static singletonInstances;
+    private transientInstances;
+    private destroyedContainer;
+    private scopedInstances;
+    constructor(id: GuidValue);
+    createInstance<TConstructor, TClass>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor, forceNewInstanceLifetimeScope?: boolean): TClass;
+    static isCreatingInstanceFromType(type: any): boolean;
+    private getActiveInstance;
+    /** Only used it for Scope lifetime -  Use to create a proxy to monitor instance, will auto recreate a instance if disposed */
+    private createInstanceProxy;
+    dispose(destroyContainer?: boolean): void;
+    private disposeInstance;
+}
 export declare class ServiceContainer {
     private static mockInstances;
     private static registeredOnDisposing;
     static addMock<T>(type: T, instance: any): void;
-    static getMock<T extends Class = any>(type: T | Function): MockInstance;
+    static getMock<TClass>(type: Class<TClass> | (() => TClass)): MockInstance;
     /**
     *  @param forceNewInstanceLifetimeScope that used in Provide/Inject pattern in ui layer.
     */
-    static createInstance<T, T2 extends Class = any>(classType: T2, constructorArgs?: T, forceNewInstanceLifetimeScope?: boolean): InstanceType<T2>;
+    static createInstance<TConstructor, TClass = any>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor, forceNewInstanceLifetimeScope?: boolean): TClass;
     static disposeScopedAndTransient(): void;
     static onDisposing(func: (instance: any) => void): void;
     static getRegisteredOnDisposing(): ((activatedInstance: any) => void)[];
@@ -21,7 +38,7 @@ export declare class ServiceContainer {
 export declare class ServiceContainerContext {
     private container;
     constructor();
-    createInstance<T, T2 extends Class = any>(classType: T2 | Function, constructorArgs?: T, forceNewInstanceLifetimeScope?: boolean): InstanceType<T2>;
+    createInstance<TConstructor, TClass = any>(type: Class<TClass> | (() => TClass), constructorArgs?: TConstructor, forceNewInstanceLifetimeScope?: boolean): TClass;
     dispose(): void;
 }
 export {};

package/internal-do-not-import-from-here/core/console/ConsoleKeyboardShortcuts.d.ts

@@ -1,6 +1 @@
-export declare class ConsoleKeyboardShortcuts {
-    static init(): void;
-    private static initOmniaConsole;
-    private static initCommandPalette;
-    private static initDocs;
-}
+export {};

package/internal-do-not-import-from-here/core/http/HttpClient.d.ts

@@ -129,6 +129,7 @@ export declare class HttpClient {
      *  }
      */
     static createContextAwareRequestConfig: (baseUrl: string, acceptHeader?: string) => Promise<AxiosRequestConfig>;
+    private static getDomainRegex;
     private static createMSServiceContextAwareRequestConfig;
     private static get omniaBootstrapData();
     private static get omniaApp();

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

@@ -2,9 +2,10 @@ export { Extend, registerApi } from "./Extend";
 export * from "./Provide";
 export * from "./Inject";
 export * from "./Injectable";
+export * from "./DefineFactory";
 export * from "./Cookies";
 export * from "./LocalStorage";
-export * from "./ServiceContainer";
+export { ServiceContainer, ServiceContainerContext } from "./ServiceContainer";
 export * from "./Encoder";
 export * from "./Require";
 export { PublicManifestResourceLoader as ManifestResourceLoader } from "../runtime/core/ManifestResourceLoader";

package/internal-do-not-import-from-here/core/messaging/InternalTopics.d.ts

@@ -28,6 +28,9 @@ export declare class InternalTopics {
         instance: any;
         object: any;
     }>;
+    static get requestedLoadManifestByElement(): IMessageBusTopicPublishSubscriber<{
+        elementName: string;
+    }>;
     static get vueOnDestroyed(): IMessageBusTopicPublishSubscriber<{
         instance: ComponentInternalInstance;
     }>;

package/internal-do-not-import-from-here/core/services/ClientManifestHelper.d.ts

@@ -0,0 +1,5 @@
+import { OmniaManifests, OmniaServiceManifests } from "@omnia/fx-models";
+export declare class ClientManifestHelper {
+    static populateOmniaServiceManifestsProperties(omniaServiceManifests: OmniaServiceManifests): void;
+    static populateOmniaManifestsProperties(omniaManifest: OmniaManifests): void;
+}

package/internal-do-not-import-from-here/core/services/LocalizationService.d.ts

@@ -0,0 +1,15 @@
+import { LocalizationTargetTypes } from "@omnia/fx-models";
+export declare function mergeLocaliation(srcObj: object, desObj: object): void;
+export interface ILocalizationServiceProvider {
+    getState(): {
+        [key: string]: {};
+    };
+    loadLocalization(target: LocalizationTargetTypes): Promise<Object>;
+    merge(target: object): any;
+}
+export declare class LocalizationServiceProviders {
+    private static _provider;
+    static getProvider(): ILocalizationServiceProvider;
+    static setProvider(provider: ILocalizationServiceProvider): void;
+    static init(): Promise<void>;
+}

package/internal-do-not-import-from-here/core/services/ServiceManifestProvider.d.ts

@@ -1,9 +1,9 @@
-import { GuidValue, OmniaManifests } from "../../models";
+import { GuidValue, OmniaManifests, ClientManifestTargetTypes, Future, IMessageBusTopicSubscription } from "../../models";
 export interface IServiceManifestProvider {
     /**
      * Should return the manifests promise for the service or return null to use default manifest for service.
      * */
-    getOmniaServiceManifests: (omniaServiceId: GuidValue) => Promise<OmniaManifests>;
+    getOmniaServiceManifests(omniaServiceId: GuidValue, target?: ClientManifestTargetTypes): Promise<OmniaManifests>;
     /**
      * Get all service id's
      * Add or remove or leave allCurrentServiceIds unchanged
@@ -12,13 +12,19 @@ export interface IServiceManifestProvider {
     getAvailibleOmniaServiceIds: () => Array<GuidValue>;
 }
 export declare class ServiceManifestProvider {
+    private static _message;
+    private static _omniaHttpClient;
+    private static _loadOmniaServiceManifestsPromises;
+    private static _loadClientManifestPromises;
     private static externalServiceManifestProvider;
+    static onOmniaManifestsLoadedNew(): IMessageBusTopicSubscription<OmniaManifests[]>;
+    static ensureLoadClientManifests(target: ClientManifestTargetTypes): Future<OmniaManifests[]>;
     /**
      * Overrides default service manifest provider
      * Register null to revert to default manifest provider
      * */
     static overrideManifestProvider: (provider: IServiceManifestProvider) => void;
     static getAllAvailableOmniaServiceIds: () => Array<GuidValue>;
-    static getOmniaServiceManifests: (omniaServiceId: GuidValue) => Promise<OmniaManifests>;
+    static getOmniaServiceManifests(omniaServiceId: GuidValue, target?: ClientManifestTargetTypes): Promise<OmniaManifests>;
     static getOmniaServiceConfiguration: <T>(omniaServiceId: GuidValue) => T;
 }

package/internal-do-not-import-from-here/core/services/ServiceManifestProviderInternal.d.ts

@@ -1,10 +1,11 @@
-import { OmniaManifests, WebComponentBundleManifest } from "../../models";
+import { OmniaManifests, ComponentBundleManifest } from "../../models";
 export declare class ServiceManifestProviderInternal {
-    private static _allOmniaManifests;
-    private static _wcManifests;
+    private static omniaManifests;
+    private static wcManifests;
     static init(): Promise<void>;
     static getAllOmniaManifests(): OmniaManifests[];
     static getAllWebComponentsManifests(): {
-        [manifestId: string]: WebComponentBundleManifest;
+        [manifestId: string]: ComponentBundleManifest;
     };
+    private static mergeManifests;
 }

package/internal-do-not-import-from-here/core/services/index.d.ts

@@ -12,3 +12,4 @@ export * from "./UserPropertyBagFactory";
 export * from "./IAppRouteFactory";
 export * from "./TokenService";
 export * from "./AuthenticationSessionService";
+export * from "./LocalizationService";

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

@@ -1,4 +1,4 @@
-import { TimePeriodSettings, TenantRegionalSettings, GuidValue, IIcon } from "../../models";
+import { TimePeriodSettings, TenantRegionalSettings, IIcon } from "../../models";
 export declare module Utils {
     function isNativeClass(value: any): boolean;
     function asyncForEach<T>(array: Array<T>, callback: (item: T, index?: number, items?: Array<T>) => Promise<void>): Promise<void>;
@@ -22,22 +22,22 @@ export declare module Utils {
      *
      * @param obj Object to test whether or not it is an array.
      */
-    function isArray(obj: any): boolean;
+    function isArray(obj: any): obj is Array<any>;
     /**
      * Check if is type of a function
      * @param obj Object to test whether or not it is an function.
      */
-    function isFunction(obj: any): boolean;
+    function isFunction(obj: any): obj is Function;
     /**
      * Check if is type of a Object
-     * @param obj Object to test whether or not it is an function.
+     * @param obj Object to test whether or not it is a real object.
      */
-    function isObject(obj: any): boolean;
+    function isObject(val: any): val is object;
     /**
      * Check if is type of a boolean
-     * @param obj Object to test whether or not it is an function.
+     * @param obj Object to test whether or not it is a boolean.
      */
-    function isBoolean(obj: any): boolean;
+    function isBoolean(obj: any): obj is Boolean;
     /**
      * Generate a new guid
      */
@@ -129,9 +129,9 @@ export declare module Utils {
     function isEqual(value: any, other: any): any;
     function safeStringify(value: any): string;
     function getFileType(fileName: string): string;
+    function isImageFormatSupportForMediaPicker(fileName: string): boolean;
     function formatDateTime(regionalSettings: TenantRegionalSettings, date?: Date | string): string;
     function removeClaimPrefixFromLoginName(loginName: string): string;
-    function getManifestIdByElementName(elementName: string): GuidValue;
     /**
      * Get profile url for online and other environment like sharepoint server
      * online : https://delve.office.com/?u=${id}

package/internal-do-not-import-from-here/core/utils/index.d.ts

@@ -4,4 +4,3 @@ export * from "./ScrollPagingUtils";
 export * from "./EnterprisePropertyHandler";
 export * from "./MigrationUtils";
 export * from "./UserAgentUtils";
-export * from "./gpt3utils";

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

@@ -4,5 +4,6 @@ export * from "./core";
 export * from "./vue";
 export * from "./rules";
 export * from "./apis";
-export * from "./apis";
 export { ImageProxyService } from "./services";
+export * from "./Localize";
+export { UserTypeStore } from "./stores";

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

@@ -1,7 +1,7 @@
 export * from "./expose";
 import * as Exposes from "./expose";
 import * as Models from "internal/fx/models";
-import { IExtend, ThemeDefinitionV2, WebComponentBundleManifest } from "./models";
+import { IExtend, ThemeDefinitionV2, ComponentBundleManifest } from "./models";
 interface IExtendApi {
     extendApi: <T>(targetApi: (extend: IExtend) => Promise<T>, callback?: (api: T) => void | Promise<void>) => void;
 }
@@ -16,15 +16,15 @@ declare global {
 export interface IWebComponentInstance {
 }
 export interface IWebComponentRegistrationHandler {
-    (webComponentManifest: WebComponentBundleManifest): void;
+    (webComponentManifest: ComponentBundleManifest): void;
 }
 export interface IConnectedWebComponent {
     setRegistrationHandler: (registrationHandler: IWebComponentRegistrationHandler) => void;
     addElementInstanceHandler: (instanceHandler: IWebComponentInstance, htmlElement: HTMLElement) => IWebComponentInstanceContext;
-    getManifest: () => WebComponentBundleManifest;
+    getManifest: () => ComponentBundleManifest;
 }
 export interface IWebComponentInstanceContext {
-    getManifest: () => WebComponentBundleManifest;
+    getManifest: () => ComponentBundleManifest;
 }
 export declare class WebComponentBootstrapper {
     static registerElement: (registrationHandler: IWebComponentRegistrationHandler) => void;
@@ -38,24 +38,32 @@ export declare function setCurrentManifest(omniaServiceId: any, resourceId: any)
         registerElementInstance: (instanceHandler: any, htmlElement: any) => any;
     };
     ImageProxyService: typeof Exposes.ImageProxyService;
+    UserTypeStore: typeof Exposes.UserTypeStore;
     ReplaceToken: typeof Exposes.ReplaceToken;
     OmniaContextProvider: typeof Exposes.OmniaContextProvider;
     OmniaContext: typeof Exposes.OmniaContext;
     ContextProviderCollection: typeof Exposes.ContextProviderCollection;
     Extend: Models.IExtend;
     registerApi: typeof Exposes.registerApi;
+    ServiceContainer: typeof Exposes.ServiceContainer;
+    ServiceContainerContext: typeof Exposes.ServiceContainerContext;
     ManifestResourceLoader: typeof Exposes.ManifestResourceLoader;
     Provide<T>(classType: any, constructorArgs?: T): any;
     useProvide<TProvide, TConstructor>(provide: TProvide, constructorArgs?: TConstructor): TProvide extends new (...args: any) => infer P ? P : TProvide extends (...args: any) => infer P2 ? P2 : TProvide extends Object ? TProvide : never;
     Inject<T_1>(classType: any, constructorArgs?: T_1): any;
     useInject<TClass, TConstructor_1>(type: (new (...args: any[]) => TClass) | (() => TClass), constructorArgs?: TConstructor_1): TClass;
+    injectByTypeId(typeId: Models.GuidValue): any;
     isInjectable(type: any): boolean;
     Injectable<T_2>(options: Models.ActivationOptions): any;
     defineInjectable<TFunc extends Function>(targetFunc: TFunc, options: Models.ActivationOptions): TFunc;
+    defineFactory<InferReturnSetup>(setup: (ctx: Exposes.SetupFactoryContext, ...args: any) => InferReturnSetup, lifetime: Models.InstanceLifetimes, typeIdentifier?: Models.GuidValue): () => InferReturnSetup;
+    defineFactory<InferReturnSetup_1, T1>(setup: (ctx: Exposes.SetupFactoryContext, param1: T1) => InferReturnSetup_1, lifetime: Models.InstanceLifetimes, typeIdentifier?: Models.GuidValue): (param1: T1) => InferReturnSetup_1;
+    defineFactory<InferReturnSetup_2, T1_1, T2>(setup: (ctx: Exposes.SetupFactoryContext, param1: T1_1, param2: T2) => InferReturnSetup_2, lifetime: Models.InstanceLifetimes, typeIdentifier?: string): (param1: T1_1, param2: T2) => InferReturnSetup_2;
+    defineFactory<InferReturnSetup_3, T1_2, T2_1, T3>(setup: (ctx: Exposes.SetupFactoryContext, param1: T1_2, param2: T2_1, param3: T3) => InferReturnSetup_3, lifetime: Models.InstanceLifetimes, typeIdentifier?: Models.GuidValue): (param1: T1_2, param2: T2_1, param3: T3) => InferReturnSetup_3;
+    defineFactory<InferReturnSetup_4, T1_3, T2_2, T3_1, T4>(setup: (ctx: Exposes.SetupFactoryContext, param1: T1_3, param2: T2_2, param3: T3_1, param4: T4) => InferReturnSetup_4, lifetime: Models.InstanceLifetimes, typeIdentifier?: Models.GuidValue): (param1: T1_3, param2: T2_2, param3: T3_1, param4: T4) => InferReturnSetup_4;
+    defineFactory<InferReturnSetup_5, T1_4, T2_3, T3_2, T4_1, T5>(setup: (ctx: Exposes.SetupFactoryContext, param1: T1_4, param2: T2_3, param3: T3_2, param4: T4_1, param5: T5) => InferReturnSetup_5, lifetime: Models.InstanceLifetimes, typeIdentifier?: Models.GuidValue): (param1: T1_4, param2: T2_3, param3: T3_2, param4: T4_1, param5: T5) => InferReturnSetup_5;
     Cookies: typeof Exposes.Cookies;
     LocalStorage: typeof Exposes.LocalStorage;
-    ServiceContainer: typeof Exposes.ServiceContainer;
-    ServiceContainerContext: typeof Exposes.ServiceContainerContext;
     Encoder: typeof Exposes.Encoder;
     Require: typeof Exposes.Require;
     propertyPath: <StartType, TargetType = any>() => <Path extends string>(propertyPathToCheck: Exposes.PropPathCheckTargetType<StartType, Path, TargetType>) => string;
@@ -75,7 +83,6 @@ export declare function setCurrentManifest(omniaServiceId: any, resourceId: any)
     EnterprisePropertyHandler: typeof Exposes.EnterprisePropertyHandler;
     MigrationUtils: typeof Exposes.MigrationUtils;
     UserAgentUtils: typeof Exposes.UserAgentUtils;
-    GPT3Utils: typeof Exposes.GPT3Utils;
     Console: typeof Exposes.Console;
     ConsoleUIService: typeof Exposes.ConsoleUIService;
     ServiceLocator: typeof Exposes.ServiceLocator;
@@ -93,10 +100,10 @@ export declare function setCurrentManifest(omniaServiceId: any, resourceId: any)
     IAppRouteFactory: typeof Exposes.IAppRouteFactory;
     TokenService: typeof Exposes.TokenService;
     AuthenticationSessionService: typeof Exposes.AuthenticationSessionService;
+    mergeLocaliation(srcObj: object, desObj: object): void;
+    LocalizationServiceProviders: typeof Exposes.LocalizationServiceProviders;
     GraphClient: typeof Exposes.GraphClient;
     createEventHook<T_4 = any>(): Exposes.EventHook<T_4>;
-    Localize(namespace?: string): any;
-    useLocalize<T_5>(namespace: string): T_5;
     registerVuePlugin(plugin: (((app: import("vue").App<any>, ...options: any[]) => any) & {
         install?: (app: import("vue").App<any>, ...options: any[]) => any;
     }) | {
@@ -114,13 +121,17 @@ export declare function setCurrentManifest(omniaServiceId: any, resourceId: any)
     getVueMixins(): import("vue").ComponentOptions[];
     registerVueOptionsHook(fn: () => void): void;
     getVueOptionsHooks(): ((classComponentConstructor?: any) => void)[];
-    registerAsyncVueComponent(app: import("vue").App<any>, component: Models.WebComponentBundleManifest): void;
+    getVueApps(): Set<import("vue").App<Element>>;
+    destroyVueApp(app: import("vue").App<Element>): void;
+    createVueApp(rootComponent: any, rootProps?: any): import("vue").App<Element>;
+    registerAsyncVueComponent(app: import("vue").App<any>, component: Models.ComponentBundleManifest): void;
     resolveAsyncVueComponent(elementName: string, definition: import("vue").DefineComponent): void;
-    createVueApp: import("vue").CreateAppFunction<Element>;
     vueCustomElement(tag: string, componentDefinition: Object | Exposes.ComponentDefinitionFunc, options?: Exposes.VueCustomElementOptions): HTMLElement;
     DisplayRules: typeof Exposes.DisplayRules;
     ApiHelper: typeof Exposes.ApiHelper;
     omniaScriptApi: Exposes.IOmniaScriptApi;
+    Localize(namespace?: string): any;
+    useLocalize<T_5>(namespace: string): T_5;
 };
 declare global {
     namespace JSX {