@omnia/fx 8.0.60-vnext → 8.0.62-vnext

package/internal-do-not-import-from-here/ux/theming-v2/{themes → skins/editor/themes}/Blueprints.d.ts

@@ -2,7 +2,7 @@ import { BlueprintDefinition, BlueprintItemDefinition, Guid } from "@omnia/fx-mo
 export declare class MD1Blueprint implements BlueprintDefinition {
     id: Guid;
     definitions: Array<BlueprintItemDefinition>;
-    constructor(preview?: boolean);
+    constructor();
 }
 export declare class MD2Blueprint implements BlueprintDefinition {
     id: Guid;

package/internal-do-not-import-from-here/ux/theming-v2/skins/editor/themes/SpacingTypes.d.ts

@@ -0,0 +1,17 @@
+import { Guid, SpacingDefinition } from "@omnia/fx-models";
+export declare class DefaultLayoutSpacing implements SpacingDefinition {
+    id: Guid;
+    xs: number;
+    s: number;
+    m: number;
+    l: number;
+    xl: number;
+}
+export declare class DefaultInnerSpacing implements SpacingDefinition {
+    id: Guid;
+    xs: number;
+    s: number;
+    m: number;
+    l: number;
+    xl: number;
+}

package/internal-do-not-import-from-here/ux/theming-v2/skins/editor/themes/ThemeDefinitions.d.ts

@@ -0,0 +1,8 @@
+import { ThemeDefinitionV2 } from "@omnia/fx-models";
+import { ThemeDefinitionInstance } from "../../core";
+export declare function useEditorThemeDefinitions(): {
+    readonly dark: ThemeDefinitionV2;
+    readonly light: ThemeDefinitionV2;
+};
+export declare function darkEditorDefinition(): ThemeDefinitionInstance;
+export declare function lightEditorDefinition(): ThemeDefinitionInstance;

package/internal-do-not-import-from-here/ux/theming-v2/skins/editor/themes/TypographyTypes.d.ts

@@ -0,0 +1,97 @@
+import { Guid, TypographyDefinition } from "@omnia/fx-models";
+export declare class EditorTypography implements TypographyDefinition {
+    id: Guid;
+    title: {
+        xl: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        l: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        m: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        s: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        xs: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+    };
+    text: {
+        l: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        m: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        s: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        xs: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+    };
+    navigation: {
+        l: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+        m: {
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+    };
+    link: {
+        m: {
+            decoration: string;
+            large: {
+                size: number;
+                lineHeight: number;
+                weight: number;
+            };
+        };
+    };
+}

package/internal-do-not-import-from-here/ux/theming-v2/skins/editor/themes/index.d.ts

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

package/internal-do-not-import-from-here/ux/theming-v2/skins/editor/useEditorSkin.d.ts

@@ -0,0 +1,7 @@
+export declare function useEditorSkin(): {
+    themes: {
+        readonly dark: import("@omnia/fx-models").ThemeDefinitionV2;
+        readonly light: import("@omnia/fx-models").ThemeDefinitionV2;
+    };
+    velcronTemplates: {};
+};

package/internal-do-not-import-from-here/ux/theming-v2/skins/index.d.ts

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

package/internal-do-not-import-from-here/ux/theming-v2/skins/useSkins.d.ts

@@ -0,0 +1,63 @@
+export declare function useSkins(): {
+    default: {
+        readonly themes: {
+            readonly darkKnight: import("@omnia/fx-models").ThemeDefinitionV2;
+            readonly black: import("@omnia/fx-models").ThemeDefinitionV2;
+            readonly bumbleBee: import("@omnia/fx-models").ThemeDefinitionV2;
+            readonly cyberPunk: import("@omnia/fx-models").ThemeDefinitionV2;
+            readonly coffe: import("@omnia/fx-models").ThemeDefinitionV2;
+            readonly light: import("@omnia/fx-models").ThemeDefinitionV2;
+            readonly dark: import("@omnia/fx-models").ThemeDefinitionV2;
+            preview: {
+                readonly dark: import("@omnia/fx-models").ThemeDefinitionV2;
+                readonly darkMini: import("@omnia/fx-models").ThemeDefinitionV2;
+            };
+        };
+        readonly velcronTemplates: {
+            readonly headers: {
+                readonly block: {
+                    iconLeft: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                    iconRight: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                };
+                page: {
+                    large: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                };
+            };
+            readonly content: {
+                text: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                textQuote: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                imageLeft: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                imageRight: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                imageWithCaption: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+            };
+            general: {};
+            readonly cards: {
+                banner: {
+                    imageTop: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                };
+                readonly rollup: {
+                    imageLeftSmall: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                    imageRightSmall: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                    imagePromotedSmall: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                    imageTop: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                    imageTopAvatar: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                    imageRightLarge: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                    avatar: import("@omnia/fx-models").VelcronDefinitionRegistration<object>;
+                };
+            };
+        };
+    };
+    documentation: {
+        themes: {
+            readonly dark: import("@omnia/fx-models").ThemeDefinitionV2;
+        };
+        velcronTemplates: {};
+    };
+    editor: {
+        themes: {
+            readonly dark: import("@omnia/fx-models").ThemeDefinitionV2;
+            readonly light: import("@omnia/fx-models").ThemeDefinitionV2;
+        };
+        velcronTemplates: {};
+    };
+};

package/internal-do-not-import-from-here/ux/theming-v2/themedefinitionpicker/ThemeDefinitionPicker.d.ts

@@ -114,10 +114,10 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            "onUpdate:modelValue"?: ((value: Guid) => any) & ((theme: ThemeDefinitionV2) => any);
             readonly modelValue?: Guid;
-            readonly toned?: string;
+            "onUpdate:modelValue"?: ((value: Guid) => any) & ((theme: ThemeDefinitionV2) => any);
             readonly "v-model"?: Guid;
+            readonly toned?: string;
         };
         $attrs: {
             [x: string]: unknown;
@@ -478,10 +478,10 @@ declare const _default: {
                 };
             }>;
         };
