@omnia/fx 8.0.31-vnext → 8.0.32-dev

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

@@ -1 +1,3 @@
+export * from "./DefineService";
+export * from "./ActivityService";
 export * from "./RealtimeService";

package/internal-do-not-import-from-here/spfx/components/OmniaWPContainer.d.ts

@@ -12,7 +12,7 @@ export declare class OmniaWPContainerComponent extends VueComponentBase {
     webpartid: string;
     displaymode: any;
     private loc;
-    private localizationService;
+    private localizationStore;
     protected settingsService: SettingsService<any>;
     private spfxSettingsService;
     private omniaTheming;

package/internal-do-not-import-from-here/spfx/components/OmniaWPContainerSettings.d.ts

@@ -10,7 +10,7 @@ export declare class OmniaWPContainerSettings extends VueComponentBase implement
     private omniaTheming;
     private omniaCtx;
     blockCatalogStore: BlockCatalogStore;
-    private localizationService;
+    private localizationStore;
     private loc;
     private blocksRegistration;
     private webpartSelectorClasses;

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

@@ -0,0 +1,36 @@
+import { AiSettings } from "../models";
+import { GuidValue } from "../shared";
+import { Store } from "./Store";
+export declare class AiSettingsStore extends Store {
+    private settings;
+    private readonly tenantKey;
+    private currentSetting;
+    private aiSettingService;
+    constructor();
+    onActivated(): void;
+    onDisposing(): void;
+    private generateSettingKey;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        getSettingsByType: (type: string, businessProfileId?: GuidValue) => AiSettings[];
+        currentEditing: () => AiSettings;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        settingsByType: import("./Store").StoreMutation<(newState: Array<AiSettings>, type: string, businessProfileId?: GuidValue) => void, (newState: AiSettings[], type: string, businessProfileId?: GuidValue) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        currentEditing: import("./Store").StoreMutation<(newState: AiSettings) => void, (newState: AiSettings) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+    /**
+     * Implementation of actions
+     */
+    actions: {
+        loadSettingsByType: import("./Store").StoreAction<unknown, (type: string, businessProfileId?: GuidValue) => void, (result: AiSettings[], type: string, businessProfileId?: GuidValue) => void, (failureReason: any, type: string, businessProfileId?: GuidValue) => void, (type: string, businessProfileId?: GuidValue) => Promise<AiSettings[]>>;
+        updateSetting: import("./Store").StoreAction<unknown, (model: AiSettings) => void, (result: AiSettings, model: AiSettings) => void, (failureReason: any, model: AiSettings) => void, (model: AiSettings) => Promise<AiSettings>>;
+        addSetting: import("./Store").StoreAction<unknown, (model: AiSettings) => void, (result: AiSettings, model: AiSettings) => void, (failureReason: any, model: AiSettings) => void, (model: AiSettings) => Promise<AiSettings>>;
+        removeSetting: import("./Store").StoreAction<unknown, (id: number) => void, (result: void, id: number) => void, (failureReason: any, id: number) => void, (id: number) => Promise<void>>;
+    };
+}

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

@@ -12,7 +12,7 @@ export declare class AppNamingPolicyStore extends Store {
     actions: {
         ensureLoad: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue) => void, (result: void, appDefinitionId: GuidValue) => void, (failureReason: any, appDefinitionId: GuidValue) => void, (appDefinitionId: GuidValue) => Promise<void>>;
         ensureLoadById: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue) => void, (result: void, appDefinitionId: GuidValue) => void, (failureReason: any, appDefinitionId: GuidValue) => void, (appDefinitionId: GuidValue) => Promise<void>>;
-        add: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (result: void, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (failureReason: any, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => Promise<void>>;
+        add: import("./Store").StoreAction<unknown, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (result: AppNamingPolicy, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (failureReason: any, appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => void, (appDefinitionId: GuidValue, definition: AppNamingPolicyDefinition) => Promise<AppNamingPolicy>>;
         update: import("./Store").StoreAction<unknown, (policy: AppNamingPolicy) => void, (result: void, policy: AppNamingPolicy) => void, (failureReason: any, policy: AppNamingPolicy) => void, (policy: AppNamingPolicy) => Promise<void>>;
         delete: import("./Store").StoreAction<unknown, (policy: AppNamingPolicy) => void, (result: void, policy: AppNamingPolicy) => void, (failureReason: any, policy: AppNamingPolicy) => void, (policy: AppNamingPolicy) => Promise<void>>;
     };

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

@@ -1,11 +1,14 @@
+import { OmniaContext } from "../contexts";
 import { GuidValue, AzureAdDefaultUserProperties, AdProperty } from "../models";
 import { Store } from "./Store";
 export declare class AzureAdUserStore extends Store {
     private azureAdService;
+    omniaCtx: OmniaContext;
     private resolvePropertiesValuePromises;
     private resolvePropertiesInfoPromise;
     private resolveSyncPropertiesInfoPromise;
     private defaultSelectUserProperties;
+    private isOmniaUser;
     actions: {
         getUserPropertiesValue: import("./Store").StoreAction<unknown, (id: GuidValue, selectMoreProperties?: string[]) => void, (result: AzureAdDefaultUserProperties, id: GuidValue, selectMoreProperties?: string[]) => void, (failureReason: any, id: GuidValue, selectMoreProperties?: string[]) => void, <T extends AzureAdDefaultUserProperties = AzureAdDefaultUserProperties>(id: GuidValue, selectMoreProperties?: string[]) => Promise<T>>;
         getUserPropertiesMetadata: import("./Store").StoreAction<unknown, () => void, (result: string[]) => void, (failureReason: any) => void, () => Promise<string[]>>;

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

@@ -1,40 +1,40 @@
-import { EventHook } from "../core";
+import { MessageBusExposeOnlySubscription, SetupFactoryContext } from "../core";
+import { IMessageBusSubscriptionHandler, IMessageBusTopicPublishSubscriber } from "@omnia/fx-models";
 type MutateFn<T> = (value: T | ((prev: T) => T)) => void;
-type StoreGettersContext<TState extends object, TInternalState extends object, TGetterSetupCtx extends object> = StoreStateContext<TState, TInternalState> & {
-    setup: TGetterSetupCtx;
-};
-type StoreStateContext<TState extends object, TInternalState extends object> = {
-    state: TState;
-    internalState: TInternalState;
-};
-type StoreActionContext<TState extends object, TInternalState extends object, TGetters, TEvents extends Record<string, EventHook<any>>, TSetup extends object> = StoreStateContext<TState, TInternalState> & {
-    get: TGetters;
-    mutate: {
-        [K in keyof TState]: MutateFn<TState[K]>;
-    };
-    events: TEvents;
-    setup: TSetup;
-};
-type StoreActivatedContext<TState extends object, TInternalState extends object, TGetters, TActions, TEvents extends Record<string, EventHook<any>>, TSetup extends object> = StoreActionContext<TState, TInternalState, TGetters, TEvents, TSetup> & {
-    actions: TActions;
-    setup: TSetup;
-};
-type Events<TState extends object, TEvents extends Record<string, EventHook<any>>> = {
-    [K in keyof TState as `onMutating${Capitalize<string & K>}` | `onMutated${Capitalize<string & K>}`]: EventHook<TState[K]>;
+type Events<TState extends object, TEvents extends Record<string, IMessageBusTopicPublishSubscriber<any>>> = {
+    [K in keyof TState as `onMutated${Capitalize<string & K>}`]: MessageBusExposeOnlySubscription<TState[K]>;
 } & TEvents;
-export declare const defineStore: <TState extends object = {}, TInternalState extends object = {}, TSetup extends object = {}, TGetters extends object = {}, TActions extends object = {}, TEvents extends Record<string, EventHook<any>> = {}>(name: string, definition: {
-    state: () => TState;
-    internalState?: () => TInternalState;
-    setup?: (ctx: StoreStateContext<TState, TInternalState>) => TSetup;
-    getters?: (ctx: StoreGettersContext<TState, TInternalState, TSetup>) => TGetters;
-    actions?: <TActionGetters extends TGetters = TGetters, TActionSetup extends TSetup = TSetup>(ctx: StoreActionContext<TState, TInternalState, TActionGetters, Events<TState, TEvents>, TActionSetup>) => TActions;
-    activated?: <TSetupGetters extends TGetters = TGetters, TSetupActions extends TActions = TActions, TActivatedSetup extends TSetup = TSetup>(ctx: StoreActivatedContext<TState, TInternalState, TSetupGetters, TSetupActions, Events<TState, TEvents>, TActivatedSetup>) => void;
+type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => any ? (...args: U) => void : never;
+type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> | infer Y ? (result: Y, ...args: U) => void : never;
+type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => any ? (failureReason: any, ...args: U) => void : never;
+type ReturnDefineAction<TAction extends {
+    [key: string]: Function;
+}> = {
+    onDispatching<T extends (...args: any) => any>(action: (actions: TAction) => T, fn: MapActionOnDispatching<T>): IMessageBusSubscriptionHandler;
+    onDispatched<T extends (...args: any) => any>(action: (actions: TAction) => T, fn: MapActionOnDispatched<T>): IMessageBusSubscriptionHandler;
+    onFailure<T extends (...args: any) => any>(action: (actions: TAction) => T, fn: MapActionOnFailure<T>): IMessageBusSubscriptionHandler;
+} & TAction;
+interface SetupStoreContext extends SetupFactoryContext {
+    defineState<TState extends object, TEvents extends Record<string, IMessageBusTopicPublishSubscriber<any>> = Record<string, IMessageBusTopicPublishSubscriber<any>>>(state: TState): {
+        state: TState;
+        events: Events<TState, TEvents>;
+        mutate: {
+            [K in keyof TState]: MutateFn<TState[K]>;
+        };
+    };
+    defineAction<TActions extends {
+        [key: string]: Function;
+    }>(actions: TActions): ReturnDefineAction<TActions>;
+}
+export interface IReturnSetupStore<TState, TGetters, TActions extends {
+    [key: string]: Function;
+}, TEvents> {
+    state?: TState;
+    get?: TGetters;
+    actions?: ReturnDefineAction<TActions>;
     events?: TEvents;
-}) => (newInstanceWithName?: string) => {
-    state: TState;
-    get: TGetters;
-    actions: TActions;
-    events: Events<TState, TEvents>;
-    activated: void;
-};
+}
+export declare function defineStore<TState extends object, TGetters extends object, TActions extends {
+    [key: string]: Function;
+}, TEvents extends Record<string, MessageBusExposeOnlySubscription<any>>, InferReturnSetup extends IReturnSetupStore<TState, TGetters, TActions, TEvents>>(name: string, setup: (ctx: SetupStoreContext) => InferReturnSetup): () => InferReturnSetup;
 export {};

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

@@ -3,21 +3,24 @@ import { Store } from "./Store";
 import { EnterprisePropertyService } from "../services/EnterprisePropertyService";
 export declare class EnterprisePropertyStore extends Store {
     enterprisePropertyService: EnterprisePropertyService;
-    private localizationService;
+    private localizationStore;
     private multilingualTextsStore;
     private queryablePropertiesService;
     private omniaContext;
     private ensuredLoadDataPromise;
     private ensuredQueryablePropertiesLoadedPromise;
     private editingProperty;
+    private ensureLoadExtendedEnterprisePropertiesPromise;
     enterprisePropertyDefinitions: import("./Store").StoreState<EnterprisePropertyDefinition[]>;
     enterprisePropertyDataTypes: import("./Store").StoreState<EnterprisePropertyDataType[]>;
     computedPropertyMapping: import("./Store").StoreState<{
         [serviceIdWithTableKey: string]: EnterprisePropertyColumnMapping[];
     }>;
+    enterprisePropertyDefinitionsDeleted: import("./Store").StoreState<EnterprisePropertyDefinition[]>;
     getters: {
         enterprisePropertyDefinitionsByIndexedTypes: (indexTypes: Array<PropertyIndexedType>) => EnterprisePropertyDefinition[];
         enterprisePropertyDefinitions: () => EnterprisePropertyDefinition[];
+        extenedEnterprisePropertyDefinitionsDeleted: () => EnterprisePropertyDefinition[];
         enterprisePropertyDefinitionsGroupByCategory: () => {
             [categoryId: string]: EnterprisePropertyDefinition[];
         };
@@ -43,6 +46,7 @@ export declare class EnterprisePropertyStore extends Store {
     actions: {
         refresh: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
         ensureLoadData: import("./Store").StoreAction<unknown, (forceReload?: boolean) => void, (result: boolean, forceReload?: boolean) => void, (failureReason: any, forceReload?: boolean) => void, (forceReload?: boolean) => Promise<boolean>>;
+        ensureLoadExtendedEnterpriseProperties: import("./Store").StoreAction<unknown, () => void, (result: boolean) => void, (failureReason: any) => void, () => Promise<boolean>>;
         addEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterpriseProperty: EnterprisePropertyDefinition) => void, (result: EnterprisePropertyDefinition, enterpriseProperty: EnterprisePropertyDefinition) => void, (failureReason: any, enterpriseProperty: EnterprisePropertyDefinition) => void, (enterpriseProperty: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>>;
         updateEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterpriseProperty: EnterprisePropertyDefinition) => void, (result: EnterprisePropertyDefinition, enterpriseProperty: EnterprisePropertyDefinition) => void, (failureReason: any, enterpriseProperty: EnterprisePropertyDefinition) => void, (enterpriseProperty: EnterprisePropertyDefinition) => Promise<EnterprisePropertyDefinition>>;
         removeEnterprisePropertyDefinition: import("./Store").StoreAction<unknown, (enterprisePropertyId: GuidValue) => void, (result: boolean, enterprisePropertyId: GuidValue) => void, (failureReason: any, enterprisePropertyId: GuidValue) => void, (enterprisePropertyId: GuidValue) => Promise<boolean>>;

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

@@ -5,7 +5,7 @@ import { OmniaContext } from "../contexts";
 export declare class FeatureStore extends Store {
     omniaContext: OmniaContext;
     featureService: FeatureService;
-    private localizationService;
+    private localizationStore;
     private activatedFeatureIds;
     featureDefinitions: import("./Store").StoreState<Feature[]>;
     featureInstances: import("./Store").StoreState<FeatureInstance[]>;

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

@@ -6,8 +6,10 @@ export declare class GroupIdentityStore extends Store {
     private loadDynamicGroupsPromise;
     private loadGroupTypesPromise;
     private dynamicGroupsState;
+    private groupTypes;
     getters: {
         getDynamicGroups: () => ResolvedDynamicGroupIdentity[];
+        groupTypes: () => GroupType[];
     };
     actions: {
         ensureLoadDynamicGroups: import("./Store").StoreAction<unknown, () => void, (result: ResolvedDynamicGroupIdentity[]) => void, (failureReason: any) => void, () => Promise<ResolvedDynamicGroupIdentity[]>>;

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

@@ -1,9 +1,25 @@
-import { Future, Identity, IdentityQuery, IResolvedIdentity } from "../models";
-import { Store } from "./Store";
-export declare class IdentityStore extends Store {
+import { Future, IResolvedIdentity, Identity, IdentityQuery, ItemQueryResult } from "../models";
+import { Store, StoreAction, MapActionOnDispatching, MapActionOnDispatched, MapActionOnFailure } from "./Store";
+type QueryActionDispatcher = (query: IdentityQuery) => Future<ItemQueryResult<IResolvedIdentity>>;
+type ResolveIdentitiesActionDispatcher = (identities: Identity[]) => Promise<{
+    [uid: string]: IResolvedIdentity;
+}>;
+type SpecialIdentitiesActionDispatcher = () => Future<Array<IResolvedIdentity>>;
+export interface IIdentityPickerStore {
+    getters: {
+        getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
+    };
+    actions: {
+        query: StoreAction<unknown, MapActionOnDispatching<QueryActionDispatcher>, MapActionOnDispatched<QueryActionDispatcher>, MapActionOnFailure<QueryActionDispatcher>, QueryActionDispatcher>;
+        resolveIdentities: StoreAction<unknown, MapActionOnDispatching<ResolveIdentitiesActionDispatcher>, MapActionOnDispatched<ResolveIdentitiesActionDispatcher>, MapActionOnFailure<ResolveIdentitiesActionDispatcher>, ResolveIdentitiesActionDispatcher>;
+        ensureSpecialIdentities: StoreAction<unknown, MapActionOnDispatching<SpecialIdentitiesActionDispatcher>, MapActionOnDispatched<SpecialIdentitiesActionDispatcher>, MapActionOnFailure<SpecialIdentitiesActionDispatcher>, SpecialIdentitiesActionDispatcher>;
+    };
+}
+export declare class IdentityStore extends Store implements IIdentityPickerStore {
     private identityService;
     private identitiesState;
     private dynamicGroupsState;
+    private loadSpecialIdentitiesPromise;
     getters: {
         getResolvedIdentity: (identity: Identity) => IResolvedIdentity;
         getResolvedIdentities: () => IResolvedIdentity[];
@@ -12,12 +28,14 @@ export declare class IdentityStore extends Store {
         addOrUpdateResolvedIdentities: (resolvedIdentities: IResolvedIdentity[]) => void;
     };
     actions: {
-        resolveIdentities: import("./Store").StoreAction<unknown, (identities: Identity[]) => void, (result: {
+        resolveIdentities: StoreAction<unknown, (identities: Identity[]) => void, (result: {
             [uid: string]: IResolvedIdentity;
         }, identities: Identity[]) => void, (failureReason: any, identities: Identity[]) => void, (identities: Identity[]) => Promise<{
             [uid: string]: IResolvedIdentity;
         }>>;
-        query: import("./Store").StoreAction<unknown, (query: IdentityQuery) => void, (result: import("@omnia/fx-models").ItemQueryResult<IResolvedIdentity>, query: IdentityQuery) => void, (failureReason: any, query: IdentityQuery) => void, (query: IdentityQuery) => Future<import("@omnia/fx-models").ItemQueryResult<IResolvedIdentity>>>;
+        query: StoreAction<unknown, (query: IdentityQuery) => void, (result: ItemQueryResult<IResolvedIdentity>, query: IdentityQuery) => void, (failureReason: any, query: IdentityQuery) => void, (query: IdentityQuery) => Future<ItemQueryResult<IResolvedIdentity>>>;
+        ensureSpecialIdentities: StoreAction<unknown, () => void, (result: IResolvedIdentity[]) => void, (failureReason: any) => void, () => Future<IResolvedIdentity[]>>;
     };
     protected onActivated(): void;
 }
+export {};

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

@@ -34,7 +34,7 @@ export declare class IdentitySyncProviderStore extends Store {
             total: number;
             value: import("@omnia/fx-models").IdentityProviderRunLog[];
         }>>;
-        getSyncPropertyBindings: import("./Store").StoreAction<unknown, (providerId: GuidValue) => void, (result: IdentityPropertySyncBinding[], providerId: GuidValue) => void, (failureReason: any, providerId: GuidValue) => void, (providerId: GuidValue) => Promise<IdentityPropertySyncBinding[]>>;
+        getSyncPropertyBindings: import("./Store").StoreAction<unknown, (providerId: GuidValue, refesh?: boolean) => void, (result: IdentityPropertySyncBinding[], providerId: GuidValue, refesh?: boolean) => void, (failureReason: any, providerId: GuidValue, refesh?: boolean) => void, (providerId: GuidValue, refesh?: boolean) => Promise<IdentityPropertySyncBinding[]>>;
         addSyncPropertyBinding: import("./Store").StoreAction<unknown, (value: IdentityPropertySyncBindingBase) => void, (result: void, value: IdentityPropertySyncBindingBase) => void, (failureReason: any, value: IdentityPropertySyncBindingBase) => void, (value: IdentityPropertySyncBindingBase) => Promise<void>>;
         removeSyncPropertyBinding: import("./Store").StoreAction<unknown, (value: IdentityPropertySyncBinding) => void, (result: void, value: IdentityPropertySyncBinding) => void, (failureReason: any, value: IdentityPropertySyncBinding) => void, (value: IdentityPropertySyncBinding) => Promise<void>>;
     };

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

@@ -0,0 +1,23 @@
+import { Store } from "./Store";
+export interface OrderedUrl {
+    order: number;
+    url: string;
+}
+export declare class LinkReferencesStore extends Store {
+    private previousUrlsStack;
+    onActivated(): void;
+    onDisposing(): void;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        previousUrl: () => OrderedUrl;
+        fullHistory: () => OrderedUrl[];
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {
+        push: import("./Store").StoreMutation<(newState: string) => void, (newState: string) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    };
+}

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

@@ -1,16 +1,30 @@
-import { Store } from "./Store";
-declare class InternalLocalizationNonReacticeStore extends Store {
-    localizations: {
-        state: {};
+import { LocalizationTargetTypes } from "../models";
+export declare const useLocalizationStore: () => {
+    state: {};
+    events: {} & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching<T extends (...args: any) => any>(action: (actions: {
+            ensureLoadLocalization: (target: LocalizationTargetTypes) => Promise<void>;
+            merge: (value: object) => void;
+        }) => T, fn: T extends (...args: infer U) => any ? (...args: U) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onDispatched<T_1 extends (...args: any) => any>(action: (actions: {
+            ensureLoadLocalization: (target: LocalizationTargetTypes) => Promise<void>;
+            merge: (value: object) => void;
+        }) => T_1, fn: T_1 extends (...args: infer U_1) => infer Y | Promise<infer Y> ? (result: Y, ...args: U_1) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onFailure<T_2 extends (...args: any) => any>(action: (actions: {
+            ensureLoadLocalization: (target: LocalizationTargetTypes) => Promise<void>;
+            merge: (value: object) => void;
+        }) => T_2, fn: T_2 extends (...args: infer U_2) => any ? (failureReason: any, ...args: U_2) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    } & {
+        ensureLoadLocalization: (target: LocalizationTargetTypes) => Promise<void>;
+        merge: (value: object) => void;
     };
-    onActivated(): void;
-    onDisposing(): void;
-    mutations: {
-        merge: import("./Store").StoreMutation<(input: object) => void, (input: object) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+    get: {
+        state: () => {
+            [key: string]: {};
+        };
+        replace(text: string): string;
+        value: (key: string) => string;
+        path: <T_3>(namespace: string, exp: (localize: T_3) => string) => string;
     };
-    private mergeLoc;
-}
-export declare class LocalizationStore {
-    static instance: InternalLocalizationNonReacticeStore;
-}
-export {};
+};

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

@@ -4,17 +4,18 @@ export declare class MediaPickerStore extends Store {
     private mediaPickerService;
     private imageRatios;
     private imageScalings;
-    private mediapickerProviders;
+    private providers;
     private providerHooks;
     private ensuredLoadImageRatiosPromise;
     private ensuredLoadImageScalingsPromise;
+    constructor();
     getters: {
         imageRatios: () => Array<MediaPickerImageRatio>;
         imageRatioByUniqueId: (uniqueId: GuidValue) => MediaPickerImageRatio;
         rollupRatios: () => Array<MediaPickerRollupImageRatio>;
         imageScalings: () => Array<MediaPickerImageScaling>;
         imageScalingByUniqueId: (uniqueId: GuidValue) => MediaPickerImageScaling;
-        mediapickerProviders: () => Array<MediaPickerProvider>;
+        providers: () => Array<MediaPickerProvider>;
         url: (media: MediaPickerImage | MediaPickerVideo, ratioId?: GuidValue) => string;
     };
     mutations: {

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

@@ -1,12 +1,11 @@
-import { OrgTreeUser, UserInformation, TenantPeopleInformation, UserIdentity } from "../models";
+import { OrgTreeUser, UserInformation, TenantPeopleInformation, UserIdentity, ResolvedUserIdentity } from "../models";
 import { Store } from "./Store";
 import { ProfileCardService } from "../services/ProfileCardService";
-import { LocalizationService } from "../services/LocalizationService";
 import { UserIdentityStore } from "./UserIdentityStore";
 export declare class ProfileCardStore extends Store {
     profileCardService: ProfileCardService;
     private omniaContext;
-    localizationService: LocalizationService;
+    private localizationStore;
     userIdentityStore: UserIdentityStore;
     user: import("./Store").StoreState<{
         [uid: string]: OrgTreeUser;
@@ -14,6 +13,8 @@ export declare class ProfileCardStore extends Store {
     userInformation: import("./Store").StoreState<{
         [uid: string]: UserInformation;
     }>;
+    userInProfile: import("./Store").StoreState<UserIdentity>;
+    userInProfileResolved: import("./Store").StoreState<ResolvedUserIdentity>;
     private enablePeopleInformation;
     private profileCardDialogTabs;
     tenantPeopleInfomation: import("./Store").StoreState<TenantPeopleInformation>;
@@ -23,15 +24,18 @@ export declare class ProfileCardStore extends Store {
         getEnablePeopleInformation: () => boolean;
         getProfileCardDialogTabs: () => Array<string>;
         getTenantPeopleInformationModel: () => TenantPeopleInformation;
+        getResolvedUserInProfile: () => ResolvedUserIdentity;
     };
     mutations: {
         setEnablePeopleInformation: import("./Store").StoreMutation<(value: boolean) => void, (value: boolean) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
         setProfieCardDialogTabs: import("./Store").StoreMutation<(tabs: string[]) => void, (tabs: string[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
         setTenantPeopleInformation: import("./Store").StoreMutation<(value: TenantPeopleInformation) => void, (value: TenantPeopleInformation) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
+        setUserInProfile: import("./Store").StoreMutation<(user: UserIdentity) => void, (user: UserIdentity) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
     actions: {
         loadUser: import("./Store").StoreAction<unknown, (user: UserIdentity) => void, (result: OrgTreeUser, user: UserIdentity) => void, (failureReason: any, user: UserIdentity) => void, (user: UserIdentity) => Promise<OrgTreeUser>>;
         loadUserProperties: import("./Store").StoreAction<unknown, (user: UserIdentity, refresh?: boolean) => void, (result: UserInformation, user: UserIdentity, refresh?: boolean) => void, (failureReason: any, user: UserIdentity, refresh?: boolean) => void, (user: UserIdentity, refresh?: boolean) => Promise<UserInformation>>;
+        loadUserInProfile: import("./Store").StoreAction<unknown, () => void, (result: ResolvedUserIdentity) => void, (failureReason: any) => void, () => Promise<ResolvedUserIdentity>>;
     };
     onActivated(): void;
     onDisposing(): void;

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

@@ -19,10 +19,10 @@ export interface StateMutationLog {
 export interface StateActionLog {
     func: any;
 }
-type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
-type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
-type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
-type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
+export type MapOnCommitToCommit<T extends Function> = T extends (...args: infer U) => void ? (...args: U) => IMessageBusSubscriptionHandler : T;
+export type MapActionOnDispatching<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (...args: U) => void : never;
+export type MapActionOnDispatched<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (result: Y, ...args: U) => void : never;
+export type MapActionOnFailure<T extends Function> = T extends (...args: infer U) => Promise<infer Y> ? (failureReason: any, ...args: U) => void : never;
 export declare class StoreLogger {
     private _logState;
     enabled: boolean;
@@ -148,4 +148,3 @@ export declare class StoreMutation<T extends Function, CommitFunc extends Functi
     onCommiting(fn: T): IMessageBusSubscriptionHandler;
     onCommited(fn: T): IMessageBusSubscriptionHandler;
 }
-export {};

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

@@ -1,22 +1,19 @@
 import { TimeZoneUnit } from "../models";
 import { Store } from "./Store";
+import dayjs from "dayjs";
 export declare class TimeZoneStore extends Store {
     private timeZoneService;
-    private omniaContext;
     private localTimeZoneId;
     private timeZoneUnits;
     private loadTimeZoneCollectionPromise;
-    private loadCurrenTimeZoneSettingsPromise;
-    private currentUser;
-    private currentTimeZone;
     getters: {
         localTimeZoneId: () => string;
         timeZones: () => TimeZoneUnit[];
-        convertToCurrentUserTimeZone: (utcDatetime: string) => any;
+        convertToCurrentUserTimeZone: (utcDatetime: string) => dayjs.Dayjs;
+        convertToTimeZone: (utcDatetime: string, timezone: string) => dayjs.Dayjs;
     };
     actions: {
         ensureTimeZones: import("./Store").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
-        ensureLoadedCurrentTimeZoneSettings: import("./Store").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
     };
     protected onActivated(): void;
 }

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

@@ -1,4 +1,4 @@
-import { EnterprisePropertyDefinition, GroupIdentity, GuidValue, Identity, IdentityProperty, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity } from "@omnia/fx-models";
+import { GroupIdentity, GuidValue, Identity, IdentityProperty, UserIdentityPropertyDefinition, PropertyBinding, PropertyDefinition, ResolvedUserIdentity, UserIdentity } from "@omnia/fx-models";
 import { MediaPickerService, UserPresenceStatus } from "../services";
 import { Store } from "./Store";
 export declare class UserIdentityStore extends Store {
@@ -22,8 +22,11 @@ export declare class UserIdentityStore extends Store {
     };
     actions: {
         addUserProperty: import("./Store").StoreAction<unknown, (property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (result: void, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (failureReason: any, property: PropertyBinding<PropertyDefinition<any, any, any, import("@omnia/fx-models").PropertySetupBase>>) => void, (property: PropertyBinding<PropertyDefinition<any, any, any>>) => Promise<void>>;
-        createUserProperty: import("./Store").StoreAction<unknown, (property: EnterprisePropertyDefinition) => void, (result: void, property: EnterprisePropertyDefinition) => void, (failureReason: any, property: EnterprisePropertyDefinition) => void, (property: EnterprisePropertyDefinition) => Promise<void>>;
+        createUserProperty: import("./Store").StoreAction<unknown, (property: UserIdentityPropertyDefinition) => void, (result: void, property: UserIdentityPropertyDefinition) => void, (failureReason: any, property: UserIdentityPropertyDefinition) => void, (property: UserIdentityPropertyDefinition) => Promise<void>>;
         removeUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        updateUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        terminateUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
+        restoreUserProperty: import("./Store").StoreAction<unknown, (identityProperty: IdentityProperty) => void, (result: void, identityProperty: IdentityProperty) => void, (failureReason: any, identityProperty: IdentityProperty) => void, (identityProperty: IdentityProperty) => Promise<void>>;
         ensureLoadUserProperties: import("./Store").StoreAction<unknown, () => void, (result: IdentityProperty[]) => void, (failureReason: any) => void, () => Promise<IdentityProperty[]>>;
         resolveUsersIdentity: import("./Store").StoreAction<unknown, (users: UserIdentity[]) => void, (result: {
             [uid: string]: ResolvedUserIdentity;

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

@@ -13,6 +13,7 @@ export declare class VersionedLayoutStore extends Store {
         getLatestRef: (dataIdentifier: IVersionedDataIdentifier) => LatestReferenceResponse;
         getAppScopedLayoutWithDefinition: <Definition extends VersionedLayoutDefinition>(appInstanceId: GuidValue, 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[];
     };
     mutations: {
         addOrUpdateLayouts: import("./Store").StoreMutation<(...versionedLayouts: VersionedLayout[]) => void, (...args: VersionedLayout[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
@@ -27,6 +28,7 @@ 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: Layout, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (failureReason: any, version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => void, (version: IVersionReference, parentVersion: IVersionReference, force?: boolean) => Promise<Layout>>;
         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>>;
         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: {
             versionedLayout: VersionedLayout;
@@ -35,6 +37,13 @@ export declare class VersionedLayoutStore extends Store {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
         }>>;
+        createBusinessProfileScoped: import("./Store").StoreAction<unknown, (businessProfileId: GuidValue, 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<{
+            versionedLayout: VersionedLayout;
+            checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;
+        }>>;
         createTenantScoped: import("./Store").StoreAction<unknown, (definition: VersionedLayoutDefinition, urlSegment: string, parentLayoutId?: VersionedLayoutId) => void, (result: {
             versionedLayout: VersionedLayout;
             checkedOutVersionedData: IVersionedData<VersionedLayoutDefinition>;

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

@@ -40,3 +40,6 @@ export * from "./PromotedTagStore";
 export * from "./DynamicGroupStore";
 export * from "./ConnectedTenantStore";
 export * from "./DefineStore";
+export * from "./oxide";
+export * from "./AiSettingsStore";
+export * from "./LinkReferencesStore";

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

@@ -0,0 +1,71 @@
+declare const HostTypeDefinitions: readonly ["admin", "editor", "docs"];
+export type HostTypes = typeof HostTypeDefinitions[number];
+declare const ComponentHostTypeDefinitions: readonly ["dialog", "drawer", "expansion-panel", "blade", "app", "table", "appbar", "toolbar", "tab", "tab-vertical", "panel", "omfx", "menu"];
+export type ComponentHostTypes = typeof ComponentHostTypeDefinitions[number];
+declare const ComponentVariantDefinitions: readonly ["footer", "content", "navigation", "header", "settings", "info-section", "default", "section", "options", "toolbar"];
+export type ComponentVariants = typeof ComponentVariantDefinitions[number];
+export interface NewHostSettings {
+    host?: HostTypes;
+    componentHost?: ComponentHostTypes;
+    variant?: ComponentVariants;
+    force?: boolean;
+    appliedComponent?: string;
+}
+export declare const useCompontentHostStore: () => {
+    state: {
+        host: "editor" | "admin" | "docs";
+        componentHost: "dialog" | "menu" | "table" | "tab" | "toolbar" | "app" | "tab-vertical" | "drawer" | "expansion-panel" | "blade" | "appbar" | "panel" | "omfx";
+        componentVariant: "section" | "navigation" | "default" | "footer" | "header" | "options" | "content" | "toolbar" | "settings" | "info-section";
+        appliedComponents: string[];
+        force: boolean;
+    };
+    events: {
+        onMutatedHost: import("internal/fx/core").MessageBusExposeOnlySubscription<"editor" | "admin" | "docs">;
+        onMutatedComponentHost: import("internal/fx/core").MessageBusExposeOnlySubscription<"dialog" | "menu" | "table" | "tab" | "toolbar" | "app" | "tab-vertical" | "drawer" | "expansion-panel" | "blade" | "appbar" | "panel" | "omfx">;
+        onMutatedComponentVariant: import("internal/fx/core").MessageBusExposeOnlySubscription<"section" | "navigation" | "default" | "footer" | "header" | "options" | "content" | "toolbar" | "settings" | "info-section">;
+        onMutatedAppliedComponents: import("internal/fx/core").MessageBusExposeOnlySubscription<string[]>;
+        onMutatedForce: import("internal/fx/core").MessageBusExposeOnlySubscription<boolean>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching<T extends (...args: any) => any>(action: (actions: {
+            addAppliedComponent(host: string): void;
+            setHost(type: HostTypes): void;
+            setComponentHost(type: ComponentHostTypes): void;
+            setComponentVariant(variant: ComponentVariants): void;
+            setForce(value: boolean): void;
+            provideNewHost(settings: NewHostSettings): void;
+        }) => T, fn: T extends (...args: infer U) => any ? (...args: U) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onDispatched<T_1 extends (...args: any) => any>(action: (actions: {
+            addAppliedComponent(host: string): void;
+            setHost(type: HostTypes): void;
+            setComponentHost(type: ComponentHostTypes): void;
+            setComponentVariant(variant: ComponentVariants): void;
+            setForce(value: boolean): void;
+            provideNewHost(settings: NewHostSettings): void;
+        }) => T_1, fn: T_1 extends (...args: infer U_1) => infer Y | Promise<infer Y> ? (result: Y, ...args: U_1) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+        onFailure<T_2 extends (...args: any) => any>(action: (actions: {
+            addAppliedComponent(host: string): void;
+            setHost(type: HostTypes): void;
+            setComponentHost(type: ComponentHostTypes): void;
+            setComponentVariant(variant: ComponentVariants): void;
+            setForce(value: boolean): void;
+            provideNewHost(settings: NewHostSettings): void;
+        }) => T_2, fn: T_2 extends (...args: infer U_2) => any ? (failureReason: any, ...args: U_2) => void : never): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+    } & {
+        addAppliedComponent(host: string): void;
+        setHost(type: HostTypes): void;
+        setComponentHost(type: ComponentHostTypes): void;
+        setComponentVariant(variant: ComponentVariants): void;
+        setForce(value: boolean): void;
+        provideNewHost(settings: NewHostSettings): void;
+    };
+    get: {
+        canApplyOn: (hostType: ComponentHostTypes | HostTypes, variant?: any) => boolean;
+        readonly host: "editor" | "admin" | "docs";
+        readonly componentHost: "dialog" | "menu" | "table" | "tab" | "toolbar" | "app" | "tab-vertical" | "drawer" | "expansion-panel" | "blade" | "appbar" | "panel" | "omfx";
+        readonly componentVariant: "section" | "navigation" | "default" | "footer" | "header" | "options" | "content" | "toolbar" | "settings" | "info-section";
+        readonly force: boolean;
+        appliedComponents(host: string): boolean;
+    };
+};
+export {};