@omnia/fx 7.5.63-dev → 7.5.63-preview

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

@@ -1,4 +1,4 @@
-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";
@@ -14,6 +14,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 +25,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/UserTypeIdentityStore.d.ts

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

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

@@ -29,6 +29,7 @@ export declare class VersionedLayoutStore extends Store {
         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>>;
+        ensureLoadByTypeIds: import("./Store").StoreAction<unknown, (layoutTypeIds: GuidValue[]) => void, (result: void, layoutTypeIds: GuidValue[]) => void, (failureReason: any, layoutTypeIds: GuidValue[]) => void, (layoutTypeIds: 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;

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

@@ -42,3 +42,4 @@ export * from "./ConnectedTenantStore";
 export * from "./DefineStore";
 export * from "./AiSettingsStore";
 export * from "./LinkReferencesStore";
+export * from "./UserTypeIdentityStore";

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

@@ -57,6 +57,7 @@ export * from "./filterengine";
 export * from "./use";
 export * from "./tag";
 export * from "./statuscoderenderer";
+export * from "./datetimefilterquery";
 export * from "./TokenBasedRouter";
 export * from "./StyleFlow";
 export * from "./UxCoreTypings";

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

@@ -23,6 +23,7 @@ export declare abstract class TokenBasedRouter<T1 extends TokenBasedRoute, T2 ex
     protected protectedClearRoute(): void;
     protected combinePathParts(...parts: string[]): string;
     private resolveContext;
+    static getRouterUrl(): string;
     private static buildPath;
     private static resolveTokenBasedContext;
     private static ensureNoSlashAtTheBeginningAndTheEnd;

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

@@ -280,7 +280,7 @@ export interface OmniaUxLocalization {
                     Subject: string;
                     Body: string;
                 };
-                OnBoardingLink: {
+                OnboardingLink: {
                     Subject: string;
                     Body: string;
                 };
@@ -292,9 +292,21 @@ export interface OmniaUxLocalization {
                     Subject: string;
                     Body: string;
                 };
+                InformDisabledAccountEmail: {
+                    Subject: string;
+                    Body: string;
+                };
+                InformEnabledAccountEmail: {
+                    Subject: string;
+                    Body: string;
+                };
+                InformDisabledAccountDueToTimeLimitedEmail: {
+                    Subject: string;
+                    Body: string;
+                };
             };
             IdentityCreationRequestEmails: {
-                NotifiedIdentities: {
+                NotifyIdentities: {
                     Subject: string;
                     Body: string;
                 };
@@ -396,6 +408,11 @@ export interface OmniaUxLocalization {
                 OverlayOpacity: string;
                 OverlayColor: string;
                 NoResultText: string;
+                Metric: string;
+                ShowMetric: string;
+                Color: string;
+                DialogWidth: string;
+                DialogHeight: string;
             };
             Follow: string;
             Unfollow: string;
@@ -414,6 +431,9 @@ export interface OmniaUxLocalization {
             FixedValue: string;
             CurrentPage: string;
             User: string;
+            TargetedUser: string;
+            CurrentUser: string;
+            SelectedUser: string;
         };
         BooleanFilterOption: {
             Yes: string;
@@ -427,6 +447,7 @@ export interface OmniaUxLocalization {
             FixedHeader: string;
             FixedFilterArea: string;
         };
+        UserProperty: string;
     };
     EnterpriseGlossary: {
         EnterpriseGlossaryPicker: string;
@@ -455,6 +476,12 @@ export interface OmniaUxLocalization {
             TermSet: string;
             Language: string;
             MultilingualText: string;
+            Tags: string;
+            UserType: string;
+            PublishingApp: string;
+            BusinessProfile: string;
+            PageCollection: string;
+            PageType: string;
         };
         Users: {
             Username: string;
@@ -673,6 +700,12 @@ export interface OmniaUxLocalization {
             Description: string;
             Title: string;
         };
+        SharePointTermStore: {
+            Category: string;
+            Description: string;
+            Title: string;
+            ConsentInformation: string;
+        };
     };
     AuditLog: {
         Title: string;
@@ -757,6 +790,7 @@ export interface OmniaUxLocalization {
                     NoDefault: string;
                     CurrentUser: string;
                     PickedUser: string;
+                    SelectedUser: string;
                 };
                 FilterRenderType: {
                     Label: string;
@@ -1277,6 +1311,11 @@ export interface OmniaUxLocalization {
             By: string;
         };
     };
+    UserTypeLayout: {
+        Private: string;
+        Public: string;
+        UserPickerLabel: string;
+    };
     SignIn: {
         Title: string;
         Decsription: string;
@@ -1318,7 +1357,7 @@ export interface OmniaUxLocalization {
             NullOmniaAuthSettings: string;
             OneOrMoreOmniaAuthUnavailable: string;
             AtLeastOneAuthProvider: string;
-            NullEmptyOnBoardingSettings: string;
+            NullEmptyOnboardingSettings: string;
             OmniaAuthSettingsHaveDifferentProvidersLength: string;
         };
     };

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

@@ -1,13 +1,6 @@
-import { DataSourceProperty, Guid, PropertyConfiguration, PropertyDefinition, PropertyDataSourceId, DataSourcePropertyDisplayInformation, GuidValue, PropertyDefinitionId, PropertyDisplaySettingsBase, PropertySetupBase } from "@omnia/fx-models";
+import { Guid, PropertyConfiguration, PropertyDefinition, DataSourcePropertyDisplayInformation, PropertyDefinitionId, PropertyDisplaySettingsBase, PropertySetupBase, AppDataSourceProperty } from "@omnia/fx-models";
 import { EnterprisePropertyStore, MultilingualStore } from "@omnia/fx/stores";
 import { LocalizationService, PropertyDataSourceBase, WritebackResult, EnterprisePropertiesProvider, PropertyBindingService } from "@omnia/fx/services";
-export declare class AppDataSourceProperty extends DataSourceProperty {
-    readonly enterprisePropertyDefinitionId?: GuidValue;
-    readonly builtInId?: GuidValue;
-    readonly builtInInternalName?: string;
-    constructor(dataSourceId: PropertyDataSourceId, enterprisePropertyDefinitionId?: GuidValue, builtInId?: GuidValue, builtInInternalName?: string);
-    isEqual: (property: AppDataSourceProperty) => boolean;
-}
 export declare class AppPropertiesProvider extends PropertyDataSourceBase<AppDataSourceProperty> {
     id: Guid;
     title: string;
@@ -18,23 +11,24 @@ export declare class AppPropertiesProvider extends PropertyDataSourceBase<AppDat
     localizationService: LocalizationService;
     propertyBindingService: PropertyBindingService;
     private static builtInProperties;
-    supportsWriteback2(properties: AppDataSourceProperty[]): Promise<{
-        property: AppDataSourceProperty;
-        supportsWriteBack: boolean;
-    }[]>;
-    writeback(properties: {
-        dataSourceProperty: AppDataSourceProperty;
-        valueToWriteback: any;
-    }[]): Promise<WritebackResult[]>;
+    isEqual: (dataSourceProperty1: AppDataSourceProperty, dataSourceProperty2: AppDataSourceProperty) => boolean;
+    getProperties(): Promise<Array<AppDataSourceProperty>>;
     getPropertyConfiguration(property: AppDataSourceProperty): Promise<PropertyConfiguration<PropertyDefinition<any, PropertyDisplaySettingsBase, any, PropertySetupBase>>>;
     getPropertyDefinition(property: AppDataSourceProperty): Promise<PropertyDefinitionId>;
     getPropertyValues(properties: AppDataSourceProperty[]): Promise<Array<{
         valueFromSource: any;
         dataSourceProperty: AppDataSourceProperty;
     }>>;
-    getProperties(): Promise<Array<AppDataSourceProperty>>;
     getPropertyDisplayInformation(dataSourceProperties: AppDataSourceProperty[]): Promise<{
         property: AppDataSourceProperty;
         displayInformation: DataSourcePropertyDisplayInformation;
     }[]>;
+    supportsWriteback2(properties: AppDataSourceProperty[]): Promise<{
+        property: AppDataSourceProperty;
+        supportsWriteBack: boolean;
+    }[]>;
+    writeback(properties: {
+        dataSourceProperty: AppDataSourceProperty;
+        valueToWriteback: any;
+    }[]): Promise<WritebackResult[]>;
 }

package/internal-do-not-import-from-here/ux/app/appinstance/renderer/AppInstanceRollupRenderer.d.ts

@@ -0,0 +1,7 @@
+import "./AppInstanceRollup.css";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<unknown, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<unknown, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<unknown, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/app/appinstance/renderer/MainRenderer.d.ts

@@ -64,10 +64,7 @@ export declare class MainRenderer extends VueComponentBase<MainRendererProps> {
     private generateFilters;
     private getHasValueFilterItems;
     private checkIfFilterItemHasValue;
-    private getDatePropFilterValue;
     private getTaxonomyFilterTermIds;
-    private generateFromDateFilter;
-    generateToDateFilter(to: Date, filterOnDateTime?: boolean): string;
     private generateTaxonomyFilter;
     private executeGetData;
     private nextPage;

package/internal-do-not-import-from-here/ux/app/appinstance/renderer/metric/MetricDetailsDialogRenderer.d.ts

@@ -0,0 +1,19 @@
+import { AppInstanceRollupRenderingInstance } from "../../shared/AppInstanceRollupRenderingInstance";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    close: () => void;
+    initialRenderingInstance: AppInstanceRollupRenderingInstance;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        close: () => void;
+        initialRenderingInstance: AppInstanceRollupRenderingInstance;
+    }, never>;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    close: () => void;
+    initialRenderingInstance: AppInstanceRollupRenderingInstance;
+}, never>, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        close: () => void;
+        initialRenderingInstance: AppInstanceRollupRenderingInstance;
+    }, never>;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/app/appinstance/renderer/metric/MetricRenderer.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<{
+    total: number;
+}, "total">, any, any, any>;
+export default _default;

package/internal-do-not-import-from-here/ux/app/appinstance/settings/AppInstanceRollupSettings.d.ts

@@ -12,5 +12,6 @@ export declare class AppInstanceRollupSettingsComponent extends VueComponentBase
     private isReadyToRenderFilter;
     created(): void;
     mounted(): void;
+    saveBlockData(): void;
     render(): VueTsxSupport.JSX.Element;
 }

package/internal-do-not-import-from-here/ux/app/appinstance/settings/components/MetricTab.d.ts

@@ -0,0 +1,8 @@
+import { AppInstanceRollupBlockSettings } from "@omnia/fx-models";
+interface MetricsTabProps {
+    settings: AppInstanceRollupBlockSettings;
+    updateSettings: (settings: AppInstanceRollupBlockSettings) => void;
+    isInWcm: boolean;
+}
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default, {}, import("vue-tsx-support").PropsForOutside<MetricsTabProps, never>, any, any, any>;
+export default _default;

package/internal-do-not-import-from-here/ux/app/appinstance/shared/AppInstanceRollupRenderingInstance.d.ts

@@ -0,0 +1,19 @@
+import { AppInstanceInfoUser, AppInstanceRollupBlockSettings, DirectionRules, IBlockInstance } from "@omnia/fx-models";
+export declare class AppInstanceRollupRenderingInstance {
+    private _blockInstance;
+    private _settings;
+    private _hideBlock?;
+    private _appDefinitionId;
+    private _isRightToLeft;
+    private _bidirectionalityClass;
+    private _onFollowAppInstanceClicked;
+    constructor();
+    get blockInstance(): IBlockInstance<AppInstanceRollupBlockSettings>;
+    get settings(): AppInstanceRollupBlockSettings;
+    get hideBlock(): (value: boolean) => void;
+    get bidirectionalityClass(): string;
+    get appDefinitionId(): string;
+    get onFollowAppInstanceClicked(): (appInstanceInfoUser: AppInstanceInfoUser) => void;
+    init(blockInstance: IBlockInstance<AppInstanceRollupBlockSettings>, settings: AppInstanceRollupBlockSettings, hideBlock: (value: boolean) => void, appDefinitionId: string, onFollowAppInstanceClicked: (appInstanceInfoUser: AppInstanceInfoUser) => void, directionRule: DirectionRules): void;
+    apply(instance: AppInstanceRollupRenderingInstance, settings: AppInstanceRollupBlockSettings): void;
+}

package/internal-do-not-import-from-here/ux/datetimefilterquery/DateTimeFilterQuery.css.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    minContentWidth: {
+        width: string;
+    };
+};
+export default _default;

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

@@ -0,0 +1,19 @@
+import { DatePeriodPropFilterValue } from "@omnia/fx/models";
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    filterValue: DatePeriodPropFilterValue;
+    onChange: (filterValue: DatePeriodPropFilterValue) => void;
+}, "filterValue">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        filterValue: DatePeriodPropFilterValue;
+        onChange: (filterValue: DatePeriodPropFilterValue) => void;
+    }, "filterValue">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    filterValue: DatePeriodPropFilterValue;
+    onChange: (filterValue: DatePeriodPropFilterValue) => void;
+}, "filterValue">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        filterValue: DatePeriodPropFilterValue;
+        onChange: (filterValue: DatePeriodPropFilterValue) => void;
+    }, "filterValue">;
+});
+export default _default;

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

