@omnia/fx 8.0.293-dev → 8.0.296-dev

package/internal-do-not-import-from-here/ux/velcron/components/definitionpicker/VelcronDefinitionPicker.d.ts

@@ -115,8 +115,8 @@ declare const _default: {
             required: boolean;
         };
     }>> & {
-        onAdd?: () => any;
         onClose?: () => any;
+        onAdd?: () => any;
         "onUpdate:modelValue"?: (value: boolean) => any;
         onSelected?: (resolverReference: VelcronRendererResolverReference) => any;
         "onDefinition:enter"?: (id: guid) => any;
@@ -128,126 +128,7 @@ declare const _default: {
         "update:modelValue": (value: boolean) => any;
         "definition:enter": (id: guid) => any;
         "definition:leave": (id: guid) => any;
-    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-        "v-slots": import("vue").Prop<{
-            default?: import("../../../DefineVueTypings").Slot;
-        } & {
-            activator?: () => VNodeChild;
-        }>;
-        allowBuiltIn: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        exclusions: {
-            type: import("vue").PropType<guid[]>;
-        };
-        previewState: {
-            type: import("vue").PropType<VelcronState>;
-        };
-        allowEdit: {
-            type: import("vue").PropType<boolean>;
-        };
-        variant: {
-            type: import("vue").PropType<Variant>;
-        };
-        renderTypeFilters: {
-            type: import("vue").PropType<guid[]>;
-        };
-        categoryFilters: {
-            type: import("vue").PropType<guid[]>;
-        };
-        "onUpdate:modelValue": {
-            type: import("vue").PropType<(value: boolean) => any | void>;
-        };
-        "v-model": {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        modelValue: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        };
-        name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
-            type: import("vue").PropType<(value: boolean) => any | void>;
-        }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
-            type: import("vue").PropType<boolean>;
-            required: false;
-        }; } & {
-            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, boolean, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: boolean) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<boolean>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<boolean>;
-                    required: false;
-                };
-            }>;
-            defaultValue(value?: boolean): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, boolean, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: boolean) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<boolean>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<boolean>;
-                    required: false;
-                };
-            }, false>;
-            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, boolean, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: boolean) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<boolean>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<boolean>;
-                    required: false;
-                };
-            }>;
-        };
-        title: {
-            type: import("vue").PropType<string>;
-        };
-        icon: {
-            type: import("vue").PropType<IIcon>;
-        };
-        colorSchemaType: {
-            type: import("vue").PropType<import("@omnia/fx-models").ColorSchemaTypes | import("@omnia/fx-models").ColorSchemaType>;
-            required: boolean;
-        };
-        container: {
-            type: BooleanConstructor;
-            required: boolean;
-        };
-        colors: {
-            type: import("vue").PropType<import("@omnia/fx/ux").ColorSchemaStoreType>;
-            required: boolean;
-        };
-    }>> & {
-        onAdd?: () => any;
-        onClose?: () => any;
-        "onUpdate:modelValue"?: (value: boolean) => any;
-        onSelected?: (resolverReference: VelcronRendererResolverReference) => any;
-        "onDefinition:enter"?: (id: guid) => any;
-        "onDefinition:leave"?: (id: guid) => any;
-    }, {
+    }, import("vue").PublicProps, {
         container: boolean;
     }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