-        "onUpdate:modelValue"?: (value: Guid) => any;
         modelValue?: Guid;
-        toned?: string;
+        "onUpdate:modelValue"?: (value: Guid) => any;
         "v-model"?: Guid;
+        toned?: string;
     }>, "onUpdate:modelValue"> & {
         "onUpdate:modelValue"?: (theme: ThemeDefinitionV2) => any;
     };

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

@@ -1,14 +1,6 @@
-import { IInternalValidator, IValidationRuleBuilder, IValidationScope } from "../models/Validation";
-export declare function createValidator(): {
-    destroy: () => void;
-    createRules: () => IValidationRuleBuilder;
-    overrideValidate: (func: () => Promise<boolean>) => void;
-    register: (validation: IValidationScope) => void;
-    unregister: (validation: IValidationScope) => void;
-    validate: () => Promise<boolean>;
-    resetValidation: () => void;
-};
+import { IInternalValidator, IValidator } from "../models/Validation";
+export declare function createValidator(): IValidator;
 export declare function useInternalValidator(): {
-    setValidator: (validator: IInternalValidator) => void;
+    setValidator: (validator: IValidator) => void;
     validator: IInternalValidator;
 };

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

@@ -110,8 +110,8 @@ declare const _default: {
                 [key: string]: any;
             }>) => void)[];
             readonly styles?: unknown;
-            readonly "onUpdate:modelValue"?: (value: UserIdentity) => any;
             readonly modelValue?: UserIdentity;
+            readonly "onUpdate:modelValue"?: (value: UserIdentity) => any;
             readonly "v-model"?: UserIdentity;
             readonly offsetX?: number;
             readonly offsetY?: number;
@@ -469,8 +469,8 @@ declare const _default: {
             }>;
         };
         styles?: unknown;
-        "onUpdate:modelValue"?: (value: UserIdentity) => any;
         modelValue?: UserIdentity;