@@ -0,0 +1 @@
+export * from "./shared";

package/internal-do-not-import-from-here/ux/datetimefilterquery/loc/localize.d.ts

@@ -0,0 +1,16 @@
+export declare module DateTimeFilterQueryLocalization {
+    const namespace = "Omnia.Ux.DateTimeFilterQuery";
+    interface locInterface {
+        DatePeriods: {
+            OneWeekFromToday: string;
+            TwoWeeksFromToday: string;
+            OneMonthFromToday: string;
+            EarlierThanToday: string;
+            LaterThanToday: string;
+            Custom: string;
+            Today: string;
+            From: string;
+            To: string;
+        };
+    }
+}

package/internal-do-not-import-from-here/ux/datetimefilterquery/shared/DateTimeFilterQueryHelper.d.ts

@@ -0,0 +1,7 @@
+import { DatePeriodPropFilterValue, DatePropFilterValue, DatePropertyFilterCustomValue } from "@omnia/fx/models";
+export declare class DateTimeFilterQueryHelper {
+    static getDateFilterValue(filterValue: DatePeriodPropFilterValue): DatePropFilterValue;
+    private static generateFromDateFilter;
+    private static generateToDateFilter;
+    static parseDateFilterCustomToDateValue(value: DatePropertyFilterCustomValue): Date;
+}

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