@@ -369,8 +250,8 @@ declare const _default: {
             required: boolean;
         };
     }>> & {
-        onAdd?: () => any;
         onClose?: () => any;
+        onAdd?: () => any;
         "onUpdate:modelValue"?: (value: boolean) => any;
         onSelected?: (resolverReference: VelcronRendererResolverReference) => any;
         "onDefinition:enter"?: (id: guid) => any;
@@ -494,8 +375,8 @@ declare const _default: {
         required: boolean;
     };
 }>> & {
-    onAdd?: () => any;
     onClose?: () => any;
+    onAdd?: () => any;
     "onUpdate:modelValue"?: (value: boolean) => any;
     onSelected?: (resolverReference: VelcronRendererResolverReference) => any;
     "onDefinition:enter"?: (id: guid) => any;
@@ -577,15 +458,15 @@ declare const _default: {
         container?: boolean;
         colorSchemaType?: "background" | "primary" | "secondary" | import("@omnia/fx-models").ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";
         colors?: import("@omnia/fx/ux").ColorSchemaStoreType;
-        modelValue?: boolean;
-        "v-model"?: boolean;
-        "onUpdate:modelValue"?: (value: boolean) => any | void;
         "v-slots"?: {
             default?: import("../../../DefineVueTypings").Slot;
         } & {
             activator?: () => VNodeChild;
         };
+        "v-model"?: boolean;
+        modelValue?: boolean;
         variant?: Variant;
+        "onUpdate:modelValue"?: (value: boolean) => any | void;
         allowEdit?: boolean;
         categoryFilters?: guid[];
         renderTypeFilters?: guid[];

package/internal-do-not-import-from-here/ux/velcron/components/definitionpicker/VelcronDefinitionPreview.d.ts

@@ -98,100 +98,7 @@ declare const _default: {
         "update:modelValue": (value: boolean) => any;
         "definition:enter": (id: guid) => any;
         "definition:leave": (id: guid) => any;
-    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-        previewState: {
-            type: import("vue").PropType<VelcronState>;
-        };
-        allowEdit: {
-            type: import("vue").PropType<boolean>;
-        };
-        hasContainer: {
-            type: import("vue").PropType<boolean>;
-        };
-        "onUpdate:modelValue": {
-            type: import("vue").PropType<(value: VelcronDefinitionRegistration<object>) => any | void>;
-        };
-        "v-model": {
-            type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-            required: false;
-        };
-        modelValue: {
-            type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-            required: false;
-        };
-        name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
-            type: import("vue").PropType<(value: VelcronDefinitionRegistration<object>) => any | void>;
-        }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
-            type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-            required: false;
-        }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
-            type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-            required: false;
-        }; } & {
-            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronDefinitionRegistration<object>, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: VelcronDefinitionRegistration<object>) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-                    required: false;
-                };
-            }>;
-            defaultValue(value?: VelcronDefinitionRegistration<object>): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronDefinitionRegistration<object>, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: VelcronDefinitionRegistration<object>) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-                    required: false;
-                };
-            }, false>;
-            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronDefinitionRegistration<object>, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: VelcronDefinitionRegistration<object>) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<VelcronDefinitionRegistration<object>>;
-                    required: false;
-                };
-            }>;
-        };
-        colorSchemaType: {
-            type: import("vue").PropType<import("@omnia/fx-models").ColorSchemaTypes | ColorSchemaType>;
-            required: boolean;
-        };
-        container: {
-            type: BooleanConstructor;
-            required: boolean;
-        };
-        colors: {
-            type: import("vue").PropType<import("@omnia/fx/ux").ColorSchemaStoreType>;
-            required: boolean;
-        };
-    }>> & {
-        "onUpdate:modelValue"?: (value: boolean) => any;
-        onSelected?: (id: guid) => any;
-        "onDefinition:enter"?: (id: guid) => any;
-        "onDefinition:leave"?: (id: guid) => any;
-    }, {
+    }, import("vue").PublicProps, {
         container: boolean;
     }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
