@omnia/fx 7.0.497-dev → 7.0.499-dev

package/internal-do-not-import-from-here/ux/app/management/tabs/templates/tabs/CustomSteps.d.ts

@@ -1,7 +1,6 @@
-import { AppProvisioningStepInfo, AppProvisioningStepRegistration, AppTemplate, MultilingualString } from "@omnia/fx-models";
+import { AppProvisioningStepInfo, AppProvisioningStepRegistration, AppTemplate } from "@omnia/fx-models";
 export interface StepViewModel extends AppProvisioningStepRegistration {
     info: AppProvisioningStepInfo;
-    inputTitle?: MultilingualString;
     checked?: boolean;
 }
 declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<{

package/internal-do-not-import-from-here/ux/appprovisioning/components/AppProvisioningComponentBase.d.ts

@@ -1,6 +1,6 @@
 import { AppInstanceCreateInfo, AppInstance, GuidValue, AppTemplate, AppProvisioningStepContext, AppDefinition, AppProvisioningStepInfo, AppProvisioningHandlerMessage, IMessageBusSubscriptionHandler, AppProvisioningStepRegistration, InformationSummaryRenderer } from "../../../models";
 import { SubscriptionHandler } from "../../..";
-import { AppStore, DirectionRuleStore, EnterprisePropertyStore, FeatureStore, TargetingPropertyStore } from "../../../stores";
+import { AppStore, DirectionRuleStore, EnterprisePropertyStore, FeatureStore, MultilingualStore, TargetingPropertyStore } from "../../../stores";
 import { VueComponentBase, OmniaTheming, OmniaUxLocalization } from "../..";
 import { AppService, LocalizationService } from "../../../services";
 export interface IAppProvisioningComponentProps {
@@ -31,6 +31,7 @@ export declare abstract class AppProvisioningComponentBase<Props = IAppProvision
     protected appService: AppService;
     protected targetingPropertyStore: TargetingPropertyStore;
     protected directionStore: DirectionRuleStore;
+    protected multilingualStore: MultilingualStore;
     private omniaContext;
     protected subscriptionHandler: SubscriptionHandler;
     registerAppProvisioningStepsSubscriptionHandler: IMessageBusSubscriptionHandler;

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

@@ -18,6 +18,8 @@ export interface IdentitiesLocalization {
             EditRule: string;
             UserType: string;
             DisplayName: string;
+            ErrorNoRules: string;
+            EmptyRuleValue: string;
         };
     };
     BuiltInProperty: {

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

@@ -8,7 +8,9 @@ export interface OmniaAuthProviderClient {
 export interface OmniaAuthProviderContext {
     uniqueName: string;
     redirectUrl: string;
+    hasOtherWaysToLogin: boolean;
     showError: () => void;
+    openSelections: () => void;
 }
 export interface OmniaAuthProviderChainAction {
     (result: AuthenticationSessionResult): void;

package/internal-do-not-import-from-here/ux/signin/SignInBlock.css.d.ts

@@ -6,7 +6,7 @@ declare const _default: {
     container: {
         color: "#fff";
         minHeight: string;
-        width: string;
+        maxWidth: string;
         backgroundColor: "#2323236b";
         borderRadius: string;
         backdropFilter: "blur(10px) saturate(160%)";

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

@@ -1,7 +1,6 @@
 export declare module SignInLocalization {
     const namespace = "Omnia.SignIn";
     interface locInterface {
-        HowToLogin: string;
         Login: string;
         SendMagicLink: string;
         MagicLinkValidMessage: string;
@@ -26,5 +25,14 @@ export declare module SignInLocalization {
             };
         };
         GenericError: string;
+        UseAnotherAccount: string;
+        OtherWaysToLogin: string;
+        ForgotPassword: string;
+        Email: string;
+        Send: string;
+        Retry: string;
+        SendResetPasswordMessage: string;
+        SentResetPasswordMessage: string;
+        RetryResetPasswordWarning: string;
     }
 }

package/internal-do-not-import-from-here/ux/signin/omnia/providers/OtpProvider.d.ts

@@ -1,4 +1,4 @@
-import { OmniaAuthProviderClient, OmniaAuthProviderContext, OmniaAuthProviderChainAction } from "../../Shared";
+import { OmniaAuthProviderChainAction, OmniaAuthProviderClient, OmniaAuthProviderContext } from "../../Shared";
 export declare const useProvider: () => OmniaAuthProviderClient;
 export declare const OneTimePasswordProvider: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<{
     context: OmniaAuthProviderContext;

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

@@ -1,8 +1,10 @@
 import { IValidator } from "../validation";
 export declare function useValidator(breakInheritValidator?: boolean): IValidator;
 export declare function useValidation(): {
-    vueInstance: any;
     validate: () => boolean;
     addValidation: (validation: any) => void;
     clearValidation: (validation: any) => void;
 };
+export interface InternalVueValidationInstance {
+    __validationInstance: ReturnType<typeof useValidation>;
+}

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

@@ -4,6 +4,7 @@ export declare class FormValidator implements IValidator {
     private components;
     constructor(component?: VueComponentBase<any>);
     register: (component: VueComponentBase<any>) => void;
+    unregister(component: VueComponentBase<any>): void;
     validateAll: (isAutoScroll?: boolean) => boolean;
     clearValidation: () => void;
 }

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

@@ -1,6 +1,7 @@
 import { VueComponentBase } from "./../VueComponentBase";
 export interface IValidator {
     register: (component: VueComponentBase<any>) => void;
+    unregister(component: VueComponentBase<any>): void;
     validateAll: (isAutoScroll?: boolean) => boolean;
     clearValidation: () => void;
 }

package/internal-do-not-import-from-here/ux/velcron/core/models/VelcronDefinitions.d.ts

@@ -18,12 +18,13 @@ export interface BuiltInComponentRenderers {
     "WebView": any;
     "CustomComponent": any;
     "Dialog": any;
-    "Section": any;
+    "FlexView": any;
     "Icon": any;
 }
 export type DynamicViewModel = object;
 export interface OnItemRenderedHookResult {
-    cssClass: Object;
+    cssClass?: Object;
+    containerRenderer?: VelcronContainerRenderer;
 }
 export interface VelcronRenderContext {
     id?: string;
@@ -47,6 +48,11 @@ export interface VelcronRenderContextHooks {
     onItemSelected?: ((item: VelcronDefinition) => void);
     onItemRendered?: ((item: VelcronDefinition) => OnItemRenderedHookResult);
 }
+export interface VelcronContainerRenderer {
+    definition: VelcronDefinition;
+    renderContext: VelcronRenderContext;
+    component: JSX.Element;
+}
 export interface VelcronAction extends VelcronRenderContext {
     type: VelcronActionTypes;
 }
@@ -160,7 +166,8 @@ export interface VelcronImageDefinition extends VelcronDefinition {
 export interface VelcronButtonDefinition extends VelcronDefinition {
     type: "Button";
     text: string;
-    icon: VelcronIcon;
+    icon?: VelcronIcon;
+    disabled?: boolean;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronTextInputDefinition extends VelcronDefinition {
@@ -191,15 +198,14 @@ export interface VelcronIconDefinition extends VelcronDefinition {
     size?: number;
     events?: VelcronOnPressEvent;
 }
-export interface VelcronSectionDefinition extends VelcronDefinition {
-    type: "Section";
-    columns: Array<VelcronSectionColumn>;
-    columnStyle?: object;
-}
-export interface VelcronSectionColumn extends VelcronDefinition {
+export interface VelcronFlexViewDefinition extends VelcronDefinition {
+    type: "FlexView";
+    column?: boolean;
     body: Array<VelcronDefinition>;
+    columnStyle?: object;
     horizontalAlignment?: VelcronHorizontalAlignments;
     verticalAlignment?: VerticalAlignments;
+    grow?: number;
     width?: "auto" | "stretch" | number | string;
 }
 export interface VelcronSectionColumnWidth {

package/internal-do-not-import-from-here/ux/velcron/core/models/VelcronDescriptors.d.ts

@@ -24,6 +24,7 @@ export interface VelcronComponentPropertyDescriptor {
     editor?: VelcronComponentPropertyEditors;
     required?: boolean;
     defaultValue?: VelcronPrimitiveType | VelcroncomponentArrayType;
+    disableRemovePropertyOnEmptyOrFalse?: boolean;
 }
 export interface VelcronComponentArrayPropertyDescriptor extends VelcronComponentPropertyDescriptor {
     type: VelcronDataTypes.componentArray;

package/internal-do-not-import-from-here/ux/velcron/core/parser/VelcronConstants.d.ts

@@ -10,7 +10,7 @@ export declare const VelcronConstants: {
         progressCircle: string;
         webView: string;
         dialog: string;
-        section: string;
+        flexView: string;
         icon: string;
     };
     events: {

package/internal-do-not-import-from-here/ux/velcron/core/parser/VelcronStyles.d.ts

@@ -1,8 +1,9 @@
-import { VelcronDefinition, VelcronSectionDefinition, VelcronSectionColumn, VelcronRenderContext } from "../models";
+import { VelcronDefinition, VelcronRenderContext } from "../models";
 export declare class VelcronStyles {
-    static component(definition: VelcronDefinition, renderCtx: VelcronRenderContext): any;
+    static create(definition: VelcronDefinition, renderCtx: VelcronRenderContext): any;
+    private static createStylesForText;
+    private static createStylesForImage;
+    private static createStylesForFlexbox;
+    private static createStylesForLayoutColumnComponent;
     private static dataBindStyles;
-    static section(sectionDef: VelcronSectionDefinition, renderCtx: VelcronRenderContext): any;
-    static layoutColumn(layoutDef: VelcronSectionDefinition, columnDef: VelcronSectionColumn, renderCtx: VelcronRenderContext): object;
-    static layoutColumnComponent(layoutDef: VelcronSectionDefinition, columnDef: VelcronSectionColumn, renderCtx: VelcronRenderContext): object;
 }

package/internal-do-not-import-from-here/ux/velcron/editor/components/ContainerRenderer.d.ts

@@ -0,0 +1,3 @@
+import { VelcronContainerRenderer } from "../../core";
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<VelcronContainerRenderer, never>, any, any, any>;
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/components/ContainerRendererStyles.d.ts

@@ -0,0 +1,3 @@
+export declare const ContainerRenderStyles: {
+    item: string;
+};

package/internal-do-not-import-from-here/ux/velcron/editor/components/pickers/ColorPicker.css.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    container: {
+        fontSize: number;
+    };
+};
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/components/pickers/ColorPicker.d.ts

@@ -0,0 +1,48 @@
+interface ColorPickerData {
+}
+declare const _default: (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd"), {}, import("vue-tsx-support").PropsForOutside<{
+    required: boolean;
+    data: ColorPickerData | {
+        title: string;
+    };
+    styles: {
+        container: {
+            fontSize: number;
+        };
+    };
+}, "required">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        required: boolean;
+        data: ColorPickerData | {
+            title: string;
+        };
+        styles: {
+            container: {
+                fontSize: number;
+            };
+        };
+    }, "required">;
+}) | (import("vue").VueConstructor<import("vue-tsx-support")._TsxComponentInstanceV3<import("vue/types/umd") & import("vue").ShallowUnwrapRef<() => VueTsxSupport.JSX.Element>, {}, import("vue-tsx-support").PropsForOutside<{
+    required: boolean;
+    data: ColorPickerData | {
+        title: string;
+    };
+    styles: {
+        container: {
+            fontSize: number;
+        };
+    };
+}, "required">, any, any, any>> & {
+    propsDefinition: import("vue-tsx-support").PropsForOutside<{
+        required: boolean;
+        data: ColorPickerData | {
+            title: string;
+        };
+        styles: {
+            container: {
+                fontSize: number;
+            };
+        };
+    }, "required">;
+});
+export default _default;

package/internal-do-not-import-from-here/ux/velcron/editor/models/BuiltInDescriptors.d.ts

@@ -1,4 +1,4 @@
-import { VelcronDataTypes, VelcronDescriptor, VelcronDescriptorTypes, VelcronComponentEventDescriptor, VelcronComponentDescriptor, VelcronSubComponentDescriptor } from "../../core";
+import { VelcronDataTypes, VelcronDescriptor, VelcronDescriptorTypes, VelcronComponentEventDescriptor, VelcronComponentDescriptor } from "../../core";
 export interface VelcronDataMemberDescriptor extends VelcronDescriptor {
     descriptorType: VelcronDescriptorTypes.dataMember;
     dataType: VelcronDataTypes;
@@ -29,5 +29,4 @@ export declare const VelcronProgressCircleComponentDescriptor: VelcronComponentD
 export declare const VelcronViewComponentDescriptor: VelcronComponentDescriptor;
 export declare const VelcronDialogComponentDescriptor: VelcronComponentDescriptor;
 export declare const VelcronIconComponentDescriptor: VelcronComponentDescriptor;
-export declare const VelcronSectionColumnComponentDescriptor: VelcronSubComponentDescriptor;
 export declare const VelcronSectionComponentDescriptor: VelcronComponentDescriptor;

package/internal-do-not-import-from-here/ux/velcron/editor/stores/VelcronEditorStore.d.ts

@@ -6,6 +6,7 @@ export declare class VelcronEditorStore extends Store {
     appData: import("@omnia/fx/stores").StoreState<object>;
     app: import("@omnia/fx/stores").StoreState<VelcronAppDefinition>;
     appCacheKey: import("@omnia/fx/stores").StoreState<string>;
+    appTreeOpenIds: import("@omnia/fx/stores").StoreState<string[]>;
     appTree: import("@omnia/fx/stores").StoreState<AppTreeItem[]>;
     editorMode: import("@omnia/fx/stores").StoreState<editorModes>;
     selectedAppTreeItem: import("@omnia/fx/stores").StoreState<AppTreeItem>;
@@ -37,7 +38,7 @@ export declare class VelcronEditorStore extends Store {
         codeEditorTab: (newState: codeEditorTabs) => void;
         editorMode: (newState: editorModes) => void;
         syncState: () => void;
-        setSelectedAppTreeItem: (appTreeItem: AppTreeItem) => void;
+        setSelectedAppTreeItem: (key: string) => void;
         showAddComponent: (show: boolean) => void;
         showShare: (show: boolean) => void;
         showAddDataObject: (show: boolean) => void;
@@ -56,6 +57,7 @@ export declare class VelcronEditorStore extends Store {
      * Implementation of actions
      */
     actions: {};
+    private getTreeItemNode;
     private buildUiTree;
     private buildDataMembersRecursive;
     private buildDefinitionTreeRecursive;

package/internal-do-not-import-from-here/ux/velcron/renderer/VelcronRenderer.css.d.ts

@@ -2,6 +2,8 @@
  * Styles for the VelcronRenderer component
  */
 declare const _default: {
-    container: {};
+    container: {
+        width: string;
+    };
 };
 export default _default;

package/internal-do-not-import-from-here/ux/velcron/renderer/components/{Section.d.ts → FlexView.d.ts}

@@ -1,3 +1,3 @@
-import { VelcronRenderProps, VelcronSectionDefinition } from "../../core";
-declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<VelcronRenderProps<VelcronSectionDefinition>, never>, any, any, any>;
+import { VelcronRenderProps, VelcronFlexViewDefinition } from "../../core";
+declare const _default: import("vue-tsx-support")._TsxComponentV3<import("vue").default<Record<string, any>, Record<string, any>, never, never, (event: string, ...args: any[]) => import("vue").default<Record<string, any>, Record<string, any>, never, never, any>>, {}, import("vue-tsx-support").PropsForOutside<VelcronRenderProps<VelcronFlexViewDefinition>, never>, any, any, any>;
 export default _default;

package/internal-do-not-import-from-here/ux/velcron/theming/ColorManager.d.ts

@@ -0,0 +1,6 @@
+import { ColorDefinition, ColorGroup } from "./model/ThemeDefinition";
+export declare const ColorManager: () => {
+    getColorDefinition: (color: string, colorToned?: string) => ColorDefinition;
+    createColorSchema: (color: string, name: string, fixedColor?: boolean, colorBlend?: string) => ColorGroup;
+    isDarkColor: (color: any) => boolean;
+};

package/internal-do-not-import-from-here/ux/velcron/theming/ThemeStore.d.ts

@@ -0,0 +1,23 @@
+import { Store } from "@omnia/fx/stores";
+import { ThemeDefinition } from "./model/ThemeDefinition";
+export declare class ThemeStore extends Store {
+    private currentTheme;
+    constructor();
+    onActivated(): void;
+    onDisposing(): void;
+    /**
+    * Implementation of getters
+    */
+    getters: {
+        currentTheme: () => import("@omnia/fx/stores").StoreState<ThemeDefinition>;
+        getColorSchema(name: string): any;
+    };
+    /**
+     * Implementation of mutations
+     */
+    mutations: {};
+    /**
+     * Implementation of actions
+     */
+    actions: {};
+}

package/internal-do-not-import-from-here/ux/velcron/theming/model/ThemeDefinition.d.ts

@@ -0,0 +1,47 @@
+export interface ColorDefinition {
+    dark: boolean;
+    color: string;
+    colorToned: string;
+}
+export interface ColorSchema {
+    name: string;
+    base: ColorDefinition;
+    onBase: ColorDefinition;
+    container: ColorDefinition;
+    onContainer: ColorDefinition;
+}
+export interface ColorGroup {
+    dark: ColorSchema;
+    light: ColorSchema;
+}
+export interface ThemeDefinition {
+    id: string;
+    dark: boolean;
+    primary: ColorSchema;
+    secondary: ColorSchema;
+    tertiary: ColorSchema;
+    neutral: ColorSchema;
+    background: ColorSchema;
+    error: ColorSchema;
+    additional: Array<ColorSchema>;
+}
+export declare const ColorSchemaNames: {
+    primary: string;
+    secondary: string;
+    tertiary: string;
+    neutral: string;
+    background: string;
+    error: string;
+    additional: string;
+};
+export declare enum DefinitionTypes {
+    light = 1,
+    dark = 2,
+    highContrast = 3
+}
+export interface DefinitionGroup extends ThemeDefinition {
+    changeDefinitionType(definitionType: DefinitionTypes): any;
+    getVuetifyTheme(): any;
+    darkDefinition: ThemeDefinition;
+    lightDefinition: ThemeDefinition;
+}

package/internal-do-not-import-from-here/ux/velcron/theming/themes/Colors.d.ts

@@ -0,0 +1,94 @@
+import { ColorSchema } from "../model/ThemeDefinition";
+export declare const SystemColors: {
+    Teal: string;
+    Purple: string;
+    DarkGreen: string;
+    LightGreen: string;
+    DarkBackground: string;
+    LightBackround: string;
+    DarkPink: string;
+    RedBrown: string;
+    Orange: string;
+    Gold: string;
+    Black: string;
+    Grey: string;
+};
+export declare const ColorSchemas: {
+    Teal: ColorSchema;
+    Purple: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    DarkGreen: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    LightGreen: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    DarkBackground: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    LightBackground: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    DarkPink: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    RedBrown: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        component: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    Orange: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    Gold: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    Black: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    Grey: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+    LightBlue: {
+        base: import("../model/ThemeDefinition").ColorDefinition;
+        onBase: import("../model/ThemeDefinition").ColorDefinition;
+        container: import("../model/ThemeDefinition").ColorDefinition;
+        onContainer: import("../model/ThemeDefinition").ColorDefinition;
+    };
+};
+export declare const AppChrome: {
+    Black: import("../model/ThemeDefinition").ColorDefinition;
+    White: import("../model/ThemeDefinition").ColorDefinition;
+};

package/internal-do-not-import-from-here/ux/velcron/theming/themes/Themes.d.ts

@@ -0,0 +1,99 @@
+import { ColorSchema, DefinitionGroup, DefinitionTypes, ThemeDefinition } from "../model/ThemeDefinition";
+export declare class OmniaThemeInstance implements DefinitionGroup, ThemeDefinition {
+    darkDefinition: ThemeDefinition;
+    lightDefinition: ThemeDefinition;
+    currentDefinition: ThemeDefinition;
+    dark: boolean;
+    constructor(lightDefinition: ThemeDefinition, darkDefintion: ThemeDefinition);
+    get id(): string;
+    get primary(): ColorSchema;
+    get secondary(): ColorSchema;
+    get tertiary(): ColorSchema;
+    get neutral(): ColorSchema;
+    get background(): ColorSchema;
+    get error(): ColorSchema;
+    get additional(): Array<ColorSchema>;
+    changeDefinitionType(definitionType: DefinitionTypes): void;
+    protected getVuetifyThemeFromDefinition(themeDefinition: ThemeDefinition): {
+        dark: boolean;
+        colors: {
+            background: string;
+            "on-background": string;
+            surface: string;
+            "on-surface": string;
+            primary: string;
+            "on-primary": string;
+            secondary: string;
+            "on-secondary": string;
+            tertiary: string;
+            "on-tertiary": string;
+            error: string;
+            "on-error": string;
+            info: string;
+            "on-info": string;
+            success: string;
+            "on-success": string;
+            warning: string;
+            "on-warning": string;
+        };
+    };
+    getVuetifyTheme(): {
+        dark: boolean;
+        colors: {
+            background: string;
+            "on-background": string;
+            surface: string;
+            "on-surface": string;
+            primary: string;
+            "on-primary": string;
+            secondary: string;
+            "on-secondary": string;
+            tertiary: string;
+            "on-tertiary": string;
+            error: string;
+            "on-error": string;
+            info: string;
+            "on-info": string;
+            success: string;
+            "on-success": string;
+            warning: string;
+            "on-warning": string;
+        };
+    };
+}
+export declare class LightThemeDefinition implements ThemeDefinition {
+    dark: boolean;
+    id: string;
+    primary: ColorSchema;
+    secondary: ColorSchema;
+    tertiary: ColorSchema;
+    neutral: ColorSchema;
+    background: ColorSchema;
+    error: ColorSchema;
+    additional: ColorSchema[];
+    constructor();
+}
+export declare class DarkThemeDefinition implements ThemeDefinition {
+    dark: boolean;
+    id: string;
+    primary: ColorSchema;
+    secondary: ColorSchema;
+    tertiary: ColorSchema;
+    neutral: ColorSchema;
+    background: ColorSchema;
+    error: ColorSchema;
+    additional: ColorSchema[];
+    constructor();
+}
+export declare class CustomTheme implements ThemeDefinition {
+    id: string;
+    primary: ColorSchema;
+    secondary: ColorSchema;
+    tertiary: ColorSchema;
+    neutral: ColorSchema;
+    background: ColorSchema;
+    error: ColorSchema;
+    additional: ColorSchema[];
+    dark: boolean;
+    constructor(primary: string, secondary: string, tertiary: string, neutral: string, background: string);
+}

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

@@ -117,6 +117,7 @@ import wc30289e2b58ff48b0aabb3cb3732c3038 from './ux/usertypelayout/UserTypeLayo
 import wc5b26d2a399c041f3beae9c1115d6e8d8 from './ux/usertypelayout/UserTypeLayoutBladeBuilder';
 import wc80bd5b0978ea40439001d3d409236382 from './ux/velcron/blocks/VelcronBlock';
 import wce8526e8ed3f74e848e0dd747fd4d376d from './ux/velcron/blocks/VelcronBlockSettings';
+import wc1266389c28034034921b897f788f302d from './ux/velcron/editor/components/pickers/ColorPicker';
 import wcc75ffd4cf2f14b6685c5c2d894fdf00f from './ux/velcron/editor/VelcronEditor';
 import wc3dd4d94bcc254f9fac2100a3ff84dc7e from './ux/velcron/renderer/VelcronRenderer';
 import wcba03fc7e6921468289c0a0ffe0cf942e from './ux/versionedlayout/renderer/VersionedLayoutRenderer';
@@ -245,6 +246,7 @@ declare global {
             "omfx-usertype-layout-blade-builder": base.CombinedTsxComponentAttrs<typeof wc5b26d2a399c041f3beae9c1115d6e8d8.propsDefinition, {}, {}, {}, {}, true> & VueComponentBaseProps;
             "omfx-velcron-block": base.CombinedTsxComponentAttrs<typeof wc80bd5b0978ea40439001d3d409236382.propsDefinition, {}, {}, {}, {}, true> & VueComponentBaseProps;
             "omfx-velcron-block-settings": base.CombinedTsxComponentAttrs<typeof wce8526e8ed3f74e848e0dd747fd4d376d.propsDefinition, {}, {}, {}, {}, true> & VueComponentBaseProps;
+            "omnia-color-picker": base.CombinedTsxComponentAttrs<typeof wc1266389c28034034921b897f788f302d.propsDefinition, {}, {}, {}, {}, true> & VueComponentBaseProps;
             "omfx-velcron-editor": base.CombinedTsxComponentAttrs<typeof wcc75ffd4cf2f14b6685c5c2d894fdf00f.propsDefinition, {}, {}, {}, {}, true> & VueComponentBaseProps;
             "omfx-velcron-renderer": base.CombinedTsxComponentAttrs<typeof wc3dd4d94bcc254f9fac2100a3ff84dc7e.propsDefinition, {}, {}, {}, {}, true> & VueComponentBaseProps;
             "omfx-versioned-layout-renderer": base.CombinedTsxComponentAttrs<typeof wcba03fc7e6921468289c0a0ffe0cf942e.propsDefinition, {}, {}, {}, {}, true> & VueComponentBaseProps;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/fx",
   "license": "MIT",
-  "version": "7.0.497-dev",
+  "version": "7.0.499-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": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "7.0.497-dev",
+    "@omnia/fx-models": "7.0.499-dev",
     "@microsoft/signalr": "6.0.1",
     "broadcast-channel": "4.8.0",
     "dayjs": "1.10.7",