@@ -0,0 +1 @@
+export * from "./DateTimeFilterQueryHelper";

package/internal-do-not-import-from-here/ux/enterpriseproperties/display/personfield/PersonFieldDisplay.d.ts

@@ -4,6 +4,7 @@ import { type EnterprisePropertiesPersonDisplaySettings, Identity, IResolvedIden
 import "./PersonFieldDisplay.css";
 import { type EnterprisePropertyDefinition } from "../../../../models";
 import { OmniaTheming, VueComponentBase } from "../../..";
+import { IdentitiesLocalization } from "../../../identities/loc";
 export declare class PersonFieldDisplayComponent extends VueComponentBase implements IWebComponentInstance, IPersonFieldDisplay {
     settings: EnterprisePropertiesPersonDisplaySettings;
     valueBind: Identity[];
@@ -13,6 +14,7 @@ export declare class PersonFieldDisplayComponent extends VueComponentBase implem
     private userIdentityStore;
     private identityStore;
     private multilingualTextsStore;
+    identityLoc: IdentitiesLocalization.locInterface;
     private personFieldDisplayClasses;
     private isLoading;
     hasResolvedValue: boolean;

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

@@ -67,6 +67,10 @@ export declare class FeatureActivation extends VueComponentBase<IFeatureActivati
     private appTemplate;
     private colors;
     private styles;
+    private consentLinkReady;
+    private pullIntervalHandler;
+    private checkLastRequiredFeatureLoading;
+    private lastRquiredPermissionFeature;
     created(): void;
     beforeDestroy(): void;
     get isLoading(): boolean;
@@ -86,13 +90,17 @@ export declare class FeatureActivation extends VueComponentBase<IFeatureActivati
     private upgradeFeature;
     private doOneFeatureUpgradeAsPromise;
     private upgradeAllFeatures;
+    private getTenantPermissionsResources;
     private populateAzureAdPermissionsInfo;
     private getConsentUrl;
     private getRedirectUrl;
+    private checkRequestedPermissionsSynced;
+    private checkRequestedPermissionsReady;
     private adminConsentRedirect;
     private copyUrlToClipboard;
     private showConsentDialog;
     private closeConsentDialog;
+    private isLastRequiredPermissionFeature;
     private renderItems;
     private renderItemAction;
     private renderItemExpansionInfoAndAction;

package/internal-do-not-import-from-here/ux/features/loc/localize.d.ts

@@ -36,5 +36,8 @@ export declare module FeaturesLocalization {
         Activating: string;
         Deactivating: string;
         Deactivate: string;
+        ConsentLinkWaitingMessage: string;
+        ConsentCompletedWaitingActivation: string;
+        InstructingRevisitAzureAdPermissionsSettings: string;
     }
 }

package/internal-do-not-import-from-here/ux/filterengine/handler/FilterEngineHandler.d.ts

@@ -20,6 +20,8 @@ export declare class FilterEngineHandler extends Store {
     private propertyDefinitionHash;
     private propertyMultilingualTitleHash;
     private typedHandlers;
+    private pageNumber;
+    private url;
     private allDataReadyPromise;
     private contextPropertiesApi;
     private contextPropertyDefinitionApi;
@@ -37,6 +39,8 @@ export declare class FilterEngineHandler extends Store {
     private subscriptionHandler;
     getters: {
         keywordsSearching: () => string;
+        pageNumber: () => number;
+        pageUrl: () => string;
         hasSmallContainer: () => boolean;
         hasSmallViewport: () => boolean;
         canRenderSideSections: () => boolean;
@@ -64,6 +68,7 @@ export declare class FilterEngineHandler extends Store {
     mutations: {
         registerTopElement: import("@omnia/fx/stores").StoreMutation<(element: Element) => void, (element: Element) => IMessageBusSubscriptionHandler>;
         setKeywordsSearching: import("@omnia/fx/stores").StoreMutation<(keywordsSearching: string) => void, (keywordsSearching: string) => IMessageBusSubscriptionHandler>;
+        setPageNumber: import("@omnia/fx/stores").StoreMutation<(pageNumber: number) => void, (pageNumber: number) => IMessageBusSubscriptionHandler>;
         clearAllSelections: import("@omnia/fx/stores").StoreMutation<(typedHandlers: ITypedFilterEngineHandler[]) => void, (typedHandlers: ITypedFilterEngineHandler[]) => IMessageBusSubscriptionHandler>;
         toggleShowDialog: import("@omnia/fx/stores").StoreMutation<() => void, () => IMessageBusSubscriptionHandler>;
         ensureCloseDialog: import("@omnia/fx/stores").StoreMutation<() => void, () => IMessageBusSubscriptionHandler>;

package/internal-do-not-import-from-here/ux/filterengine/handler/FilterEngineRouter.d.ts

@@ -22,7 +22,8 @@ declare class InternalFilterEngineRouter extends TokenBasedRouter<FilterEngineRo
     deleteFilters(title: string, componentId: GuidValue): void;
     getFilters(componentId: GuidValue): FilterEngineRouterProperty[];
     getSearchingKeyword(componentId: GuidValue): string;
-    addOrUpdateFilters(title: string, componentId: GuidValue, keyword: string, filters: Array<FilterEngineRouterProperty>): void;
+    getPageNumber(componentId: GuidValue): number;
+    addOrUpdateFilters(title: string, componentId: GuidValue, keyword: string, filters: Array<FilterEngineRouterProperty>, pageNumber?: number): void;
     private getFilterComponentState;
     hasDifferentFilterComponentState(componentId: GuidValue, currentKeyword: string, currentFilters: Array<FilterEngineRouterProperty>): boolean;
     clearRoute(): void;

package/internal-do-not-import-from-here/ux/identities/loc/Localize.d.ts

@@ -1,39 +1,46 @@
-export interface IdentitiesLocalization {
-    Synchronization: {
-        Provider: {
-            AzureAd: {
-                Title: string;
-                Description: string;
-                SyncPropertyBindingSetupTitle: string;
-                SyncRuleSetupTitle: string;
+export declare module IdentitiesLocalization {
+    const namespace = "Omnia.Ux.Identities";
+    interface locInterface {
+        Synchronization: {
+            Provider: {
+                AzureAd: {
+                    Title: string;
+                    Description: string;
+                    SyncPropertyBindingSetupTitle: string;
+                    SyncRuleSetupTitle: string;
+                };
+            };
+            PropertySyncBinding: {
+                SyncProperty: string;
+                UserProperty: string;
+            };
+            Settings: {
+                AddNewRule: string;
+                AddFilter: string;
+                EditRule: string;
+                UserType: string;
+                DisplayName: string;
+                ErrorNoRules: string;
+                EmptyRuleValue: string;
             };
         };
-        PropertySyncBinding: {
-            SyncProperty: string;
-            UserProperty: string;
-        };
-        Settings: {
-            AddNewRule: string;
-            AddFilter: string;
-            EditRule: string;
-            UserType: string;
+        BuiltInProperties: {
+            UserName: string;
             DisplayName: string;
-            ErrorNoRules: string;
-            EmptyRuleValue: string;
+            UserIcon: string;
+            Email: string;
+            PreferredLanguage: string;
+            UiLanguage: string;
+            Description: string;
+            Image: string;
+            ExternalIdentityMappings: string;
+            IsRemoved: {
+                DeletedUser: string;
+                DeletedGroup: string;
+            };
+        };
+        IdentityExternalMappings: {
+            SharePointAllInternalExceptExternal: string;
         };
-    };
-    BuiltInProperties: {
-        UserName: string;
-        DisplayName: string;
-        UserIcon: string;
-        Email: string;
-        PreferredLanguage: string;
-        UiLanguage: string;
-        Description: string;
-        Image: string;
-        ExternalIdentityMappings: string;
-    };
-    IdentityExternalMappings: {
-        SharePointAllInternalExceptExternal: string;
-    };
+    }
 }

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

@@ -0,0 +1 @@
+export * from "./Localize";

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

@@ -1,3 +1,9 @@
+/**
+ * OMNIA:
+ * Modified to be TS and VUE COMPATIBLE
+ *
+ *  */
 export declare class OmniaIFrameResizer {
+    static iframeResizer: any;
     static getIframeResizer: () => any;
 }

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

@@ -1,7 +1,6 @@
 import Vue from "vue";
 import { IWebComponentInstance } from "../..";
 import { IResizingIFrame } from "./IResizingIFrame";
-import { OmniaIFrameResizer } from "./OmniaIFrameResizer";
 export declare class ResizingIFrame extends Vue implements IWebComponentInstance, IResizingIFrame {
     static IFrameContentCss: string;
     static IFrameWrapperClass: string;
@@ -12,7 +11,7 @@ export declare class ResizingIFrame extends Vue implements IWebComponentInstance
     css: string;
     iframeHeight: string;
     iframeCustomStyle: string;
-    omniaIFrameResizer: OmniaIFrameResizer;
+    private iframeResizer;
     mounted(): void;
     beforeDestroy(): void;
     created(): void;