@@ -465,8 +372,8 @@ declare const _default: {
         container?: boolean;
         colorSchemaType?: "background" | "primary" | "secondary" | import("@omnia/fx-models").ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";
         colors?: import("@omnia/fx/ux").ColorSchemaStoreType;
-        modelValue?: VelcronDefinitionRegistration<object>;
         "v-model"?: VelcronDefinitionRegistration<object>;
+        modelValue?: VelcronDefinitionRegistration<object>;
         "onUpdate:modelValue"?: (value: VelcronDefinitionRegistration<object>) => any | void;
         allowEdit?: boolean;
         previewState?: VelcronState;

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

@@ -88,90 +88,7 @@ declare const _default: {
         "update:modelValue": (value: VelcronAppDefinition) => true;
         "value:enter": (propertyEditorMapping: VelcronEditor, value: any) => true;
         "value:leave": (propertyEditorMapping: VelcronEditor, value: any) => true;
-    }, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-        previewColorSchemaType: {
-            type: import("vue").PropType<"background" | "primary" | "secondary" | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic">;
-        };
-        location: {
-            type: import("vue").PropType<EditorLocation>;
-        };
-        hidePropertyMapped: {
-            type: import("vue").PropType<boolean>;
-        };
-        propertyEditors: {
-            type: import("vue").PropType<VelcronEditor<any>[]>;
-        };
-        "onUpdate:modelValue": {
-            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any | void>;
-        };
-        "v-model": {
-            type: import("vue").PropType<VelcronAppDefinition<object>>;
-            required: false;
-        };
-        modelValue: {
-            type: import("vue").PropType<VelcronAppDefinition<object>>;
-            required: false;
-        };
-        name: <TName extends string>(n?: TName) => { [key in import("../../../DefineVueTypings").VModelEmitsInJsxElement<TName>]: {
-            type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any | void>;
-        }; } & { [key_1 in import("../../../DefineVueTypings").VModelKeyNameInJsxElement<TName>]: {
-            type: import("vue").PropType<VelcronAppDefinition<object>>;
-            required: false;
-        }; } & { [key_2 in import("../../../DefineVueTypings").VModelKeyNameInProps<TName>]: {
-            type: import("vue").PropType<VelcronAppDefinition<object>>;
-            required: false;
-        }; } & {
-            require(): import("../../../DefineVueTypings").DefinePropModelRequire<TName, VelcronAppDefinition<object>, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<VelcronAppDefinition<object>>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<VelcronAppDefinition<object>>;
-                    required: false;
-                };
-            }>;
-            defaultValue(value?: VelcronAppDefinition<object>): import("../../../DefineVueTypings").DefinePropModelDefaultValue<TName, VelcronAppDefinition<object>, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<VelcronAppDefinition<object>>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<VelcronAppDefinition<object>>;
-                    required: false;
-                };
-            }, false>;
-            doc$(description?: string): import("../../../DefineVueTypings").DefinePropModelDoc<TName, VelcronAppDefinition<object>, {
-                "onUpdate:modelValue": {
-                    type: import("vue").PropType<(value: VelcronAppDefinition<object>) => any | void>;
-                };
-            } & {
-                "v-model": {
-                    type: import("vue").PropType<VelcronAppDefinition<object>>;
-                    required: false;
-                };
-            } & {
-                modelValue: {
-                    type: import("vue").PropType<VelcronAppDefinition<object>>;
-                    required: false;
-                };
-            }>;
-        };
-    }>> & {
-        "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any;
-        "onValue:enter"?: (propertyEditorMapping: VelcronEditor<any>, value: any) => any;
-        "onValue:leave"?: (propertyEditorMapping: VelcronEditor<any>, value: any) => any;
-    }, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+    }, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -415,8 +332,8 @@ declare const _default: {
                 };
             }>;
         };
-        modelValue?: VelcronAppDefinition<object>;
         "v-model"?: VelcronAppDefinition<object>;
+        modelValue?: VelcronAppDefinition<object>;
         "onUpdate:modelValue"?: (value: VelcronAppDefinition<object>) => any | void;
         location?: EditorLocation;
         previewColorSchemaType?: "background" | "primary" | "secondary" | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";

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

