@omnia/workplace 8.0.8-dev → 8.0.9-dev

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

@@ -1,4 +1,4 @@
-import { MultilingualString } from "@omnia/fx-models";
+import { MultilingualString, guid } from "@omnia/fx-models";
 import { TeamCollaborationRollupBlockSettings } from "../teamcollaborationrollup";
 import { CreateTeamworkBlockSettings } from "..";
 import { DialogPositions } from "@omnia/fx/ux";
@@ -15,7 +15,7 @@ export interface TeamCollaborationNavigationSettings {
     linkCreateNewSite: string;
 }
 export interface TeamworkNavigationTab {
-    id: string;
+    id: guid;
     title: MultilingualString;
     rollupSettings: TeamCollaborationRollupBlockSettings;
 }

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

@@ -1,4 +1,4 @@
-import { Spacing, GuidValue, RollupFilter, RollupSetting, PersonPropFilterValue, BooleanPropFilterValue, TextPropFilterValue, TaxonomyPropFilterValue, TexSearchestPropFilterValue, MultilingualString, MediaPickerImage, FilterEngineSettings, RollupMetricSettings, DatePeriodPropFilterValue } from "@omnia/fx-models";
+import { Spacing, guid, RollupFilter, RollupSetting, PersonPropFilterValue, BooleanPropFilterValue, TextPropFilterValue, TaxonomyPropFilterValue, TexSearchestPropFilterValue, MultilingualString, MediaPickerImage, FilterEngineSettings, RollupMetricSettings, DatePeriodPropFilterValue } from "@omnia/fx-models";
 import { TeamCollaborationRollupScopeTypes } from ".";
 import { AppEnums } from "../apps";
 export declare const TeamCollaborationConstants: {
@@ -9,7 +9,7 @@ export declare const TeamCollaborationConstants: {
     readonly appInstanceDescription: string;
 };
 export interface TeamCollaborationRollupResultItem {
-    id: string;
+    id: guid;
     properties: {
         [key: string]: any;
     };
@@ -21,12 +21,12 @@ export interface TeamCollaborationRollupResultItem {
     templateIcon?: any;
     image?: MediaPickerImage;
     defaultResourceUrlType?: AppEnums.ResourceUrlType;
-    businessProfileId?: GuidValue;
+    businessProfileId?: guid;
 }
 export interface MSTeamResponseResult {
     createdDateTime?: string;
     isArchived?: boolean;
-    id: GuidValue;
+    id: guid;
     webUrl: string;
     displayName: string;
     description?: string;
@@ -38,7 +38,7 @@ export interface TeamCollaborationResult {
     md5Hash?: string;
 }
 export interface TeamCollaborationRollupRegistrationView {
-    id: GuidValue;
+    id: guid;
     title: string;
     viewElement: string;
     settingsElement: string;
@@ -81,7 +81,7 @@ export interface TeamCollaborationRollupQuery extends RollupSetting {
     excludePersonalSite?: boolean;
     enableWildcardSearch?: boolean;
     currentBusinessProfile?: boolean;
-    trimByRoleId?: GuidValue;
+    trimByRoleId?: guid;
     searchProperties?: Array<string>;
     showMetric?: boolean;
 }
@@ -102,7 +102,7 @@ export interface TeamCollaborationRollupBlockSettings extends TeamCollaborationR
     spacing?: Spacing;
     showFollowStatus?: boolean;
     currentBusinessProfile?: boolean;
-    selectedBusinessProfiles?: Array<GuidValue>;
+    selectedBusinessProfiles?: Array<guid>;
     excludePersonalSite?: boolean;
     dialogMode?: boolean;
     tabMode?: boolean;

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

@@ -1,11 +1,11 @@
-import { GuidValue, EnterprisePropertyDefinition } from "@omnia/fx-models";
+import { guid, EnterprisePropertyDefinition } from "@omnia/fx-models";
 import { TeamCollaborationRollupViewSettings, TeamCollaborationRollupResultItem, TeamCollaborationRollupBlockSettings } from "./TeamCollaborationRollupBlock";
 export interface MyTeamCollaborationDialog {
     open: boolean;
     isCreateMode: boolean;
 }
 export interface TeamCollaborationRollupViewRegistration {
-    id: GuidValue;
+    id: guid;
     title: string;
     viewElement: string;
     settingsElement: string;

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

@@ -1,15 +1,15 @@
-import { Spacing, MultilingualString, IBlockSettingsWriter, GuidValue } from "@omnia/fx-models";
+import { Spacing, MultilingualString, IBlockSettingsWriter, guid } from "@omnia/fx-models";
 import { TeamNews } from ".";
 export interface TeamNewsRollupViewSettings {
     title: MultilingualString;
     itemLimit: number;
     dayLimit: number;
-    selectedViewManifestId: GuidValue;
+    selectedViewManifestId: guid;
     includeLegacyAnnoucement: boolean;
     filterByFollowedSites: boolean;
     showNewsImage: boolean;
     query: string;
-    selectedSettingsViewManifestId?: GuidValue;
+    selectedSettingsViewManifestId?: guid;
     selectedViewId?: string;
     orderBy?: string;
     spacing?: Spacing;

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

@@ -1,9 +1,9 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 export interface TeamNewsRollupViewRegistration {
-    id?: GuidValue;
+    id?: guid;
     title: string;
-    componentManifestId: GuidValue;
-    settingsComponentManifestId?: GuidValue;
+    componentManifestId: guid;
+    settingsComponentManifestId?: guid;
     viewElement?: string;
     settingsElement?: string;
 }

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

@@ -1,18 +1,18 @@
-import { GuidValue, Identity } from "@omnia/fx/models";
+import { guid, Identity } from "@omnia/fx/models";
 import { AnalyticsDimensionMapping, AnalyticsDimensionScopes, AnalyticsDimensions, AnalyticsScopeInfo, AnalyticsSettings, AnalyticsToken, WidgetCategoryInfo, MatomoSite } from "../models/analytics";
 export declare class AnalyticsStoreService {
     private httpClient;
     constructor();
-    getSettings: (businessProfileId?: GuidValue) => Promise<AnalyticsSettings>;
-    getToken: (businessProfileId?: GuidValue) => Promise<AnalyticsToken>;
-    getDimensions: (businessProfileId?: GuidValue) => Promise<AnalyticsDimensions>;
-    getScopesInfo: (businessProfileId?: GuidValue) => Promise<AnalyticsScopeInfo[]>;
+    getSettings: (businessProfileId?: guid) => Promise<AnalyticsSettings>;
+    getToken: (businessProfileId?: guid) => Promise<AnalyticsToken>;
+    getDimensions: (businessProfileId?: guid) => Promise<AnalyticsDimensions>;
+    getScopesInfo: (businessProfileId?: guid) => Promise<AnalyticsScopeInfo[]>;
     getWidgetInformation: () => Promise<WidgetCategoryInfo[]>;
     addDimension: (name: string, scope: AnalyticsDimensionScopes) => Promise<number>;
     enableAnalytics: () => Promise<boolean>;
     disableAnalytics: () => Promise<boolean>;
-    setBusinessProfileReaders: (roleId: GuidValue, identities: Identity[]) => Promise<void>;
-    setTenantAdmins: (roleId: GuidValue, identities: Identity[]) => Promise<void>;
+    setBusinessProfileReaders: (roleId: guid, identities: Identity[]) => Promise<void>;
+    setTenantAdmins: (roleId: guid, identities: Identity[]) => Promise<void>;
     setMappings: (mappings: AnalyticsDimensionMapping[]) => Promise<void>;
     ensureSitesWithAtLeastViewAccess: () => Promise<MatomoSite[]>;
 }

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

@@ -1,10 +1,10 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { AppAuthenticationOptions } from "../../fx/models";
 export declare class AppAuthenticationOptionsService {
     private httpClient;
     private appService;
     private featureStore;
     private readonly baseUrl;
-    update: (appInstanceId: GuidValue, options: AppAuthenticationOptions) => Promise<AppAuthenticationOptions>;
-    get: (appInstanceId: GuidValue) => Promise<AppAuthenticationOptions>;
+    update: (appInstanceId: guid, options: AppAuthenticationOptions) => Promise<AppAuthenticationOptions>;
+    get: (appInstanceId: guid) => Promise<AppAuthenticationOptions>;
 }

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

@@ -1,10 +1,10 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { PromotedSearchResult, PromotedSearchResultData } from "../../fx/models";
 export declare class PromotedSearchResultService {
     private httpClient;
     private readonly baseUrl;
-    add: (profileId: GuidValue, data: PromotedSearchResultData) => Promise<PromotedSearchResult>;
+    add: (profileId: guid, data: PromotedSearchResultData) => Promise<PromotedSearchResult>;
     update: (item: PromotedSearchResult) => Promise<PromotedSearchResult>;
-    getAll: (profileId: GuidValue, filterActiveOnly?: boolean) => Promise<PromotedSearchResult[]>;
+    getAll: (profileId: guid, filterActiveOnly?: boolean) => Promise<PromotedSearchResult[]>;
     delete: (item: PromotedSearchResult) => Promise<void>;
 }

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

@@ -1,9 +1,9 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { SearchFeedback, SearchFeedbackData, SearchFeedbackQueryRequest, SearchFeedbackQueryResult } from "../../fx/models";
 export declare class SearchFeedbackService {
     private httpClient;
     private readonly baseUrl;
-    add: (profileId: GuidValue, data: SearchFeedbackData) => Promise<SearchFeedback>;
+    add: (profileId: guid, data: SearchFeedbackData) => Promise<SearchFeedback>;
     query: (request: SearchFeedbackQueryRequest) => Promise<SearchFeedbackQueryResult>;
     delete: (feedback: SearchFeedback) => Promise<void>;
 }

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

@@ -1,15 +1,15 @@
-import { GuidValue, Identity, ItemQueryResult } from "@omnia/fx/models";
+import { guid, Identity, ItemQueryResult } from "@omnia/fx/models";
 import { ISignOffRequestUpdatableProperties, SignOffRequest, SignOffRequestCreateModel, SignOffRequestQuery, SignOffRequestResourceDetail, SignOffRequestResource, UserSignOffRequests } from "../../fx/models";
 import { SignOffRequestDetails } from "../../fx/models/signoffrequest/SignOffRequestDetail";
 export declare class SignOffRequestService {
     private httpClient;
     private readonly baseUrl;
     getRequests: (query: SignOffRequestQuery) => Promise<ItemQueryResult<SignOffRequest>>;
-    getRequestById: (id: GuidValue) => Promise<SignOffRequest>;
-    getRequestDetails: (id: GuidValue) => Promise<SignOffRequestDetails>;
+    getRequestById: (id: guid) => Promise<SignOffRequest>;
+    getRequestDetails: (id: guid) => Promise<SignOffRequestDetails>;
     addRequest: (request: SignOffRequestCreateModel) => Promise<SignOffRequest>;
     updateRequest: (signOffRequest: SignOffRequest, propertiesToUpdate: ISignOffRequestUpdatableProperties) => Promise<SignOffRequest>;
-    processRequestUsers: (requestId: GuidValue) => Promise<boolean>;
+    processRequestUsers: (requestId: guid) => Promise<boolean>;
     removeRequest: (request: SignOffRequest) => Promise<void>;
     getUnconfirmedRequestsForCurrentUserAsync: () => Promise<UserSignOffRequests>;
     confirmResourceRequests: (requestResponses: Array<SignOffRequestResource>) => Promise<void>;
@@ -19,13 +19,13 @@ export declare class SignOffRequestService {
     sendCloseEmail: (request: SignOffRequest, resourceDetails: Array<SignOffRequestResourceDetail>) => Promise<void>;
     sendReopenEmail: (request: SignOffRequest, resourceDetails: Array<SignOffRequestResourceDetail>) => Promise<void>;
     sendCompletedEmail: (request: SignOffRequest) => void;
-    closeRequest: (signOffRequestId: GuidValue) => Promise<SignOffRequest>;
-    reopenRequest: (signOffRequestId: GuidValue) => Promise<SignOffRequest>;
+    closeRequest: (signOffRequestId: guid) => Promise<SignOffRequest>;
+    reopenRequest: (signOffRequestId: guid) => Promise<SignOffRequest>;
     downloadReport: (request: SignOffRequest, showUserNameInReport: boolean, resourceDetails: Array<SignOffRequestResourceDetail>) => Promise<void>;
     resolveRequestToUsers: (requestTo: Array<Identity>) => Promise<{
         [groupId: string]: Identity[];
     }>;
-    getCurrentRequestToUsers: (requestIds: Array<GuidValue>) => Promise<{
+    getCurrentRequestToUsers: (requestIds: Array<guid>) => Promise<{
         [groupId: string]: Identity[];
     }>;
 }

package/internal-do-not-import-from-here/services/form/FormService.d.ts

@@ -1,17 +1,17 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { ChoiceQuestion, ChoiceQuestionStatistic, CreateFormRequest, Form, FormListing, FormQuery, FormQueryResult, MultipleChoiceQuestion, QueryFormRequest, Submission } from "../../models";
 export declare class FormService {
     private httpClient;
     private readonly baseUrl;
-    queryForms: (query: QueryFormRequest, profileId?: GuidValue) => Promise<FormListing[]>;
+    queryForms: (query: QueryFormRequest, profileId?: guid) => Promise<FormListing[]>;
     queryFormRollup: (query: FormQuery) => Promise<FormQueryResult>;
     deleteForm: (id: number) => Promise<any>;
     loadFormById: (id: number) => Promise<Form>;
     loadFormForRespondent: (id: number) => Promise<Form>;
     loadMySubmission: (formId: number) => Promise<Submission[]>;
     submitForm: (form: Form, saveForLater: boolean, submissionId?: number) => Promise<Submission>;
-    createBusinessProfileForm: (profileId: GuidValue, request: CreateFormRequest) => Promise<Form>;
-    createAppInstanceForm: (appInstanceId: GuidValue, request: CreateFormRequest) => Promise<Form>;
+    createBusinessProfileForm: (profileId: guid, request: CreateFormRequest) => Promise<Form>;
+    createAppInstanceForm: (appInstanceId: guid, request: CreateFormRequest) => Promise<Form>;
     updateForm: (form: Form) => Promise<Form>;
     getChoiceQuestionStatistic: (form: Form, question: ChoiceQuestion | MultipleChoiceQuestion) => Promise<ChoiceQuestionStatistic>;
     clearResponse: (formId: number, closeFormAfterward: boolean) => Promise<Form>;

package/internal-do-not-import-from-here/services/form/FormTemplateService.d.ts

@@ -1,10 +1,10 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { FormTemplate, FormTemplateRequest } from "../../models";
 export declare class FormTemplateService {
     private httpClient;
     private readonly baseUrl;
-    getFormTemplates: (businessProfileId: GuidValue) => Promise<Array<FormTemplate>>;
-    createFormTemplate: (profileId: GuidValue, createRequest: FormTemplateRequest) => Promise<FormTemplate>;
+    getFormTemplates: (businessProfileId: guid) => Promise<Array<FormTemplate>>;
+    createFormTemplate: (profileId: guid, createRequest: FormTemplateRequest) => Promise<FormTemplate>;
     updateFormTemplate: (formTemplate: FormTemplate) => Promise<FormTemplate>;
     removeFormTemplate: (id: number) => Promise<FormTemplate>;
     isFormTemplateInUse: (formTemplateId: number) => Promise<boolean>;

package/internal-do-not-import-from-here/services/form/FormTypeService.d.ts

@@ -1,10 +1,10 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { FormType, FormTypeRequest } from "../../models";
 export declare class FormTypeService {
     private httpClient;
     private readonly baseUrl;
-    getFormTypes: (businessProfileId: GuidValue) => Promise<Array<FormType>>;
-    createFormType: (profileId: GuidValue, formType: FormTypeRequest) => Promise<FormType>;
+    getFormTypes: (businessProfileId: guid) => Promise<Array<FormType>>;
+    createFormType: (profileId: guid, formType: FormTypeRequest) => Promise<FormType>;
     updateFormType: (formType: FormType) => Promise<FormType>;
     removeFormType: (id: number) => Promise<FormType>;
     isFormTypeInUse: (formTypeId: number) => Promise<boolean>;

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

@@ -9,3 +9,43 @@ export declare class AnalyticsFilterStore extends Store {
     };
     actions: any;
 }
+export declare const useAnalyticsFilterStore: () => {
+    state: {
+        filters: AnalyticsFilterSettings[];
+    };
+    get: {
+        pageFilters: (name: string) => AnalyticsFilterSettings;
+    };
+    events: {
+        onMutatedFilters: import("@omnia/fx").MessageBusExposeOnlySubscription<AnalyticsFilterSettings[]>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching: {
+            setFilter: {
+                subscribe(fn: (filter: AnalyticsFilterSettings) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            filterUpdated: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            setFilter: {
+                subscribe(fn: (result: void, filter: AnalyticsFilterSettings) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            filterUpdated: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            setFilter: {
+                subscribe(fn: (failureReason: any, filter: AnalyticsFilterSettings) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            filterUpdated: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        setFilter: (filter: AnalyticsFilterSettings) => Promise<void>;
+        filterUpdated: () => Promise<void>;
+    };
+};

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

@@ -1,7 +1,7 @@
 import { Store } from "@omnia/fx/stores";
 import { OmniaContext } from "@omnia/fx";
-import { GuidValue } from "@omnia/fx-models";
-import { AnalyticsDimensions, AnalyticsScopeInfo, AnalyticsSettings, MatomoSite } from "../models/analytics";
+import { guid, Identity } from "@omnia/fx-models";
+import { AnalyticsDimensionMapping, AnalyticsDimensionScopes, AnalyticsDimensions, AnalyticsScopeInfo, AnalyticsSettings, MatomoSite } from "../models/analytics";
 import { AnalyticsStoreService } from "../services/AnalyticsStoreService";
 import { WidgetCategoryInfo } from "../models";
 export declare class AnalyticsStore extends Store {
@@ -23,19 +23,181 @@ export declare class AnalyticsStore extends Store {
     private analyticsUrl;
     private ensuredLoadSitesWithAtLeastViewAccessPromise;
     private sitesWithAtLeastViewAccess;
+    private isInstalled;
     onActivated(): void;
     onDisposing(): void;
     /**
      * Implementation of getters
      */
     getters: {
-        dimensions: (businessProfileId?: GuidValue) => AnalyticsDimensions;
-        settings: (businessProfileId?: GuidValue) => AnalyticsSettings;
-        scopeInfos: (businessProfileId?: GuidValue) => AnalyticsScopeInfo[];
+        dimensions: (businessProfileId?: guid) => AnalyticsDimensions;
+        settings: (businessProfileId?: guid) => AnalyticsSettings;
+        scopeInfos: (businessProfileId?: guid) => AnalyticsScopeInfo[];
         widgetCategoryInfo: () => WidgetCategoryInfo[];
-        tokens: (businessProfileId?: GuidValue) => string;
+        tokens: (businessProfileId?: guid) => string;
         analyticsUrl: () => string;
         sitesWithAtLeastViewAccess: () => MatomoSite[];
+        isInstalled: () => boolean;
     };
     actions: any;
 }
+export declare const useAnalyticsStore: () => {
+    state: {
+        dimensions: {
+            string: AnalyticsDimensions;
+        };
+        settings: {
+            string: AnalyticsSettings;
+        };
+        scopeInfos: {
+            string: AnalyticsScopeInfo[];
+        };
+        widgetCategoryInfo: WidgetCategoryInfo[];
+        analyticsUrl: string;
+        sitesWithAtLeastViewAccess: MatomoSite[];
+        isInstalled: boolean;
+    };
+    get: {
+        dimensions: (businessProfileId?: guid) => AnalyticsDimensions;
+        settings: (businessProfileId?: guid) => AnalyticsSettings;
+        scopeInfos: (businessProfileId?: guid) => AnalyticsScopeInfo[];
+        widgetCategoryInfo: () => WidgetCategoryInfo[];
+        analyticsUrl: () => string;
+        sitesWithAtLeastViewAccess: () => MatomoSite[];
+        isInstalled: () => boolean;
+    };
+    events: {
+        onMutatedDimensions: import("@omnia/fx").MessageBusExposeOnlySubscription<{
+            string: AnalyticsDimensions;
+        }>;
+        onMutatedSettings: import("@omnia/fx").MessageBusExposeOnlySubscription<{
+            string: AnalyticsSettings;
+        }>;
+        onMutatedScopeInfos: import("@omnia/fx").MessageBusExposeOnlySubscription<{
+            string: AnalyticsScopeInfo[];
+        }>;
+        onMutatedWidgetCategoryInfo: import("@omnia/fx").MessageBusExposeOnlySubscription<WidgetCategoryInfo[]>;
+        onMutatedAnalyticsUrl: import("@omnia/fx").MessageBusExposeOnlySubscription<string>;
+        onMutatedSitesWithAtLeastViewAccess: import("@omnia/fx").MessageBusExposeOnlySubscription<MatomoSite[]>;
+        onMutatedIsInstalled: import("@omnia/fx").MessageBusExposeOnlySubscription<boolean>;
+    } & Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>;
+    actions: {
+        onDispatching: {
+            ensureSettings: {
+                subscribe(fn: (businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureDimensions: {
+                subscribe(fn: (businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureScopesInfo: {
+                subscribe(fn: (businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureWidgetInfo: {
+                subscribe(fn: (force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            enableAnalytics: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            disableAnalytics: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addDimension: {
+                subscribe(fn: (name: string, scope: AnalyticsDimensionScopes) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            storeMappings: {
+                subscribe(fn: (mappings: AnalyticsDimensionMapping[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setBusinessProfileReaders: {
+                subscribe(fn: (roleId: guid, identites: Identity[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setTenantAdmins: {
+                subscribe(fn: (roleId: guid, identites: Identity[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureLoadSitesWithAtLeastViewAccess: {
+                subscribe(fn: () => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onDispatched: {
+            ensureSettings: {
+                subscribe(fn: (result: void, businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureDimensions: {
+                subscribe(fn: (result: void, businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureScopesInfo: {
+                subscribe(fn: (result: void, businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureWidgetInfo: {
+                subscribe(fn: (result: void, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            enableAnalytics: {
+                subscribe(fn: (result: void) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            disableAnalytics: {
+                subscribe(fn: (result: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addDimension: {
+                subscribe(fn: (result: void, name: string, scope: AnalyticsDimensionScopes) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            storeMappings: {
+                subscribe(fn: (result: void, mappings: AnalyticsDimensionMapping[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setBusinessProfileReaders: {
+                subscribe(fn: (result: void, roleId: guid, identites: Identity[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setTenantAdmins: {
+                subscribe(fn: (result: void, roleId: guid, identites: Identity[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureLoadSitesWithAtLeastViewAccess: {
+                subscribe(fn: (result: MatomoSite[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+        onFailure: {
+            ensureSettings: {
+                subscribe(fn: (failureReason: any, businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureDimensions: {
+                subscribe(fn: (failureReason: any, businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureScopesInfo: {
+                subscribe(fn: (failureReason: any, businessProfileId?: guid, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureWidgetInfo: {
+                subscribe(fn: (failureReason: any, force?: boolean) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            enableAnalytics: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            disableAnalytics: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            addDimension: {
+                subscribe(fn: (failureReason: any, name: string, scope: AnalyticsDimensionScopes) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            storeMappings: {
+                subscribe(fn: (failureReason: any, mappings: AnalyticsDimensionMapping[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setBusinessProfileReaders: {
+                subscribe(fn: (failureReason: any, roleId: guid, identites: Identity[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            setTenantAdmins: {
+                subscribe(fn: (failureReason: any, roleId: guid, identites: Identity[]) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+            ensureLoadSitesWithAtLeastViewAccess: {
+                subscribe(fn: (failureReason: any) => void): import("@omnia/fx-models").IMessageBusSubscriptionHandler;
+            };
+        };
+    } & {
+        ensureSettings(businessProfileId?: guid, force?: boolean): Promise<void>;
+        ensureDimensions(businessProfileId?: guid, force?: boolean): Promise<void>;
+        ensureScopesInfo(businessProfileId?: guid, force?: boolean): Promise<void>;
+        ensureWidgetInfo(force?: boolean): Promise<void>;
+        enableAnalytics(): Promise<void>;
+        disableAnalytics(): Promise<any>;
+        addDimension(name: string, scope: AnalyticsDimensionScopes): Promise<void>;
+        storeMappings(mappings: AnalyticsDimensionMapping[]): Promise<void>;
+        setBusinessProfileReaders(roleId: guid, identites: Identity[]): Promise<void>;
+        setTenantAdmins(roleId: guid, identites: Identity[]): Promise<void>;
+        ensureLoadSitesWithAtLeastViewAccess(): Promise<MatomoSite[]>;
+    };
+};

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

@@ -1,4 +1,4 @@
-import { Block, GuidValue, IBlockInstance } from "@omnia/fx/models";
+import { Block, guid, IBlockInstance } from "@omnia/fx/models";
 import { ICurrentFormStore, Form, Question, FormRendererBlockSettings } from "../../fx/models";
 export declare class CurrentFormStore implements ICurrentFormStore {
     private _vm;
@@ -12,7 +12,7 @@ export declare class CurrentFormStore implements ICurrentFormStore {
     constructor(form: Form, lockSubmission?: boolean, latestSubmissionAnswers?: Question[], formSettings?: FormRendererBlockSettings);
     destroy(): void;
     toggleShowReponseFlag(): void;
-    removeCheckAnswerFlag(questionId: GuidValue): void;
+    removeCheckAnswerFlag(questionId: guid): void;
     initCheckAnswerFlag(): void;
     isLockSubmission(): boolean;
     isAnswerChanged(): boolean;
@@ -22,7 +22,7 @@ export declare class CurrentFormStore implements ICurrentFormStore {
     setLatestSubmissionAnswers(latestSubmissionsAnswers: Question[]): void;
     getShowResponseFlag(): boolean;
     getLatestSubmissionAnswers(): Question[];
-    getCheckAnswerFlag(questionId: GuidValue): boolean;
+    getCheckAnswerFlag(questionId: guid): boolean;
     getForm(): Form;
     getFormSettings(): FormRendererBlockSettings;
     cloneQuestion(sourceBlock: IBlockInstance | Block, targetBlock: IBlockInstance | Block): Question;

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

@@ -1,5 +1,5 @@
 import { Store, useLocalizationStore } from "@omnia/fx/stores";
-import { Guid } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { DashboardScope, DashboardMetric, DashboardFilter, DashboardScopeMessage } from "../../fx/models";
 export declare class GovernanceDashboardStore extends Store {
     localizationStore: ReturnType<typeof useLocalizationStore>;
@@ -15,8 +15,8 @@ export declare class GovernanceDashboardStore extends Store {
         getScopes: () => {
             [scopeId: string]: DashboardScope;
         };
-        getMetricsByScopeId: (scopeId: Guid) => DashboardMetric[];
-        getFilterByScopeId: (scopeId: Guid) => DashboardFilter[];
+        getMetricsByScopeId: (scopeId: guid) => DashboardMetric[];
+        getFilterByScopeId: (scopeId: guid) => DashboardFilter[];
     };
     registerDashboardFilter: (filter: DashboardFilter) => void;
     registerDashboardScope: (scope: DashboardScopeMessage) => void;

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

@@ -1,5 +1,5 @@
 import { Store } from "@omnia/fx/stores";
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { NotificationPanelHistoryEntry, NotificationPanelBlockSettings } from "../models";
 import { NotificationPanelHistoryService } from "../services";
 export declare class NotificationPanelStore extends Store {
@@ -26,7 +26,7 @@ export declare class NotificationPanelStore extends Store {
         removeHistoryEntries: import("@omnia/fx/stores").StoreMutation<(objectIds: Array<string>) => void, (objectIds: string[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
     actions: {
-        getComponentsSettingsByManifestId: import("@omnia/fx/stores").StoreAction<unknown, (npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: GuidValue, fallbackComponentElementName?: string) => void, (result: unknown, npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: GuidValue, fallbackComponentElementName?: string) => void, (failureReason: any, npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: GuidValue, fallbackComponentElementName?: string) => void, (npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: GuidValue, fallbackComponentElementName?: string) => any>;
+        getComponentsSettingsByManifestId: import("@omnia/fx/stores").StoreAction<unknown, (npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: guid, fallbackComponentElementName?: string) => void, (result: unknown, npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: guid, fallbackComponentElementName?: string) => void, (failureReason: any, npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: guid, fallbackComponentElementName?: string) => void, (npBlockSettings: NotificationPanelBlockSettings[], componentManifestId: guid, fallbackComponentElementName?: string) => any>;
         /**
         * Object ids values must be lowercase
         */

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

@@ -1,4 +1,4 @@
-import { GuidValue } from "@omnia/fx-models";
+import { guid } from "@omnia/fx-models";
 import { Store } from "@omnia/fx/stores";
 import { PromotedSearchResult, PromotedSearchResultData } from "../models";
 export declare class PromotedSearchResultStore extends Store {
@@ -7,20 +7,19 @@ export declare class PromotedSearchResultStore extends Store {
     private userTargetingStore;
     private multilingualStore;
     getters: {
-        all: (profileId: GuidValue) => PromotedSearchResult[];
-        search: (text: string, profileId: GuidValue) => PromotedSearchResult[];
+        all: (profileId: guid) => PromotedSearchResult[];
+        search: (text: string, profileId: guid) => PromotedSearchResult[];
     };
     mutations: {
         addOrUpdate: import("@omnia/fx/stores").StoreMutation<(...items: PromotedSearchResult[]) => void, (...args: PromotedSearchResult[]) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
         remove: import("@omnia/fx/stores").StoreMutation<(item: PromotedSearchResult) => void, (item: PromotedSearchResult) => import("@omnia/fx-models").IMessageBusSubscriptionHandler>;
     };
     actions: {
-        ensureLoad: import("@omnia/fx/stores").StoreAction<unknown, (profileId: GuidValue, filterOnlyActive?: boolean) => void, (result: void, profileId: GuidValue, filterOnlyActive?: boolean) => void, (failureReason: any, profileId: GuidValue, filterOnlyActive?: boolean) => void, (profileId: GuidValue, filterOnlyActive?: boolean) => Promise<void>>;
-        add: import("@omnia/fx/stores").StoreAction<unknown, (profileId: GuidValue, data: PromotedSearchResultData) => void, (result: PromotedSearchResult, profileId: GuidValue, data: PromotedSearchResultData) => void, (failureReason: any, profileId: GuidValue, data: PromotedSearchResultData) => void, (profileId: GuidValue, data: PromotedSearchResultData) => Promise<PromotedSearchResult>>;
+        ensureLoad: import("@omnia/fx/stores").StoreAction<unknown, (profileId: guid, filterOnlyActive?: boolean) => void, (result: void, profileId: guid, filterOnlyActive?: boolean) => void, (failureReason: any, profileId: guid, filterOnlyActive?: boolean) => void, (profileId: guid, filterOnlyActive?: boolean) => Promise<void>>;
+        add: import("@omnia/fx/stores").StoreAction<unknown, (profileId: guid, data: PromotedSearchResultData) => void, (result: PromotedSearchResult, profileId: guid, data: PromotedSearchResultData) => void, (failureReason: any, profileId: guid, data: PromotedSearchResultData) => void, (profileId: guid, data: PromotedSearchResultData) => Promise<PromotedSearchResult>>;
         update: import("@omnia/fx/stores").StoreAction<unknown, (item: PromotedSearchResult) => void, (result: PromotedSearchResult, item: PromotedSearchResult) => void, (failureReason: any, item: PromotedSearchResult) => void, (item: PromotedSearchResult) => Promise<PromotedSearchResult>>;
         delete: import("@omnia/fx/stores").StoreAction<unknown, (item: PromotedSearchResult) => void, (result: void, item: PromotedSearchResult) => void, (failureReason: any, item: PromotedSearchResult) => void, (item: PromotedSearchResult) => Promise<void>>;
     };
-    private getProfileIdStr;
     private searchByTitle;
     private filterActiveItems;
     private checkSearchMatching;