+        "onUpdate:modelValue"?: (value: UserIdentity) => any;
         "v-model"?: UserIdentity;
         offsetX?: number;
         offsetY?: number;

package/internal-do-not-import-from-here/ux/velcron/blocks/velcron/VelcronBlockSettings.d.ts

@@ -1,11 +1,6 @@
-import { ColorSchemaReference, VelcronAppDefinition } from "../../core";
-interface VelcronColorSchema {
-    colorSchemas: {
-        [key: string]: ColorSchemaReference;
-    };
-}
+import { VelcronAppDefinition } from "@omnia/fx/models";
 export interface VelcronBlockBlockSettings {
-    definition: VelcronAppDefinition<VelcronColorSchema>;
+    definition: VelcronAppDefinition<any>;
 }
 declare const _default: {
     new (...args: any[]): {

package/internal-do-not-import-from-here/ux/velcron/components/{properties/VelcronProperties.d.ts → propertieseditor/VelcronPropertiesEditor.d.ts}

@@ -1,5 +1,4 @@
-import { VelcronAppDefinition } from "../../core";
-import { VelcronDefinitionEditableProperty } from "../../editor/models";
+import { VelcronAppDefinition, VelcronPropertyEditor } from "@omnia/fx-models";
 declare const _default: {
     new (...args: any[]): {
         $: import("vue").ComponentInternalInstance;
@@ -110,10 +109,11 @@ declare const _default: {
             }>) => void) | ((vnode: import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                 [key: string]: any;
             }>) => void)[];
-            "onUpdate:modelValue"?: ((value: VelcronAppDefinition<object>) => any) & ((value: VelcronAppDefinition<object>) => any);
             readonly modelValue?: VelcronAppDefinition<object>;
-            readonly properties: VelcronDefinitionEditableProperty[];
+            "onUpdate:modelValue"?: ((value: VelcronAppDefinition<object>) => any) & ((value: VelcronAppDefinition<object>) => any);
             readonly "v-model"?: VelcronAppDefinition<object>;
+            readonly propertyEditors?: VelcronPropertyEditor<any>[];
+            readonly "property-editors"?: VelcronPropertyEditor<any>[];
         };
         $attrs: {
             [x: string]: unknown;
@@ -129,9 +129,11 @@ declare const _default: {
         $emit: (event: "update:modelValue", value: VelcronAppDefinition<object>) => void;
         $el: any;
         $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-            properties: {
-                type: import("vue").PropType<VelcronDefinitionEditableProperty[]>;
-                required: true;
+            "property-editors": {
+                type: import("vue").PropType<VelcronPropertyEditor<any>[]>;
+            };
+            propertyEditors: {
+                type: import("vue").PropType<VelcronPropertyEditor<any>[]>;
             };
             "onUpdate:modelValue": {
                 type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
@@ -224,9 +226,11 @@ declare const _default: {
         $nextTick: typeof import("vue").nextTick;
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
     } & Readonly<import("vue").ExtractPropTypes<{
-        properties: {
-            type: import("vue").PropType<VelcronDefinitionEditableProperty[]>;
-            required: true;
+        "property-editors": {
+            type: import("vue").PropType<VelcronPropertyEditor<any>[]>;
+        };
+        propertyEditors: {
+            type: import("vue").PropType<VelcronPropertyEditor<any>[]>;
         };
         "onUpdate:modelValue": {
             type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
@@ -301,9 +305,11 @@ declare const _default: {
     __isTeleport?: never;
     __isSuspense?: never;
 } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
-    properties: {
-        type: import("vue").PropType<VelcronDefinitionEditableProperty[]>;
-        required: true;
+    "property-editors": {
+        type: import("vue").PropType<VelcronPropertyEditor<any>[]>;
+    };
+    propertyEditors: {
+        type: import("vue").PropType<VelcronPropertyEditor<any>[]>;
     };
     "onUpdate:modelValue": {
         type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
@@ -376,9 +382,7 @@ declare const _default: {
 }, () => JSX.Element[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (value: VelcronAppDefinition) => true;
 }, string, {}, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
-    propsDefinition: Omit<Readonly<{
-        properties: VelcronDefinitionEditableProperty[];
-    } & {
+    propsDefinition: Omit<Readonly<{} & {
         name?: {
             [x: `onUpdate:${string}`]: {
                 type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any>;
@@ -440,9 +444,11 @@ declare const _default: {
                 };
             }>;
         };
-        "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         modelValue?: VelcronAppDefinition<object>;
+        "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
         "v-model"?: VelcronAppDefinition<object>;
+        propertyEditors?: VelcronPropertyEditor<any>[];
+        "property-editors"?: VelcronPropertyEditor<any>[];
     }>, "onUpdate:modelValue"> & {
         "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
     };

package/internal-do-not-import-from-here/ux/velcron/components/{properties → propertieseditor}/editors/alignment/AlignmentEditor.d.ts

@@ -1,4 +1,4 @@
 export interface VelcronAlignmentPropertyEditorSettings {
     vertical: boolean;
 }
-export declare const useVelcronAlignmentPropertyEditor: (settings?: VelcronAlignmentPropertyEditorSettings) => import("../../../../editor/models").VelcronPropertyEditor<any>;
+export declare const useVelcronAlignmentPropertyEditor: (settings?: VelcronAlignmentPropertyEditorSettings) => import("@omnia/fx-models").VelcronPropertyEditor<any>;

package/internal-do-not-import-from-here/ux/velcron/components/propertieseditor/editors/color/ColorEditor.d.ts

@@ -0,0 +1 @@
+export declare const useVelcronColorPropertyEditor: (settings?: undefined) => import("@omnia/fx-models").VelcronPropertyEditor<any>;

package/internal-do-not-import-from-here/ux/velcron/components/{properties → propertieseditor}/editors/index.d.ts

@@ -3,3 +3,4 @@ export * from "./slider/SliderEditor";
 export * from "./switch/SwitchEditor";
 export * from "./text/TextEditor";
 export * from "./color/ColorEditor";
+export * from "./markdown/MarkdownEditor";

package/internal-do-not-import-from-here/ux/velcron/components/propertieseditor/editors/markdown/MarkdownEditor.d.ts

@@ -0,0 +1 @@
+export declare const useVelcronMarkdownPropertyEditor: (settings?: undefined) => import("@omnia/fx-models").VelcronPropertyEditor<any>;

package/internal-do-not-import-from-here/ux/velcron/components/propertieseditor/editors/slider/SliderEditor.d.ts

@@ -0,0 +1,2 @@
+import { VelcronSliderPropertyEditorSettings } from "@omnia/fx-models";
+export declare const useVelcronSliderPropertyEditor: (settings?: VelcronSliderPropertyEditorSettings) => import("@omnia/fx-models").VelcronPropertyEditor<any>;

package/internal-do-not-import-from-here/ux/velcron/components/propertieseditor/editors/switch/SwitchEditor.d.ts

@@ -0,0 +1 @@
+export declare const useVelcronSwitchPropertyEditor: (settings?: undefined) => import("@omnia/fx-models").VelcronPropertyEditor<any>;

package/internal-do-not-import-from-here/ux/velcron/components/propertieseditor/editors/text/TextEditor.d.ts

@@ -0,0 +1 @@
+export declare const useVelcronTextPropertyEditor: (settings?: undefined) => import("@omnia/fx-models").VelcronPropertyEditor<any>;

package/internal-do-not-import-from-here/ux/velcron/components/{properties → propertieseditor}/models/DefineVelcronPropertyEditor.d.ts

@@ -1,2 +1,2 @@
-import { VelcronPropertyEditor } from "../../../editor/models";
+import { VelcronPropertyEditor } from "@omnia/fx-models";
 export declare function defineVelcronPropertyEditor<TSettings = undefined>(name: string, component: unknown): (settings?: TSettings) => VelcronPropertyEditor;

package/internal-do-not-import-from-here/ux/velcron/components/propertieseditor/models/DefineVelcronPropertyEditorProps.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,7 +1,7 @@
 import { VelcronEvent, VelcronOnUpdatedEvent, VelcronOnClosedEvent, VelcronOnCloseRequestedEvent, VelcronOnEditModeEvent, VelcronOnLoadEvent, VelcronOnPressEvent } from "./VelcronEvents";
 import { VelcroncomponentArrayType, VelcronPrimitiveType } from "./VelcronTypes";
 import { AssignOperators, VelcronHorizontalAlignments, VelcronIconTypes, VelcronActionTypes, VelcronVerticalAlignments } from "./Enums";
-import { useVelcronThemingStore } from "..";
+import { VelcronPropertyEditor, useVelcronThemingStore } from "..";
 import { useVelcronColorSchemaStore } from "../stores/VelcronColorSchema";
 import { useVelcronBlueprintStore } from "../stores/VelcronBlueprint";
 export interface ResolvedComponentRenderer {
@@ -10,19 +10,19 @@ export interface ResolvedComponentRenderer {
     customComponent: boolean;
 }
 export interface BuiltInComponentRenderers {
-    "View": unknown;
-    "Card": unknown;
-    "Text": unknown;
-    "Image": unknown;
-    "Button": unknown;
-    "TextInput": unknown;
-    "ProgressCircle": unknown;
-    "WebView": unknown;
-    "CustomComponent": unknown;
-    "Dialog": unknown;
-    "Icon": unknown;
-    "Chip": unknown;
-    "Markdown": unknown;
+    "view": unknown;
+    "card": unknown;
+    "text": unknown;
+    "image": unknown;
+    "button": unknown;
+    "text-input": unknown;
+    "progress-circle": unknown;
+    "web-view": unknown;
+    "custom-component": unknown;
+    "dialog": unknown;
+    "icon": unknown;
+    "chip": unknown;
+    "markdown": unknown;
 }
 export interface ColorSchemaReference {
     name: string;
@@ -162,7 +162,7 @@ export interface VelcronIcon {
     name: string;
 }
 export interface VelcronAppDefinition<TState extends DynamicState = DynamicState> extends VelcronDefinitionBase {
-    type: "Velcron";
+    type: "velcron";
     version: string;
     name: string;
     body?: Array<VelcronDefinition>;
@@ -171,6 +171,7 @@ export interface VelcronAppDefinition<TState extends DynamicState = DynamicState
         [name: string]: [];
     };
     components?: Array<VelcronCustomComponentDefinition>;
+    propEditors?: Array<VelcronPropertyEditor>;
     state?: TState;
     computed?: {
         [name: string]: [];
@@ -184,91 +185,95 @@ export interface VelcronComponentDefinition extends VelcronDefinition {
 }
 /*** Built-in Components *********************************************************************/
 export interface VelcronViewDefinition extends VelcronDefinition, VelcronColorStyling {
-    type: "View";
+    type: "view";
     events?: VelcronOnPressEvent;
     direction?: "row" | "column" | "row-reverse" | "column-reverse" | string;
     columnStyle?: object;
     horizontalAlignment?: VelcronHorizontalAlignments;
     verticalAlignment?: VelcronVerticalAlignments;
     grow?: number;
+    absolute?: VelcronSpacing;
     border?: VelcronBorder;
     borderRadius?: VelcronDimensions;
-    width?: number;
+    width?: number | string;
+    minWidth?: number | string;
+    height?: number | string;
+    minHeight?: number | string;
 }
 export interface VelcronCardDefinition extends VelcronDefinition, VelcronColorStyling {
-    type: "Card";
+    type: "card";
     style?: VelcronCardStyling;
     footer?: Array<VelcronDefinition>;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronTextDefinition extends VelcronDefinitionWithEditMode, VelcronColorStyling, VelcronTextStyling {
-    type: "Text";
+    type: "text";
     editLabel?: VelcronBindableProp;
     lineClamp?: number;
     noWrap?: boolean;
     events?: VelcronOnPressEvent & VelcronOnUpdatedEvent;
 }
 export declare enum VelcronImageRatios {
-    square = 1,
-    landscape = 2
+    square = "square",
+    landscape = "landscapre"
 }
 export interface VelcronImageDefinition extends VelcronDefinition {
-    type: "Image";
+    type: "image";
     source: string;
-    ratio: VelcronImageRatios;
+    ratio: VelcronImageRatios | string;
     cover?: VelcronBindableProp<boolean>;
     borderRadius?: VelcronDimensions;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronButtonDefinition extends VelcronDefinition {
-    type: "Button";
+    type: "button";
     text: string;
     icon?: VelcronIcon;
     disabled?: boolean;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronTextInputDefinition extends VelcronDefinition {
-    type: "TextInput";
+    type: "text-input";
     label?: string;
     bind: string;
     initialValue?: string;
     events: VelcronOnUpdatedEvent;
 }
 export interface VelcronProgressCircleDefinition extends VelcronDefinition {
-    type: "ProgressCircle";
+    type: "progress-circle";
     events?: VelcronOnPressEvent;
 }
 export interface VelcronWebViewDefinition extends VelcronDefinition {
-    type: "WebView";
+    type: "web-view";
     source: string;
 }
 export interface VelcronDialogDefinition extends VelcronDefinition {
-    type: "Dialog";
+    type: "dialog";
     title: string;
     visible: string;
     events?: VelcronOnCloseRequestedEvent & VelcronOnClosedEvent;
 }
 export interface VelcronIconDefinition extends VelcronDefinition, VelcronColorStyling {
-    type: "Icon";
+    type: "icon";
     icon: string;
     size?: VelcronBindableProp<number>;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronMarkdownDefinition extends VelcronDefinitionWithEditMode, VelcronColorStyling, VelcronTextStyling {
-    type: "Markdown";
+    type: "markdown";
     events: VelcronOnUpdatedEvent;
 }
 export interface VelcronDimensions {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
+    top: number | string;
+    right: number | string;
+    bottom: number | string;
+    left: number | string;
 }
 export interface VelcronBorder extends VelcronDimensions {
     color: string;
 }
 export interface VelcronChipDefinition extends VelcronDefinition {
-    type: "Chip";
+    type: "chip";
     text: string;
     icon?: VelcronIcon;
     disabled?: boolean;

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

@@ -0,0 +1,57 @@
+import { VelcronDataTypes, VelcronImageRatios } from "@omnia/fx-models";
+export interface VelcronPropertyEditor<TSettings = any> {
+    name?: string;
+    type: BuiltInPropertyEditorType | string;
+    settings?: TSettings;
+    mapToStateProperty: string;
+    dataType?: VelcronDataTypes;
+    component?: unknown;
+}
+export type BuiltInPropertyEditorType = "text" | "slider" | "switch" | "alignment" | "color" | "markdown" | "icon" | "image";
+export declare enum BuiltInPropertyEditorTypes {
+    text = "text",
+    slider = "slider",
+    switch = "switch",
+    alignment = "alignment",
+    color = "color",
+    markdown = "markdown",
+    icon = "icon",
+    image = "image"
+}
+export interface VelcronSliderPropertyEditorSettings {
+    min: number;
+    max: number;
+    step: number;
+}
+export interface VelcronSliderPropertyEditor extends VelcronPropertyEditor<VelcronSliderPropertyEditorSettings> {
+    type: "slider";
+}
+export interface VelcronTextPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "text";
+}
+export interface VelcronSwitchPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "switch";
+}
+export interface VelcronAlignmentPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "alignment";
+}
+export interface VelcronColorPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "color";
+}
+export interface VelcronIconPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "icon";
+}
+export interface VelcronMarkdownPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "markdown";
+}
+export interface VelcronImagePropertyEditor extends VelcronPropertyEditor<any> {
+    type: "image";
+}
+export interface VelcronContentState {
+    caption: string;
+    main: string;
+}
+export interface VelcronImageState {
+    url: string;
+    ratio: VelcronImageRatios;
+}