@omnia/fx 8.0.404-dev → 8.0.406-dev

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

@@ -155,4 +155,5 @@ export declare namespace Utils {
      * @returns
      */
     function getQueryStringFromCurrentUrl(name: string): string;
+    function convertStringToArray(object: any): any;
 }

package/internal-do-not-import-from-here/ux/admin/usermanagement/userproperties/GDPRBlade.d.ts

@@ -0,0 +1,6 @@
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<Record<string, any>> & {} & {
+    "v-slots"?: {} & Omit<{
+        default?: import("vue").Slot;
+    }, never>;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, string> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;

package/internal-do-not-import-from-here/ux/aurora/admin/blades/typography/store/TypographyEditorStore.d.ts

@@ -1,9 +1,9 @@
-import { guid, ITemplateRegistration, TypographyBlueprint, TextStyleDefinition, TextStyleSizes, TextStyleType, TypographyFontDefinition, IFontBlueprints, TypographyFontRef, BlueprintVariant, FontAwesomeIcon, TypographyBreakpoint } from "@omnia/fx-models";
+import { guid, ITemplateRegistration, TypographyBlueprint, TextStyleDefinition, TextStyleSizes, TextStyleType, TypographyFontDefinition, IFontBlueprints, TypographyFontRef, BlueprintVariant, FontAwesomeIcon, TextStyleBreakpointType } from "@omnia/fx-models";
 export interface BreakpointItem {
     icon: FontAwesomeIcon;
     title: string;
     subTitle: string;
-    scale: TypographyBreakpoint;
+    scale: TextStyleBreakpointType;
 }
 type StyleVariant = "system-styles" | "custom-styles" | "type-scale";
 export declare const useTypographyEditorStore: () => {
@@ -17,7 +17,7 @@ export declare const useTypographyEditorStore: () => {
             styleVariant: StyleVariant;
         };
         selected: {
-            typography: {
+            textStyle: {
                 type: TextStyleType;
                 size: TextStyleSizes;
                 definition: TextStyleDefinition;
@@ -35,7 +35,7 @@ export declare const useTypographyEditorStore: () => {
             styleVariant: StyleVariant;
         };
         selected: {
-            typography: {
+            textStyle: {
                 type: TextStyleType;
                 size: TextStyleSizes;
                 definition: TextStyleDefinition;
@@ -56,11 +56,10 @@ export declare const useTypographyEditorStore: () => {
             ativateBreakpoint(value: boolean): void;
         };
         calculate(): {
-            editingDefinitionFromBaseStyles(): void;
             baseScale(): void;
         };
         breakpoint(): {
-            setSelected(breakpoint: TypographyBreakpoint): void;
+            setSelected(breakpoint: TextStyleBreakpointType): void;
             activate(value: boolean): void;
         };
         variants(): {
@@ -94,6 +93,7 @@ export declare const useTypographyEditorStore: () => {
         deleteRegistration(): Promise<boolean>;
     }>;
     get: {
+        textStyleName: (textStyleType: TextStyleType, size: TextStyleSizes) => string;
         typeScale: {
             active: {
                 readonly scale: number;
@@ -137,7 +137,7 @@ export declare const useTypographyEditorStore: () => {
             xs: TextStyleDefinition;
             font?: TypographyFontRef;
         };
-        selectedTypoSizeFont: () => string;
+        selectedTextStyleSizeFont: () => string;
     };
     bladeId: {
         startBlade: guid;
@@ -150,7 +150,8 @@ export declare const useTypographyEditorStore: () => {
     };
     rules: {
         breakpoint: {
-            isActive: (size: TypographyBreakpoint) => boolean;
+            readonly showStatus: boolean;
+            isActive: (size: TextStyleBreakpointType) => boolean;
             readonly showEnableDisable: boolean;
             readonly isEnabled: boolean;
         };

package/internal-do-not-import-from-here/ux/aurora/components/textstylepicker/TextStylePicker.d.ts

@@ -1,22 +1,29 @@
 import { DefineSlot } from "@omnia/fx/ux";
-import { TextBlueprint, ThemeContextType, TextStyleValue } from "@omnia/fx-models";
+import { TextBlueprint, ThemeContextType, TextStyleValue, TypographyBlueprint, TextStyleBreakpointType } from "@omnia/fx-models";
 import { VNode } from "vue";
 import { PickerVariant } from "internal/fx/ux/oxide/picker/models/SharedSettings";
+import { ViewTypes } from "./store/TextStylePickerStore";
 export type TypographyPickerTypes = "default" | "title" | "text" | "variant" | "navigation";
 declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
-    "emit:update:modelValue": (value: TextStyleValue) => void;
+    "emit:update:modelValue": (value: number | TextStyleValue) => void;
 } & {
-    "v-model"?: TextStyleValue;
+    "v-model"?: number | TextStyleValue;
 } & {
-    modelValue?: TextStyleValue;
+    modelValue?: number | TextStyleValue;
 } & {
     customTyping?: boolean;
 } & {
     themeType?: ThemeContextType;
+} & {
+    viewType?: ViewTypes;
 } & {
     type?: TypographyPickerTypes;
 } & {
     textBlueprint?: TextBlueprint;
+} & {
+    typographyBlueprint?: TypographyBlueprint;
+} & {
+    breakpoint?: TextStyleBreakpointType;
 } & {
     toned?: boolean;
 } & {
@@ -28,12 +35,12 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
 } & {
     sampleText?: string;
 } & DefineSlot<"activator", () => VNode>> & {
-    "onUpdate:modelValue"?: (value: TextStyleValue) => any;
+    "onUpdate:modelValue"?: (value: number | TextStyleValue) => any;
 } & {
     "v-slots"?: {
         activator?: () => VNode;
     } & Omit<{
         default?: import("vue").Slot;
     }, "activator">;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "label" | "type" | "variant" | "modelValue" | "v-model" | "toned" | "placeholder" | "emit:update:modelValue" | "themeType" | "slot:activator" | "textBlueprint" | "customTyping" | "sampleText"> & import("@omnia/fx/ux").VNodeEvents) => any;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "label" | "type" | "variant" | "modelValue" | "v-model" | "toned" | "placeholder" | "emit:update:modelValue" | "themeType" | "slot:activator" | "textBlueprint" | "customTyping" | "viewType" | "typographyBlueprint" | "breakpoint" | "sampleText"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/aurora/components/textstylepicker/store/TextStylePickerStore.d.ts

@@ -1,15 +1,21 @@
-import { ThemeContextType, ThemedTextStyleValue, TextStyleValue as textStyle } from "@omnia/fx-models";
+import { ThemeContextType, ThemedTextStyleValue, TextStyleValue as textStyle, TypographyBlueprint, TextStyleBreakpointType } from "@omnia/fx-models";
+export type ViewTypes = "type-scale" | "system-styles" | "custom-styles";
 export declare const useTextStylePickerStore: () => {
     state: {
-        internalModel: textStyle;
+        internalModel: number | textStyle;
         sampleText: string;
+        viewType: ViewTypes;
+        typographyBlueprint: TypographyBlueprint;
+        breakPoint: TextStyleBreakpointType;
     };
     actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
         clear: () => void;
+        setScaleValue(value: number): void;
         select: (value: textStyle) => void;
-        initState: (model: textStyle, sampleText: string, themeType: ThemeContextType) => void;
+        initState: (model: textStyle | number, sampleText: string, themeType: ThemeContextType, viewType: ViewTypes, typographyBlueprint: TypographyBlueprint, breakpoint: TextStyleBreakpointType) => void;
     }>;
     get: {
+        readonly textStyle: textStyle;
         displayText: (textStyle: ThemedTextStyleValue) => string;
         displayIcon: (textStyle: ThemedTextStyleValue) => import("@omnia/fx-models").FontAwesomeIcon;
     };

package/internal-do-not-import-from-here/ux/aurora/components/typography/TextStyleEditor.d.ts

@@ -0,0 +1,34 @@
+import { TextStyleDefinition, TypographyBlueprint, TextStyleBreakpointType, TextStyleSizes } from "@omnia/fx-models";
+import { DefineSlot } from "@omnia/fx/ux";
+import { VNodeChild } from "vue";
+type EditorVariant = "default" | "dialog" | "blade-inline";
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
+    "emit:update:modelValue": (value: TextStyleDefinition) => void;
+} & {
+    "v-model"?: TextStyleDefinition;
+} & {
+    modelValue?: TextStyleDefinition;
+} & {
+    variant?: EditorVariant;
+} & {
+    blueprint?: TypographyBlueprint;
+} & {
+    textStyleType?: "display" | "headline" | "title" | "text" | "label" | "variants";
+} & {
+    textStyleSize?: TextStyleSizes;
+} & {
+    breakpoint?: TextStyleBreakpointType;
+} & {
+    sampleText?: string;
+} & {
+    toolbarCallback?: (value: () => VNodeChild) => void;
+} & DefineSlot<"activator", () => VNodeChild>> & {
+    "onUpdate:modelValue"?: (value: TextStyleDefinition) => any;
+} & {
+    "v-slots"?: {
+        activator?: () => VNodeChild;
+    } & Omit<{
+        default?: import("vue").Slot;
+    }, "activator">;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "blueprint" | "variant" | "modelValue" | "v-model" | "emit:update:modelValue" | "slot:activator" | "breakpoint" | "sampleText" | "toolbarCallback" | "textStyleType" | "textStyleSize"> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;

package/internal-do-not-import-from-here/ux/aurora/components/typography/TypographyBlueprintsViewer.d.ts

@@ -1,4 +1,4 @@
-import { BlueprintVariant, ThemeContextType, TypographyBlueprint, TextStyleSizes, TextStyleType, TypographyBreakpoint } from "@omnia/fx-models";
+import { ThemeContextType, TypographyBlueprint, TextStyleSizes, TextStyleType, TextStyleBreakpointType } from "@omnia/fx-models";
 import { DefineEmit } from "@omnia/fx/ux";
 import { ViewTypes } from "./store/TypographyViewerStore";
 type Variant = "list" | "picker";
@@ -6,6 +6,10 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
     blueprint?: TypographyBlueprint;
 } & {
     toned?: boolean;
+} & {
+    showActivationStatus?: boolean;
+} & {
+    activeScale?: number;
 } & {
     sampleText?: string;
 } & {
@@ -13,19 +17,17 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
 } & {
     viewtype?: ViewTypes;
 } & {
-    breakpoint?: TypographyBreakpoint;
+    breakpoint?: TextStyleBreakpointType;
 } & {
     editable?: boolean;
 } & {
     themeType?: ThemeContextType;
-} & DefineEmit<"click:select", (typography: TextStyleType, size: TextStyleSizes) => true> & DefineEmit<"click:selectFill", (variant: BlueprintVariant) => true> & DefineEmit<"click:add", () => true> & DefineEmit<"click:addFill", () => true>> & {
-    "onClick:add"?: () => any;
+} & DefineEmit<"click:select", (typography: TextStyleType, size: TextStyleSizes) => true> & DefineEmit<"click:selectScale", (scale: number) => true>> & {
     "onClick:select"?: (typography: "display" | "headline" | "title" | "text" | "label" | "variants", size: TextStyleSizes) => any;
-    "onClick:selectFill"?: (variant: BlueprintVariant) => any;
-    "onClick:addFill"?: () => any;
+    "onClick:selectScale"?: (scale: number) => any;
 } & {
     "v-slots"?: {} & Omit<{
         default?: import("vue").Slot;
     }, never>;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "blueprint" | "variant" | "editable" | "toned" | "themeType" | "emit:click:add" | "emit:click:select" | "sampleText" | "breakpoint" | "viewtype" | "emit:click:selectFill" | "emit:click:addFill"> & import("@omnia/fx/ux").VNodeEvents) => any;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "blueprint" | "variant" | "editable" | "toned" | "themeType" | "emit:click:select" | "breakpoint" | "sampleText" | "showActivationStatus" | "activeScale" | "viewtype" | "emit:click:selectScale"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/aurora/components/typography/store/TextStyleEditorStore.d.ts

@@ -0,0 +1,83 @@
+import { FontAwesomeIcon, TextStyleBreakPoint, TextStyleDefinition, TextStyleType, TypographyBlueprint, TextStyleBreakpointType, TextStyleSizes } from "@omnia/fx-models";
+export interface BreakpointItem {
+    icon: FontAwesomeIcon;
+    title: string;
+    active: boolean;
+    breakpoint: TextStyleBreakpointType;
+}
+type lineHeightType = "dynamic" | "fixed" | "typescale";
+type fontSizeType = "custom" | "typescale";
+interface SettingsOption {
+    text: string;
+    value: string;
+}
+export declare const useTextStyleEditorStore: () => {
+    state: {
+        internalModel: TextStyleDefinition;
+        blueprint: TypographyBlueprint;
+        textStyleType: "display" | "headline" | "title" | "text" | "label" | "variants";
+        textStyleSize: TextStyleSizes;
+        lineHeightType: lineHeightType;
+        fontSizeType: fontSizeType;
+        breakpoint: TextStyleBreakpointType;
+        customValues: {
+            lineHeightMultiplier: number;
+            lineHeight: number;
+            fontSize: number;
+            scale: number;
+        };
+    };
+    actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
+        textStyleDefinition: () => {
+            update: () => void;
+        };
+        set: () => {
+            fontSize: {
+                fontType: (value: fontSizeType) => void;
+                fixedValue(value: number): void;
+                scale(value: number): void;
+            };
+            lineHeight: {
+                lineHeightType: (value: lineHeightType) => void;
+                fixedValue(value: number): void;
+                multiplier: (value: number) => void;
+            };
+            fontWeight: (value: number) => void;
+            letterSpacing: (value: number) => void;
+        };
+        breakpoint: () => {
+            activate: (value: boolean) => void;
+        };
+        init: () => {
+            customValues: () => void;
+            state: (model: TextStyleDefinition, textStyleType: TextStyleType, breakpoint: TextStyleBreakpointType, blueprint: TypographyBlueprint, textStyleSize: TextStyleSizes) => void;
+        };
+    }>;
+    get: {
+        typeScale: {
+            readonly lineHeightMultiplier: number;
+            readonly defaultTextStyle: TextStyleBreakPoint;
+        };
+        readonly breakpoint: {
+            readonly textStyle: TextStyleBreakPoint;
+        };
+        readonly baseStyle: {
+            readonly scale: number;
+        };
+    };
+    rules: {
+        readonly isEnabled: boolean;
+        show: {
+            readonly enableDisableSwitch: boolean;
+            readonly name: boolean;
+            readonly ItalicSettings: boolean;
+        };
+    };
+    dataTypes: {
+        lineHeightOptions: SettingsOption[];
+        fontSizeOptions: SettingsOption[];
+    };
+} & {
+    dispose?: () => void;
+};
+export {};

package/internal-do-not-import-from-here/ux/aurora/components/typography/store/TypographyViewerStore.d.ts

@@ -1,18 +1,21 @@
-import { TextStyleDefinition, TextStyleSizes, TextStyleType, TypographyBlueprint, TypographyBreakpoint } from "@omnia/fx-models";
+import { TextStyleDefinition, TextStyleSizes, TextStyleType, TypographyBlueprint, TextStyleBreakpointType } from "@omnia/fx-models";
 export type ViewTypes = "type-scale" | "system-styles" | "custom-styles";
 export declare const useTypographyViewerStore: () => {
     state: {
         blueprint: TypographyBlueprint;
         viewType: ViewTypes;
-        breakPoint: TypographyBreakpoint;
+        breakPoint: TextStyleBreakpointType;
         sampleText: string;
+        settings: {
+            showBreakpiontActivStatues: boolean;
+        };
     };
     actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
-        initState: (blueprint: TypographyBlueprint, viewType: ViewTypes, breakPoint: TypographyBreakpoint, sampleText: string) => void;
+        initState: (blueprint: TypographyBlueprint, viewType: ViewTypes, breakPoint: TextStyleBreakpointType, sampleText: string) => void;
     }>;
     get: {
         typeScale: {
-            definition: {
+            textStyleDefinition: {
                 bySize: (size: any) => {
                     textStyleDefinition: TextStyleDefinition;
                     fontSize: number;
@@ -22,10 +25,10 @@ export declare const useTypographyViewerStore: () => {
                 lineHeight: (definition: TextStyleDefinition) => number;
             };
         };
-        typographyName: (typography: TextStyleType, size: TextStyleSizes) => string;
+        textStyleName: (textStyle: TextStyleType, size: TextStyleSizes) => string;
         fontSizeDisplayFormat: (fontCss: string) => string;
         sampleText: (typography: TextStyleType, size: TextStyleSizes) => string;
-        typeStyling: (typography: TextStyleType, size: TextStyleSizes) => any;
+        typeStyling: (textStyleTpe: TextStyleType, size: TextStyleSizes) => any;
     };
     rules: {
         typeScale: {
@@ -33,12 +36,14 @@ export declare const useTypographyViewerStore: () => {
             isSizeUsed(size: number): boolean;
         };
         breakpoint: {
+            isActive(textStyleType: TextStyleType, size: TextStyleSizes): boolean;
+            readonly showActivationStatus: boolean;
             readonly isCustomBreakpoint: boolean;
         };
         variants: {
             isPlaceholder: (size: string) => boolean;
         };
-        canStyleBeDisplayed: (typography: TextStyleType, size: TextStyleSizes, isVariants: boolean) => boolean;
+        canStyleBeDisplayed: (textStyleType: TextStyleType, size: TextStyleSizes, isVariants: boolean) => boolean;
     };
 } & {
     dispose?: () => void;

package/internal-do-not-import-from-here/ux/aurora/store/TypographyBlueprintManager.d.ts

@@ -1,14 +1,21 @@
-import { TextStyleDefinition, TextStyleSizes, TextStyleType, TypographyBlueprint } from "@omnia/fx-models";
+import { TextStyleDefinition, TypographyBlueprint } from "@omnia/fx-models";
+interface BreakpointScale {
+    lg: number;
+    md: number;
+    sm: number;
+}
 export declare function useTypographyBlueprintManager(): {
     typeScale: {
-        createDefinition: (blueprint: TypographyBlueprint, scaleSlot: number) => TextStyleDefinition;
+        createTextStyleDefinition: (blueprint: TypographyBlueprint, scaleSlots: BreakpointScale) => TextStyleDefinition;
     };
-    definition: {
-        updateAllFromTypeScale(blueprint: TypographyBlueprint): TypographyBlueprint;
-        updateFromBaseStyles(definition: TextStyleDefinition, type: TextStyleType, size: TextStyleSizes, blueprint: TypographyBlueprint): TextStyleDefinition;
+    textStyledefinition: {
+        createAll(blueprint: TypographyBlueprint): TypographyBlueprint;
+        update(definition: TextStyleDefinition, blueprint: TypographyBlueprint): TextStyleDefinition;
+        strip(definition: TextStyleDefinition): TextStyleDefinition;
     };
     blueprint: {
-        initScale(blueprint: TypographyBlueprint): TypographyBlueprint;
+        initFromScale(blueprint: TypographyBlueprint): TypographyBlueprint;
         strip(blueprint: TypographyBlueprint): TypographyBlueprint;
     };
 };
+export {};

package/internal-do-not-import-from-here/ux/aurora/store/TypographyBlueprintStore.d.ts

@@ -11,6 +11,9 @@ export declare const useTypographyBlueprintStore: () => {
         id: guid;
         availableFonts: TypographyFontDefinition[];
     }, Record<string, import("@omnia/fx-models").IMessageBusTopicPublishSubscriber<any>>>;
+    rules: {
+        isStyleActive: (textStyleType: TextStyleType, size: TextStyleSizes) => boolean;
+    };
     actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
         normalize(blueprint: TypographyBlueprint): TypographyBlueprint;
         setBlueprint(): void;

package/internal-do-not-import-from-here/ux/enterpriseproperties/settings/extendedproperty/ExtendedPropertySettings.d.ts

@@ -1,4 +1,6 @@
+import { DefineSlot } from "@omnia/fx/ux";
 import { ExtendedPropertyEnterprisePropertyDefinition } from "@omnia/fx/models";
+import { VNodeChild } from "vue";
 import * as ux from "@omnia/fx/ux";
 declare const _default: (props: ux.ExtractProps<{
     property: ExtendedPropertyEnterprisePropertyDefinition;
@@ -6,9 +8,11 @@ declare const _default: (props: ux.ExtractProps<{
     styles?: {
         container: import("typestyle/lib/types").NestedCSSProperties;
     };
-}> & {} & {
-    "v-slots"?: {} & Omit<{
+} & DefineSlot<"settings", () => VNodeChild>> & {} & {
+    "v-slots"?: {
+        settings?: () => VNodeChild;
+    } & Omit<{
         default?: import("vue").Slot;
-    }, never>;
-} & {} & Omit<ux.VueComponentBaseProps, "styles" | "property"> & ux.VNodeEvents) => any;
+    }, "settings">;
+} & {} & Omit<ux.VueComponentBaseProps, "styles" | "property" | "slot:settings"> & ux.VNodeEvents) => any;
 export default _default;

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

@@ -323,9 +323,9 @@ declare const _default: {
         hideGroupTypeSelection?: Boolean;
         hideUserTypeSelection?: Boolean;
         hideDynamicGroupSelection?: Boolean;
+        displayIdentityType?: Boolean;
         enableSpecialUser?: ISpecialUserConfiguration;
         showSelectedIdentities?: Boolean;
-        displayIdentityType?: Boolean;
         isClosed?: Boolean;
     }>, "onRemove" | "onDoc$" | "onAdd" | "onCloseDialog"> & {
         onRemove?: (identity: Identity) => any;

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

@@ -35,6 +35,8 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
     hideUserTypeSelection?: boolean;
 } & {
     hideDynamicGroupSelection?: boolean;
+} & {
+    displayIdentityType?: boolean;
 } & {
     identityStore?: IIdentityPickerStore;
 } & {
@@ -52,5 +54,5 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
     "v-slots"?: {} & Omit<{
         default?: import("vue").Slot;
     }, never>;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "filter" | "type" | "top" | "identityStore" | "disabled" | "location" | "modelValue" | "v-model" | "emit:update:modelValue" | "providerIds" | "emailEnabled" | "permissionEnabled" | "businessProfileId" | "attachToParent" | "keepSelectionMenu" | "disabledIdentities" | "blockedIdentities" | "hideTab" | "hideGroupTypeSelection" | "hideUserTypeSelection" | "hideDynamicGroupSelection" | "enableSpecialUser" | "emit:identityChanged"> & import("@omnia/fx/ux").VNodeEvents) => any;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "filter" | "type" | "top" | "identityStore" | "disabled" | "location" | "modelValue" | "v-model" | "emit:update:modelValue" | "providerIds" | "emailEnabled" | "permissionEnabled" | "businessProfileId" | "attachToParent" | "keepSelectionMenu" | "disabledIdentities" | "blockedIdentities" | "hideTab" | "hideGroupTypeSelection" | "hideUserTypeSelection" | "hideDynamicGroupSelection" | "displayIdentityType" | "enableSpecialUser" | "emit:identityChanged"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

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

@@ -55,6 +55,8 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
     hideUserTypeSelection?: boolean;
 } & {
     hideDynamicGroupSelection?: boolean;
+} & {
+    displayIdentityType?: boolean;
 } & {
     identityStore?: IIdentityPickerStore;
 } & {
@@ -72,5 +74,5 @@ declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
     "v-slots"?: {} & Omit<{
         default?: import("vue").Slot;
     }, never>;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "filter" | "label" | "type" | "top" | "variant" | "identityStore" | "required" | "multiple" | "dense" | "disabled" | "modelValue" | "v-model" | "emit:update:modelValue" | "description" | "ariaInvalid" | "ariaDescribedby" | "providerIds" | "emailEnabled" | "permissionEnabled" | "businessProfileId" | "singleLine" | "attachToParent" | "keepSelectionMenu" | "showCurrentUserOption" | "autoOpenSelection" | "disabledIdentities" | "blockedIdentities" | "emit:menuToggle" | "hideTab" | "hideGroupTypeSelection" | "hideUserTypeSelection" | "hideDynamicGroupSelection" | "enableSpecialUser"> & import("@omnia/fx/ux").VNodeEvents) => any;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "filter" | "label" | "type" | "top" | "variant" | "identityStore" | "required" | "multiple" | "dense" | "disabled" | "modelValue" | "v-model" | "emit:update:modelValue" | "description" | "ariaInvalid" | "ariaDescribedby" | "providerIds" | "emailEnabled" | "permissionEnabled" | "businessProfileId" | "singleLine" | "attachToParent" | "keepSelectionMenu" | "showCurrentUserOption" | "autoOpenSelection" | "disabledIdentities" | "blockedIdentities" | "emit:menuToggle" | "hideTab" | "hideGroupTypeSelection" | "hideUserTypeSelection" | "hideDynamicGroupSelection" | "displayIdentityType" | "enableSpecialUser"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/journey/selection/JourneySelect.d.ts

@@ -1,7 +1,7 @@
 import { DefineEmit, DefineProp, DefinePropTheming, DefineSlot, DefineVModel, JourneySelectItem, JourneySelectPropertyMapping, useJourneySelectStore } from "@omnia/fx/ux";
 import { VNodeChild } from "vue";
 import { ActionDefinition } from "@omnia/fx-models";
-type BaseProps<TItem> = DefinePropTheming & DefineVModel<"", Array<any> | any> & DefineProp<"getApi", (store: ReturnType<typeof useJourneySelectStore>) => void, false, null, "callback to get a reference to the store"> & DefineProp<"items", Array<TItem>, false, null, "Items to select from"> & DefineProp<"toned", boolean, false, null, "Sets the component to toned"> & DefineProp<"multiple", boolean, false, null, "If it is allowed to select multiple or single"> & DefineProp<"propertyValueMapping", JourneySelectPropertyMapping<TItem>, false, null, "Property value mappings"> & DefineProp<"returnSelectionAsObject", boolean, false, null, "Changes the selection behavior to return the object directly rather than the value specified with item-value"> & DefineProp<"label", string, null, null, "The label of the component"> & DefineProp<"labelAdd", string, null, null, "The add label of the component"> & DefineProp<"titleAdd", string, null, null, "The add title of the add blade"> & DefineProp<"titleEdit", string, null, null, "The edit title of the edit blade"> & DefineProp<"disableSearch", boolean, false, null, "Disables the automatic search"> & DefineProp<"disableSave", boolean, false, null, "If it is allowed save"> & DefineProp<"sortable", boolean, false, null, "If it is allowed to sort"> & DefineProp<"readonly", boolean, false, null, "Disable add and delete"> & DefineProp<"list", boolean, false, null, "Always render the items as a list"> & DefineProp<"confirmDelete", boolean, false, null, "If you confirm before delete from the items"> & DefineProp<"noAddConfirm", boolean, false, null, "If items are added without a save button"> & DefineProp<"bladelessAdd", boolean, false, null, "If addis not a blade and only fires events"> & DefineProp<"bladeless", boolean, false, null, "If add/edit is not a blade and only fires events"> & DefineProp<"actions", ActionDefinition[], false, null, "Actions to display in the blade header"> & DefineProp<"itemSettingable", (item: TItem) => boolean, false, null, "Item has settings or not."> & DefineSlot<"selectionItemRender", (item: JourneySelectItem<any>, index: number, isSelected: boolean) => VNodeChild> & DefineSlot<"selectionRender", () => VNodeChild> & DefineSlot<"selectedItemRenderer", (item: JourneySelectItem<any>, index: number) => VNodeChild> & DefineSlot<"settingsRender", (item: JourneySelectItem<any>, index: number) => VNodeChild> & DefineSlot<"actions", () => VNodeChild> & DefineEmit<"showAdd", () => true> & DefineEmit<"showEdit", (item: TItem, index: number) => true> & DefineEmit<"search", (searchText: string) => true> & DefineEmit<"click:clear", () => true> & DefineEmit<"click:add", (item: Array<TItem> | TItem) => true> & DefineEmit<"click:update", (item: TItem, index: number) => true> & DefineEmit<"click:delete", (item: TItem, index: number) => true>;
+type BaseProps<TItem> = DefinePropTheming & DefineVModel<"", Array<any> | any> & DefineProp<"getApi", (store: ReturnType<typeof useJourneySelectStore>) => void, false, null, "callback to get a reference to the store"> & DefineProp<"items", Array<TItem>, false, null, "Items to select from"> & DefineProp<"toned", boolean, false, null, "Sets the component to toned"> & DefineProp<"multiple", boolean, false, null, "If it is allowed to select multiple or single"> & DefineProp<"propertyValueMapping", JourneySelectPropertyMapping<TItem>, false, null, "Property value mappings"> & DefineProp<"returnSelectionAsObject", boolean, false, null, "Changes the selection behavior to return the object directly rather than the value specified with item-value"> & DefineProp<"label", string, null, null, "The label of the component"> & DefineProp<"labelAdd", string, null, null, "The add label of the component"> & DefineProp<"titleAdd", string, null, null, "The add title of the add blade"> & DefineProp<"titleEdit", string, null, null, "The edit title of the edit blade"> & DefineProp<"disableSearch", boolean, false, null, "Disables the automatic search"> & DefineProp<"disableSave", boolean, false, null, "If it is allowed save"> & DefineProp<"sortable", boolean, false, null, "If it is allowed to sort"> & DefineProp<"readonly", boolean, false, null, "Disable add and delete"> & DefineProp<"list", boolean, false, null, "Always render the items as a list"> & DefineProp<"confirmDelete", boolean, false, null, "If you confirm before delete from the items"> & DefineProp<"noAddConfirm", boolean, false, null, "If items are added without a save button"> & DefineProp<"bladelessAdd", boolean, false, null, "If addis not a blade and only fires events"> & DefineProp<"bladeless", boolean, false, null, "If add/edit is not a blade and only fires events"> & DefineProp<"actions", ActionDefinition[], false, null, "Actions to display in the blade header of the selection blade"> & DefineProp<"itemSettingable", (item: TItem) => boolean, false, null, "Item has settings or not."> & DefineProp<"itemDeletable", (item: TItem) => boolean, false, null, "Item can be deleted or not."> & DefineSlot<"selectionItemRender", (item: JourneySelectItem<any>, index: number, isSelected: boolean) => VNodeChild> & DefineSlot<"selectionRender", () => VNodeChild> & DefineSlot<"selectedItemRenderer", (item: JourneySelectItem<any>, index: number) => VNodeChild> & DefineSlot<"settingsRender", (item: JourneySelectItem<any>, index: number) => VNodeChild> & DefineSlot<"actions", () => VNodeChild> & DefineEmit<"showAdd", () => true> & DefineEmit<"showEdit", (item: TItem, index: number) => true> & DefineEmit<"search", (searchText: string) => true> & DefineEmit<"click:clear", () => true> & DefineEmit<"click:add", (item: Array<TItem> | TItem) => true> & DefineEmit<"click:update", (item: TItem, index: number) => true> & DefineEmit<"click:delete", (item: TItem, index: number) => true>;
 declare const _default: <TItem extends unknown = any>(props: import("@omnia/fx/ux").ExtractProps<BaseProps<TItem>> & {
     "onUpdate:modelValue"?: (value: any) => any;
     "onClick:clear"?: () => any;
@@ -21,5 +21,5 @@ declare const _default: <TItem extends unknown = any>(props: import("@omnia/fx/u
     } & Omit<{
         default?: import("vue").Slot;
     }, "actions" | "selectionItemRender" | "selectionRender" | "selectedItemRenderer" | "settingsRender">;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "label" | "actions" | "list" | "multiple" | "colorSchemaType" | "modelValue" | "items" | "readonly" | "slot:actions" | "colors" | "v-model" | "toned" | "emit:update:modelValue" | "emit:search" | "getApi" | "emit:click:clear" | "emit:click:add" | "emit:click:delete" | "sortable" | "labelAdd" | "propertyValueMapping" | "returnSelectionAsObject" | "titleAdd" | "titleEdit" | "disableSearch" | "disableSave" | "confirmDelete" | "noAddConfirm" | "bladelessAdd" | "bladeless" | "itemSettingable" | "slot:selectionItemRender" | "slot:selectionRender" | "slot:selectedItemRenderer" | "slot:settingsRender" | "emit:showAdd" | "emit:showEdit" | "emit:click:update"> & import("@omnia/fx/ux").VNodeEvents) => any;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "label" | "actions" | "list" | "multiple" | "colorSchemaType" | "modelValue" | "items" | "readonly" | "slot:actions" | "colors" | "v-model" | "toned" | "emit:update:modelValue" | "emit:search" | "getApi" | "emit:click:clear" | "emit:click:add" | "emit:click:delete" | "sortable" | "labelAdd" | "propertyValueMapping" | "returnSelectionAsObject" | "titleAdd" | "titleEdit" | "disableSearch" | "disableSave" | "confirmDelete" | "noAddConfirm" | "bladelessAdd" | "bladeless" | "itemSettingable" | "itemDeletable" | "slot:selectionItemRender" | "slot:selectionRender" | "slot:selectedItemRenderer" | "slot:settingsRender" | "emit:showAdd" | "emit:showEdit" | "emit:click:update"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/journey/stores/JourneySelectStore.d.ts

@@ -51,6 +51,7 @@ export declare const useJourneySelectStore: () => {
         selectedItems: {
             all: JourneySelectItem<any>[];
             inEdit: JourneySelectItem<any>[];
+            isDeletable: (item: any) => boolean;
         };
         selectedItem: {
             item: JourneySelectItem<any>;
@@ -92,6 +93,7 @@ export declare const useJourneySelectStore: () => {
         selectedItems: {
             all: JourneySelectItem<any>[];
             inEdit: JourneySelectItem<any>[];
+            isDeletable: (item: any) => boolean;
         };
         selectedItem: {
             item: JourneySelectItem<any>;

package/internal-do-not-import-from-here/ux/oxide/selection/Selection.d.ts

@@ -1,7 +1,7 @@
 import { DefineEmit, DefineProp, DefinePropTheming, DefineSlot, ItemValueType } from "@omnia/fx/ux";
 import { VNodeChild } from "vue";
 import { OMultiSelectionStyles } from "@omnia/fx-models";
-type SelectionVariants = "remove" | "settings";
+type SelectionVariants = "remove" | "settings" | "readonly";
 type BaseProps<TItem> = DefinePropTheming & DefineProp<"items", TItem[], false, null, "TItem must be an array of objects or array of strings. When using objects, will look for a title, value and disabled keys. This can be changed using the item-title, item-value and item-disabled props."> & DefineProp<"variant", SelectionVariants, false, null, "The component variants"> & DefineProp<"toned", boolean, false, null, "Sets the component to toned"> & DefineProp<"sorting", boolean, false, null, "Sets the component to sorting mode"> & DefineProp<"itemValue", ItemValueType<TItem>, false, null, "Property on supplied items that contains its value."> & DefineProp<"itemTitle", ItemValueType<TItem>, false, null, "Property on supplied items that contains its title."> & DefineProp<"itemSubtitle", string, false, null, "Property on supplied items that contains its value."> & DefineProp<"itemIcon", string, false, null, "Property on supplied items that contains its value."> & DefineProp<"enableAdd", boolean, false, null, "If add button is shown"> & DefineProp<"selectionStyle", OMultiSelectionStyles, false, null, "The style of multi select"> & DefineProp<"itemSettingable", (item: TItem) => boolean, false, null, "Item has settings or not."> & DefineSlot<"item", (item: TItem, index: Number) => VNodeChild> & DefineEmit<"selectItem", (index: any) => true> & DefineEmit<"sort:update", (items: TItem[]) => true> & DefineEmit<"addItem", () => true>;
 declare const _default: <TItem extends unknown>(props: import("@omnia/fx/ux").ExtractProps<BaseProps<TItem>> & {
     onSelectItem?: (index: any) => any;

package/internal-do-not-import-from-here/ux/properties/builtins/phone-number/PhoneNumberConfiguration.d.ts

@@ -0,0 +1,7 @@
+import { IPropertyConfigurationRenderer, PhoneNumberPropertyDefinition } from "@omnia/fx-models";
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<IPropertyConfigurationRenderer<PhoneNumberPropertyDefinition>> & {} & {
+    "v-slots"?: {} & Omit<{
+        default?: import("vue").Slot;
+    }, never>;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, keyof IPropertyConfigurationRenderer<PhoneNumberPropertyDefinition>> & import("@omnia/fx/ux").VNodeEvents) => any;
+export default _default;

package/internal-do-not-import-from-here/ux/properties/builtins/phone-number/PhoneNumberEditor.d.ts

@@ -1,69 +1,21 @@
 import { PhoneDisplaySettings, PhoneEditorSettings, PhoneNumberPropertyValue } from "@omnia/fx-models";
-declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-        modelValue: import("vue").Prop<PhoneNumberPropertyValue, PhoneNumberPropertyValue>;
-        editorSettings: import("vue").Prop<PhoneEditorSettings, PhoneEditorSettings>;
-        displaySettings: import("vue").Prop<PhoneDisplaySettings, PhoneDisplaySettings>;
-        setupSettings?: import("vue").Prop<never, never>;
-        disabled?: import("vue").Prop<boolean, boolean>;
-        "v-model": import("vue").Prop<PhoneNumberPropertyValue, PhoneNumberPropertyValue>;
-        onVnodeBeforeMount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-        onVnodeMounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-        onVnodeBeforeUpdate?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
-        onVnodeUpdated?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
-        onVnodeBeforeUnmount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-        onVnodeUnmounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-    }>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{
-        modelValue: import("vue").Prop<PhoneNumberPropertyValue, PhoneNumberPropertyValue>;
-        editorSettings: import("vue").Prop<PhoneEditorSettings, PhoneEditorSettings>;
-        displaySettings: import("vue").Prop<PhoneDisplaySettings, PhoneDisplaySettings>;
-        setupSettings?: import("vue").Prop<never, never>;
-        disabled?: import("vue").Prop<boolean, boolean>;
-        "v-model": import("vue").Prop<PhoneNumberPropertyValue, PhoneNumberPropertyValue>;
-        onVnodeBeforeMount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-        onVnodeMounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-        onVnodeBeforeUpdate?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
-        onVnodeUpdated?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
-        onVnodeBeforeUnmount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-        onVnodeUnmounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-    }>>, {}, {}, {}, {}, {}>;
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    modelValue: import("vue").Prop<PhoneNumberPropertyValue, PhoneNumberPropertyValue>;
-    editorSettings: import("vue").Prop<PhoneEditorSettings, PhoneEditorSettings>;
-    displaySettings: import("vue").Prop<PhoneDisplaySettings, PhoneDisplaySettings>;
-    setupSettings?: import("vue").Prop<never, never>;
-    disabled?: import("vue").Prop<boolean, boolean>;
-    "v-model": import("vue").Prop<PhoneNumberPropertyValue, PhoneNumberPropertyValue>;
-    onVnodeBeforeMount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-    onVnodeMounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-    onVnodeBeforeUpdate?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
-    onVnodeUpdated?: import("vue").Prop<((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]>;
-    onVnodeBeforeUnmount?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-    onVnodeUnmounted?: import("vue").Prop<((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[], ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]>;
-}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{} & {
-        disabled?: boolean;
-        modelValue?: PhoneNumberPropertyValue;
-        onVnodeBeforeMount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
-        onVnodeMounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
-        onVnodeBeforeUpdate?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
-        onVnodeUpdated?: ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[];
-        onVnodeBeforeUnmount?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
-        onVnodeUnmounted?: ((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[];
-        "v-model"?: PhoneNumberPropertyValue;
-        displaySettings?: PhoneDisplaySettings;
-        setupSettings?: never;
-        editorSettings?: PhoneEditorSettings;
-    }>, never>;
-};
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<{
+    "emit:update:modelValue": (value: PhoneNumberPropertyValue) => void;
+} & {
+    "v-model"?: PhoneNumberPropertyValue;
+} & {
+    modelValue?: PhoneNumberPropertyValue;
+} & {
+    displaySettings?: PhoneDisplaySettings;
+} & {
+    editorSettings?: PhoneEditorSettings;
+} & {
+    disabled?: boolean;
+}> & {
+    "onUpdate:modelValue"?: (value: PhoneNumberPropertyValue) => any;
+} & {
+    "v-slots"?: {} & Omit<{
+        default?: import("vue").Slot;
+    }, never>;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "disabled" | "modelValue" | "v-model" | "emit:update:modelValue" | "displaySettings" | "editorSettings"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

package/internal-do-not-import-from-here/ux/properties/property-cover/PropertyCover.d.ts

@@ -1,11 +1,12 @@
 import { DefineSlot } from "@omnia/fx/ux";
 import { VNodeChild } from "vue";
-declare const _default: (props: import("@omnia/fx/ux").ExtractProps<DefineSlot<"display", (elementConfig: VNodeChild) => VNodeChild> & DefineSlot<"edit", (elementConfig: VNodeChild) => VNodeChild>> & {} & {
+declare const _default: (props: import("@omnia/fx/ux").ExtractProps<DefineSlot<"display", (elementConfig: VNodeChild) => VNodeChild> & DefineSlot<"edit", (elementConfig: VNodeChild) => VNodeChild> & DefineSlot<"setup", (elementConfig: VNodeChild) => VNodeChild>> & {} & {
     "v-slots"?: {
         display?: (elementConfig: VNodeChild) => VNodeChild;
         edit?: (elementConfig: VNodeChild) => VNodeChild;
+        setup?: (elementConfig: VNodeChild) => VNodeChild;
     } & Omit<{
         default?: import("vue").Slot;
-    }, "display" | "edit">;
-} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "slot:display" | "slot:edit"> & import("@omnia/fx/ux").VNodeEvents) => any;
+    }, "display" | "setup" | "edit">;
+} & {} & Omit<import("@omnia/fx/ux").VueComponentBaseProps, "slot:display" | "slot:edit" | "slot:setup"> & import("@omnia/fx/ux").VNodeEvents) => any;
 export default _default;

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

@@ -431,7 +431,7 @@ import wc287d666180644ba5ab5def0471a75a89 from './ux/aurora/components/textstyle
 import wc252ece0016594978b3ddfafdd59adda4 from './ux/aurora/components/themepicker/ThemePicker';
 import wc73e1c232690249f78967e3e3f6d92bd7 from './ux/aurora/components/themepreview/ThemePreview';
 import wcc6eec07d48af435ab0c75195d9c7dcfc from './ux/aurora/components/themepreview/ComponentPreview';
-import wc99a73153b5c647da9d6de517f51e53f0 from './ux/aurora/components/typography/TypographyEditor';
+import wc99a73153b5c647da9d6de517f51e53f0 from './ux/aurora/components/typography/TextStyleEditor';
 import wc2f742a14a560434abb899360a69c314b from './ux/aurora/components/typography/TypographyBlueprintsViewer';
 import wc49703cb13c254c5b8eb30bd1a3eaf431 from './ux/aurora/components/typography/TypographyBlueprintPicker';
 import wc6bcccc7dd1c74fe591a660641ac62cd7 from './ux/aurora/components/viewtemplatepicker/ViewTemplatePicker';
@@ -504,6 +504,7 @@ import wc784d162feec24424a993d8ba812b9c94 from './ux/properties/builtins/multili
 import wc4abd8ef8e96f4beca6d375984132b6ec from './ux/properties/builtins/multilingualText/MultilingualTextEditor';
 import wcae83e3f39ff443b8abb93e483c14f48f from './ux/properties/builtins/phone-number/PhoneNumberDisplay';
 import wcaad7c8da16f04a46b9503564b10a8f34 from './ux/properties/builtins/phone-number/PhoneNumberEditor';
+import wc7d02c7f4a383469b8ab4d2e196735ef9 from './ux/properties/builtins/phone-number/PhoneNumberConfiguration';
 import wc13f465ea57024a47ae66d4bf1d927974 from './ux/properties/builtins/tags/TagsDisplay';
 import wc4fc24b6b58014b5f9a3474a8f5cc4f00 from './ux/properties/builtins/tags/TagsEditor';
 import wcdf429c59a8ec42cf8ec34907705793a9 from './ux/properties/builtins/text/TextDisplay';
@@ -1437,6 +1438,13 @@ declare global {
                         $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
                     };
                 } : typeof wc287d666180644ba5ab5def0471a75a89;
+                "editor": typeof wc99a73153b5c647da9d6de517f51e53f0 extends {
+                    propsDefinition: infer TProp;
+                } ? {
+                    new (...args: any[]): {
+                        $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
+                    };
+                } : typeof wc99a73153b5c647da9d6de517f51e53f0;
             };
         };
         "boolean": {
@@ -3925,6 +3933,13 @@ declare global {
                             $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
                         };
                     } : typeof wcaad7c8da16f04a46b9503564b10a8f34;
+                    "configuration": typeof wc7d02c7f4a383469b8ab4d2e196735ef9 extends {
+                        propsDefinition: infer TProp;
+                    } ? {
+                        new (...args: any[]): {
+                            $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
+                        };
+                    } : typeof wc7d02c7f4a383469b8ab4d2e196735ef9;
                 };
             };
             "tags": {
@@ -4229,13 +4244,6 @@ declare global {
             } : typeof wcb4ddcf67388c4aa494cad4fa07ff8937;
         };
         "typography": {
-            "editor": typeof wc99a73153b5c647da9d6de517f51e53f0 extends {
-                propsDefinition: infer TProp;
-            } ? {
-                new (...args: any[]): {
-                    $props: TProp & Omit<VueComponentBaseProps, keyof TProp>;
-                };
-            } : typeof wc99a73153b5c647da9d6de517f51e53f0;
             "viewer": typeof wc2f742a14a560434abb899360a69c314b extends {
                 propsDefinition: infer TProp;
             } ? {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx",
   "license": "MIT",
-  "version": "8.0.404-dev",
+  "version": "8.0.406-dev",
   "description": "Provide Omnia Fx typings and tooling for clientside Omnia development.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -20,7 +20,7 @@
   ],
   "author": "Omnia Digital Workplace AB",
   "dependencies": {
-    "@omnia/fx-models": "8.0.404-dev",
+    "@omnia/fx-models": "8.0.406-dev",
     "@microsoft/signalr": "6.0.1",
     "broadcast-channel": "4.8.0",
     "dayjs": "1.11.7",

package/internal-do-not-import-from-here/ux/aurora/components/typography/TypographyEditor.d.ts

@@ -1,357 +0,0 @@
-import { TextStyleDefinition } from "@omnia/fx-models";
-import { VNodeChild } from "vue";
-type EditorVariant = "default" | "dialog" | "blade-inline";
-declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-        "v-slots": import("vue").Prop<{
-            default?: import("../../../DefineVueTypings").Slot;
-        } & {
-            activator?: () => VNodeChild;
-        }>;
-        toolbarCallback: {
-            type: import("vue").PropType<(value: () => VNodeChild) => void>;
-        };
-        sampleText: {
-            type: import("vue").PropType<string>;
-        };
-        textStyleType: {
-            type: import("vue").PropType<"display" | "headline" | "title" | "text" | "label" | "variants">;
-        };
-        variant: {
-            type: import("vue").PropType<EditorVariant>;
-        };
-        "onUpdate:modelValue": {
-            type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-        };
-        "v-model": {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        };
-        modelValue: {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        };
-        name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
-            type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-        }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        }; } & {
-            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }>;
-            defaultValue(value?: TextStyleDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }, false>;
-            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }>;
-        };
-    }>> & {
-        "onClick:confirm"?: (model: TextStyleDefinition) => any;
-    }, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-        "click:confirm": (model: TextStyleDefinition) => true;
-    }, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{
-        "v-slots": import("vue").Prop<{
-            default?: import("../../../DefineVueTypings").Slot;
-        } & {
-            activator?: () => VNodeChild;
-        }>;
-        toolbarCallback: {
-            type: import("vue").PropType<(value: () => VNodeChild) => void>;
-        };
-        sampleText: {
-            type: import("vue").PropType<string>;
-        };
-        textStyleType: {
-            type: import("vue").PropType<"display" | "headline" | "title" | "text" | "label" | "variants">;
-        };
-        variant: {
-            type: import("vue").PropType<EditorVariant>;
-        };
-        "onUpdate:modelValue": {
-            type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-        };
-        "v-model": {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        };
-        modelValue: {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        };
-        name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
-            type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-        }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
-            type: import("vue").PropType<TextStyleDefinition>;
-            required: false;
-        }; } & {
-            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }>;
-            defaultValue(value?: TextStyleDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }, false>;
-            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }>;
-        };
-    }>> & {
-        "onClick:confirm"?: (model: TextStyleDefinition) => any;
-    }, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {}>;
-    __isFragment?: never;
-    __isTeleport?: never;
-    __isSuspense?: never;
-} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    "v-slots": import("vue").Prop<{
-        default?: import("../../../DefineVueTypings").Slot;
-    } & {
-        activator?: () => VNodeChild;
-    }>;
-    toolbarCallback: {
-        type: import("vue").PropType<(value: () => VNodeChild) => void>;
-    };
-    sampleText: {
-        type: import("vue").PropType<string>;
-    };
-    textStyleType: {
-        type: import("vue").PropType<"display" | "headline" | "title" | "text" | "label" | "variants">;
-    };
-    variant: {
-        type: import("vue").PropType<EditorVariant>;
-    };
-    "onUpdate:modelValue": {
-        type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-    };
-    "v-model": {
-        type: import("vue").PropType<TextStyleDefinition>;
-        required: false;
-    };
-    modelValue: {
-        type: import("vue").PropType<TextStyleDefinition>;
-        required: false;
-    };
-    name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
-        type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-    }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
-        type: import("vue").PropType<TextStyleDefinition>;
-        required: false;
-    }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
-        type: import("vue").PropType<TextStyleDefinition>;
-        required: false;
-    }; } & {
-        require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, TextStyleDefinition, {
-            "onUpdate:modelValue": {
-                type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-            };
-        } & {
-            "v-model": {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        } & {
-            modelValue: {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        }>;
-        defaultValue(value?: TextStyleDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, TextStyleDefinition, {
-            "onUpdate:modelValue": {
-                type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-            };
-        } & {
-            "v-model": {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        } & {
-            modelValue: {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        }, false>;
-        doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, TextStyleDefinition, {
-            "onUpdate:modelValue": {
-                type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-            };
-        } & {
-            "v-model": {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        } & {
-            modelValue: {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        }>;
-    };
-}>> & {
-    "onClick:confirm"?: (model: TextStyleDefinition) => any;
-}, () => import("vue/jsx-runtime").JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "click:confirm": (model: TextStyleDefinition) => true;
-}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{} & {
-        name?: {
-            [x: `onUpdate:${string}`]: {
-                type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-            };
-        } & {
-            [x: `v-model:${string}`]: {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        } & {
-            [x: string]: {
-                type: import("vue").PropType<TextStyleDefinition>;
-                required: false;
-            };
-        } & {
-            require(): import("../../../DefineVueTypings").DefinePropModelRequire<string, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }>;
-            defaultValue(value?: TextStyleDefinition): import("../../../DefineVueTypings").DefinePropModelDefaultValue<string, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }, false>;
-            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<string, TextStyleDefinition, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: TextStyleDefinition) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<TextStyleDefinition>;
-                    required: false;
-                };
-            }>;
-        };
-        variant?: EditorVariant;
-        modelValue?: TextStyleDefinition;
-        "v-slots"?: {
-            default?: import("../../../DefineVueTypings").Slot;
-        } & {
-            activator?: () => VNodeChild;
-        };
-        "onUpdate:modelValue"?: (value: TextStyleDefinition) => any | void;
-        "v-model"?: TextStyleDefinition;
-        sampleText?: string;
-        toolbarCallback?: (value: () => VNodeChild) => void;
-        textStyleType?: "display" | "headline" | "title" | "text" | "label" | "variants";
-    }>, "onClick:confirm"> & {
-        "onClick:confirm"?: (model: TextStyleDefinition) => any;
-    };
-};
-export default _default;

package/internal-do-not-import-from-here/ux/aurora/components/typography/store/TypographyEditorStore.d.ts

@@ -1,63 +0,0 @@
-import { FontAwesomeIcon, TextStyleBreakPoint, TextStyleDefinition } from "@omnia/fx-models";
-export interface BreakpointItem {
-    icon: FontAwesomeIcon;
-    title: string;
-    active: boolean;
-    breakpoint: "sm" | "md" | "lg";
-}
-export declare const useTypographyEditorStore: () => {
-    state: {
-        internalModel: TextStyleDefinition;
-        breakpoint: {
-            large: TextStyleBreakPoint;
-            medium: TextStyleBreakPoint;
-            small: TextStyleBreakPoint;
-        };
-        selectedBreakpoint: BreakpointItem;
-        settings: {
-            textStyleType: "display" | "headline" | "title" | "text" | "label" | "variants";
-        };
-    };
-    actions: import("@omnia/fx/stores").StoreReturnDefineAction<{
-        set: () => {
-            fontSize: (value: number) => void;
-            lineHeight: (value: number) => void;
-            fontWeight: (value: number) => void;
-            letterSpacing: (value: number) => void;
-        };
-        breakPoint: () => {
-            selected: {
-                enable: (value: boolean) => void;
-                set: {
-                    custom: (value: boolean) => void;
-                };
-            };
-            clean: (key: string) => void;
-            ensure: (key: string) => void;
-        };
-        initState: (model: TextStyleDefinition) => void;
-    }>;
-    get: {
-        selection: {
-            breakpoint: {
-                readonly definition: TextStyleBreakPoint;
-            };
-        };
-    };
-    rules: {
-        readonly showEnableBreakpoint: boolean;
-        show: {
-            readonly customSizeSwitch: boolean;
-            readonly name: boolean;
-            readonly upperCaseAndItalicSettings: boolean;
-            readonly fontSizeAndLineHeight: boolean;
-            readonly letterSpacing: boolean;
-            readonly fontWeight: boolean;
-        };
-    };
-    dataTypes: {
-        breakpoints: BreakpointItem[];
-    };
-} & {
-    dispose?: () => void;
-};