@@ -4,6 +4,8 @@ import { AssignOperators, VelcronHorizontalAlignments, VelcronIconTypes, Velcron
 import { DynamicState, VelcronDefinition, VelcronEffects, useVelcronThemingStore } from "..";
 import { guid, PropertyConfiguration, PropertyValue, PropertyDefinition, PropertySetupBase } from "@omnia/fx/models";
 import { useVelcronColorSchemaStore } from "../stores/VelcronColorSchema";
+import { Properties } from "csstype";
+import type { AnimationOptionsWithOverrides, InViewOptions, VariantDefinition, Variants } from "motion";
 export interface ResolvedComponentRenderer {
     component: unknown;
     definition: VelcronDefinition;
@@ -33,11 +35,10 @@ export interface BuiltInComponentRenderers {
     "checkbox": unknown;
     "reference": unknown;
     "radio": unknown;
-    "rive": unknown;
-    "lottie": unknown;
     "slide-panel": unknown;
     "editor": unknown;
     "link": unknown;
+    "motion": unknown;
 }
 export interface ColorSchemaReference {
     name: string;
@@ -50,10 +51,32 @@ export interface OnItemRenderedHookResult {
 export interface VelcronDisplay {
     size: VelcronDisplaySizes;
 }
+export type VelcronDisplaySizeOptions = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
 export interface VelcronDisplaySizes {
+    current: VelcronDisplaySizeOptions;
+    xs: boolean;
     sm: boolean;
     md: boolean;
     lg: boolean;
+    xl: boolean;
+    xxl: boolean;
+    smAndDown: boolean;
+    smAndUp: boolean;
+    mdAndDown: boolean;
+    mdAndUp: boolean;
+    lgAndDown: boolean;
+    lgAndUp: boolean;
+    xlAndDown: boolean;
+    xlAndUp: boolean;
+    breakpoints: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+        xxl: number;
+    };
+    setSize(sizeName: VelcronDisplaySizeOptions): any;
 }
 export interface VelcronRenderContext {
     id?: string;
@@ -236,6 +259,7 @@ export interface VelcronTextDefinition extends VelcronDefinition, VelcronColorSt
     lineClamp?: VelcronBindableProp<number>;
     noWrap?: VelcronBindableProp<boolean>;
     wordBreak?: VelcronBindableProp<"none">;
+    align?: VelcronHorizontalAlignments;
     events?: VelcronOnPressEvent & VelcronOnUpdatedEvent;
     blueprint?: VelcronBindableProp<TextBlueprint>;
 }
@@ -305,28 +329,30 @@ export interface VelcronFlowDefinition extends VelcronDefinition, VelcronColorSt
     placeholder?: VelcronBindableProp<string>;
     events?: VelcronOnUpdatedEvent;
 }
-export interface VelcronRiveDefinition extends VelcronDefinition {
-    type: "rive";
-    url: VelcronBindableProp;
-    loop?: VelcronBindableProp<boolean>;
-    autoplay?: VelcronBindableProp<boolean>;
-    count?: VelcronBindableProp<number>;
-    direction?: VelcronBindableProp<"normal" | "reverse">;
-    hover?: VelcronBindableProp<boolean>;
-}
-export interface VelcronLottieDefinition extends VelcronDefinition {
-    type: "lottie";
-    url: VelcronBindableProp;
-    loop?: VelcronBindableProp<boolean>;
-    autoplay?: VelcronBindableProp<boolean>;
-    count?: VelcronBindableProp<number>;
-    direction?: VelcronBindableProp<"normal" | "reverse">;
-    hover?: VelcronBindableProp<boolean>;
+export interface VelcronMotionDefinition extends VelcronDefinition {
+    initial?: false | VariantDefinition;
+    animate?: VariantDefinition;
+    inView?: VariantDefinition;
+    hover?: VariantDefinition;
+    press?: VariantDefinition;
+    variants?: Variants;
+    transition?: AnimationOptionsWithOverrides;
+    inViewOptions?: InViewOptions & {
+        once?: boolean;
+    };
 }
 export interface VelcronSlidePanelSlidesOptions {
     foreach: string;
     definition: VelcronDefinition;
 }
+export interface VelcronSlidePanelStyles {
+    container?: Properties;
+    wrapper?: Properties;
+    slides?: Properties;
+    previousSlide?: Properties;
+    nextSlide?: Properties;
+    activeSlide?: Properties;
+}
 export interface VelcronSlidePanelDefinition extends VelcronDefinition {
     type: "slide-panel";
     slidesPerView?: VelcronBindableProp<number>;
@@ -335,10 +361,12 @@ export interface VelcronSlidePanelDefinition extends VelcronDefinition {
     navigation?: VelcronBindableProp<boolean>;
     scrollbar?: VelcronBindableProp<boolean>;
     autoplay?: VelcronBindableProp<boolean>;
+    centeredSlides?: VelcronBindableProp<boolean>;
     loop?: VelcronBindableProp<boolean>;
     style?: VelcronCardStyling;
     events?: VelcronOnPressEvent;
     slides?: VelcronSlidePanelSlidesOptions;
+    styles?: VelcronSlidePanelStyles;
 }
 export interface VelcronEditorRendererDefinition extends VelcronDefinition {
     type: "editor";

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

@@ -3,3 +3,10 @@ export type VelcronPrimitiveType = string | number | boolean;
 export type VelcronArrayType<T> = Array<T>;
 export type VelcronObjectType<T extends Object> = T;
 export type VelcronComponentArrayType = Array<VelcronDefinition>;
+export type VelcronSwitchExpression = {
+    switch: string;
+    cases: {
+        [key: string]: string;
+    };
+    default?: string;
+};

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

@@ -23,8 +23,6 @@ export declare class VelcronActions {
     static valueIsAction(value: string): boolean;
     static executeActions(arr: any, x: any, customActionContext?: VelcronCustomActionExecutionContext): void;
     static executeAction(awAction: VelcronActionWithAutoAwait, callback: (continueExecution: boolean) => void): void;
-    static dataBindComputed(renderContext: VelcronRenderContext, template: string): string;
-    static parseAndExecuteComputed(renderContext: VelcronRenderContext, template: string): string;
     static registerActionHook<TBefore, TAfter>(actionName: string, handler: VelcronActionHooks<TBefore, TAfter>): void;
     static tryTriggerBeforeActionHook<T>(actionName: string, args: T): T;
     static tryTriggerAfterActionHook<T>(actionName: string, args: T): T;

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

@@ -5,7 +5,8 @@ export interface ParseResult<T> {
     value: T;
 }
 export declare class VelcronData {
-    static dataBind<T = string>(renderContext: VelcronRenderContext, bindTo: VelcronBindableProp<any>): T;
+    static bindInternal: (<T = string>(renderContext: VelcronRenderContext, bindTo: VelcronBindableProp<any>) => T) | null;
+    static getContextTokenValue<T>(renderContext: VelcronRenderContext, token: string): T | undefined;
     static isBindable<T = string>(bindable: VelcronBindableProp<T>): boolean;
     static getBindPath(text: string, removeStateToken?: boolean): string;
     static addCtxToVariableNames(template: string, skipIfNameStartsWith?: string, skipIfNameMatches?: Array<string>, overridePrefixWhenNameMatches?: {

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

@@ -0,0 +1,13 @@
+import { VelcronRenderContext } from "../models";
+import { VelcronBindableProp } from "..";
+export declare class VelcronDataBinder {
+    static bind<T = string>(renderContext: VelcronRenderContext, bindTo: VelcronBindableProp<any>): T;
+    private static interpolateTokens;
+    private static processToken;
+    private static evaluateSwitchExpression;
+    private static evaluateExpression;
+    static tryUpdateBoundValue(renderContext: VelcronRenderContext, bindPath: string, value: unknown): void;
+    static bindMany<T>(renderContext: VelcronRenderContext, definition: {
+        [P in keyof T]?: VelcronBindableProp<T[P]>;
+    }, propertiesToBind: Array<keyof T>, objectToBindTo: Partial<T>): T;
+}

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

@@ -1,8 +1,9 @@
 import { VelcronBorder, VelcronColorStyling, VelcronDefinitionHasEffects, VelcronDefinitionHasOverflow, VelcronDimensions, VelcronEffects, VelcronRenderContext } from "../models";
 import { VelcronUnitProvider } from "../models/VelcronUnitProvider";
 import { SpacingBlueprint, VelcronBindableProp, VelcronDefinition } from "..";
+import { CSSProperties, StylexType } from "internal/fx/ux/Styles.stylex";
 export declare class VelcronStyles {
-    static styleProvider: (baseStyles: object, definition: VelcronDefinition, renderCtx: VelcronRenderContext) => any;
+    static styleProvider: (baseStyles: CSSProperties, definition: VelcronDefinition, renderCtx: VelcronRenderContext) => StylexType;
     static effectsProvider: (effects: VelcronEffects, renderCtx: VelcronRenderContext) => VelcronEffects;
     static unitProvider: VelcronUnitProvider;
     spacingScaling: {
@@ -19,13 +20,13 @@ export declare class VelcronStyles {
             scaling: (value: import("..").SpacingValue) => boolean;
         };
     };
-    static registerStyleProvider(fn: (styleBase: object, definition: VelcronDefinition, renderCtx: VelcronRenderContext) => object | string, unitProvider: VelcronUnitProvider): void;
+    static registerStyleProvider(fn: (styleBase: CSSProperties, definition: VelcronDefinition, renderCtx: VelcronRenderContext) => StylexType, unitProvider: VelcronUnitProvider): void;
     static registerEffectsProvider(fn: (effects: VelcronEffects, renderCtx: VelcronRenderContext) => VelcronEffects): void;
     static applyEffects(definition: VelcronDefinitionHasEffects, renderCtx: VelcronRenderContext, applyTo: (effects: VelcronEffects) => any): any;
-    static insertBackgroundColor(styleBase: any, color: VelcronColorStyling, renderCtx: VelcronRenderContext): void;
-    static insertBorderRadiusStyles(styleBase: any, settings: VelcronDimensions): void;
-    static insertBorderStyles(styleBase: any, borderSettings: VelcronBorder, renderCtx: VelcronRenderContext): void;
-    static create(definition: VelcronDefinition, renderCtx: VelcronRenderContext): object | string;
+    static insertBackgroundColor(styleBase: CSSProperties, color: VelcronColorStyling, renderCtx: VelcronRenderContext): void;
+    static insertBorderRadiusStyles(styleBase: CSSProperties, settings: VelcronDimensions, renderCtx: VelcronRenderContext): void;
+    static insertBorderStyles(styleBase: CSSProperties, borderSettings: VelcronBorder, renderCtx: VelcronRenderContext): void;
+    static create(definition: VelcronDefinition, renderCtx: VelcronRenderContext): StylexType;
     static applySpacingDimension(value: string | number, spacing: SpacingBlueprint): string | number;
     static applyOverflow(definition: VelcronDefinitionHasOverflow, renderCtx: VelcronRenderContext, styleBase: any): void;
     static applySpacingStyles<T>(spacing: VelcronBindableProp<T>, renderCtx: VelcronRenderContext, styleBase: any, spacingDef: SpacingBlueprint, styleType: string, objectIsDatabound?: (obj: T) => void, additionalPropsToDataBind?: object): void;

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

@@ -6,3 +6,4 @@ export * from "./VelcronLogger";
 export * from "./VelcronRenderers";
 export * from "./TextValue";
 export * from "./VelcronPropertyEditors";
+export * from "./VelcronDataBinder";

package/internal-do-not-import-from-here/ux/velcron/core/stores/VelcronTheming.d.ts

@@ -1,7 +1,7 @@
-import { ColorSchemaType, ColorSchemaTypes, ColorType, ColorTypes, ContainerBlueprint, ContainerVariant, ThemeDefinitionV2, TypographySize, TypographySizes, TypographyType, TypographyTypes } from "..";
+import { ColorSchemaType, ColorSchemaTypes, ColorType, ColorTypes, ContainerBlueprint, ContainerVariant, ResolvedThemeDefinition, TypographySize, TypographySizes, TypographyType, TypographyTypes } from "..";
 export declare const useVelcronThemingStore: (newStateWithName?: string) => {
     state: {
-        currentTheme: ThemeDefinitionV2;
+        currentTheme: ResolvedThemeDefinition;
     };
     get: {
         componentBlueprints: () => void;
@@ -14,9 +14,9 @@ export declare const useVelcronThemingStore: (newStateWithName?: string) => {
         complementaryColorType: (colorType: ColorTypes | ColorType) => ColorTypes;
         complementaryColor: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => string;
         complementaryColorDefinition: (colorSchemaType: ColorSchemaTypes | ColorSchemaType, colorType: ColorTypes | ColorType) => import("..").ColorDefinition;
-        currentTheme: () => ThemeDefinitionV2;
+        currentTheme: () => ResolvedThemeDefinition;
     };
     actions: {
-        setTheme(newTheme: ThemeDefinitionV2): void;
+        setTheme(newTheme: ResolvedThemeDefinition): void;
     };
 };

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

@@ -7,14 +7,7 @@ declare const _default: {
         actionHandler: {
             type: import("vue").PropType<ActionHandlerInstance>;
         };
-    }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
-        close: {
-            type: import("vue").PropType<() => void>;
-        };
-        actionHandler: {
-            type: import("vue").PropType<ActionHandlerInstance>;
-        };
-    }>>, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+    }>>, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};

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

@@ -1,5 +1,5 @@
 declare const _default: {
-    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{}>>, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{}>>, () => JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};