@omnia/fx 8.0.295-dev → 8.0.297-dev

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

@@ -141,14 +141,14 @@ declare const _default: {
     };
 }>>, () => JSX.Element, unknown, {}, {}, 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<{} & {
+        width?: string | number;
         title?: string;
         description?: string;
         onCancel?: () => void;
-        width?: string | number;
         headerClass?: string;
         contentClass?: string;
-        modelValue?: boolean;
         "v-model"?: boolean;
+        modelValue?: boolean;
         "onUpdate:modelValue"?: (value: boolean) => any | void;
         onSave?: () => Promise<boolean>;
         disableSave?: boolean;

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

@@ -1,5 +1,5 @@
 import { CommentLikeTemplateDynamicInput } from "@omnia/fx/ux";
-import { Comment, OmitProperties, ThemeDefinition } from "../../models";
+import { Comment, OmitProperties, LegacyThemeDefinition } from "../../models";
 import { IRichTextEditor } from "../richtexteditor";
 import { CommentSorting } from "../../models/Social";
 declare const _default: {
@@ -20,7 +20,7 @@ declare const _default: {
             required: false;
         };
         cardStyle: {
-            type: import("vue").PropType<ThemeDefinition>;
+            type: import("vue").PropType<LegacyThemeDefinition>;
         };
         allowLikes: {
             type: import("vue").PropType<boolean>;
@@ -102,7 +102,7 @@ declare const _default: {
             required: false;
         };
         cardStyle: {
-            type: import("vue").PropType<ThemeDefinition>;
+            type: import("vue").PropType<LegacyThemeDefinition>;
         };
         allowLikes: {
             type: import("vue").PropType<boolean>;
@@ -181,7 +181,7 @@ declare const _default: {
         required: false;
     };
     cardStyle: {
-        type: import("vue").PropType<ThemeDefinition>;
+        type: import("vue").PropType<LegacyThemeDefinition>;
     };
     allowLikes: {
         type: import("vue").PropType<boolean>;
@@ -261,16 +261,16 @@ declare const _default: {
         richTextSettings?: OmitProperties<IRichTextEditor, "initialContent" | "onContentChange">;
         dynamicInput?: CommentLikeTemplateDynamicInput;
         additionalRoles?: string[];
-        cardStyle?: ThemeDefinition;
+        cardStyle?: LegacyThemeDefinition;
         hideEdit?: boolean;
         readOnly?: boolean;
         topicId?: string;
+        enableMention?: boolean;
         contextParams?: {
             [key: string]: string | number;
         };
         showMoreSize?: number;
         allowLikes?: boolean;
-        enableMention?: boolean;
         comments?: Comment[];
         enableBestReply?: boolean;
         canMarkBestReply?: boolean;

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

@@ -104,8 +104,8 @@ declare const _default: {
         autoFocus?: boolean;
         disabled?: boolean;
         richTextSettings?: OmitProperties<IRichTextEditor, "initialContent" | "onContentChange">;
-        enableMention?: boolean;
         resetContetnRte?: boolean;
+        enableMention?: boolean;
     }>, "onContentChanged" | "onDoc$" | "onRegisterFocus" | "onMentionChanged"> & {
         onContentChanged?: (content: string) => any;
         onDoc$?: (description?: string) => any;

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

@@ -15,11 +15,11 @@ declare const _default: {
             type: import("vue").PropType<ReactionVariants>;
             required: false;
         };
-        modelValue: {
+        "v-model": {
             type: import("vue").PropType<Required<IUserReaction>[]>;
             required: false;
         };
-        "v-model": {
+        modelValue: {
             type: import("vue").PropType<Required<IUserReaction>[]>;
             required: false;
         };
@@ -57,11 +57,11 @@ declare const _default: {
             type: import("vue").PropType<ReactionVariants>;
             required: false;
         };
-        modelValue: {
+        "v-model": {
             type: import("vue").PropType<Required<IUserReaction>[]>;
             required: false;
         };
-        "v-model": {
+        modelValue: {
             type: import("vue").PropType<Required<IUserReaction>[]>;
             required: false;
         };
@@ -91,11 +91,11 @@ declare const _default: {
         type: import("vue").PropType<ReactionVariants>;
         required: false;
     };
-    modelValue: {
+    "v-model": {
         type: import("vue").PropType<Required<IUserReaction>[]>;
         required: false;
     };
-    "v-model": {
+    modelValue: {
         type: import("vue").PropType<Required<IUserReaction>[]>;
         required: false;
     };
@@ -114,16 +114,16 @@ declare const _default: {
     "reaction:selected": (value: Required<IUserReaction>) => 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<{} & {
-        modelValue?: Required<IUserReaction>[];
-        "v-model"?: Required<IUserReaction>[];
-        "onUpdate:modelValue"?: (value: Required<IUserReaction>[]) => any | void;
         "v-slots"?: {
             default?: import("../DefineVueTypings").Slot;
         } & {
             activator: () => JSX.Element;
         };
+        "v-model"?: Required<IUserReaction>[];
+        modelValue?: Required<IUserReaction>[];
         variant?: ReactionVariants;
         stacked?: boolean;
+        "onUpdate:modelValue"?: (value: Required<IUserReaction>[]) => any | void;
     }>, "onUpdate:modelValue" | "onReaction:added" | "onReaction:removed" | "onReaction:selected"> & {
         "onUpdate:modelValue"?: (value: Required<IUserReaction>[]) => any;
         "onReaction:added"?: (value: Required<IUserReaction>) => any;

package/internal-do-not-import-from-here/ux/social/templates/CommentLikeTemplate.d.ts

@@ -1,5 +1,5 @@
 import { ICommentLikeService } from "../../../stores";
-import { type Comment, type CommentLikeTemplateSettings, ResolvedUserIdentity, ThemeDefinition, guid } from "../../../models";
+import { type Comment, type CommentLikeTemplateSettings, ResolvedUserIdentity, LegacyThemeDefinition, guid } from "../../../models";
 export interface CommentLikeTemplateDynamicInput {
     service: ICommentLikeService;
     likeListingTemplate?: string;
@@ -15,7 +15,7 @@ declare const _default: {
             required: false;
         };
         cardStyle: {
-            type: import("vue").PropType<ThemeDefinition>;
+            type: import("vue").PropType<LegacyThemeDefinition>;
         };
         additionalRoles: {
             type: import("vue").PropType<guid[]>;
@@ -66,7 +66,7 @@ declare const _default: {
             required: false;
         };
         cardStyle: {
-            type: import("vue").PropType<ThemeDefinition>;
+            type: import("vue").PropType<LegacyThemeDefinition>;
         };
         additionalRoles: {
             type: import("vue").PropType<guid[]>;
@@ -107,7 +107,7 @@ declare const _default: {
         required: false;
     };
     cardStyle: {
-        type: import("vue").PropType<ThemeDefinition>;
+        type: import("vue").PropType<LegacyThemeDefinition>;
     };
     additionalRoles: {
         type: import("vue").PropType<guid[]>;
@@ -151,7 +151,7 @@ declare const _default: {
         canShowEditDialogOnLoad?: boolean;
         canLike?: boolean;
         additionalRoles?: guid[];
-        cardStyle?: ThemeDefinition;
+        cardStyle?: LegacyThemeDefinition;
         hideEdit?: boolean;
         readOnly?: boolean;
     }>, "onDoc$" | "onOpenReply" | "onCancelReply" | "onRefresh"> & {

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

@@ -1,4 +1,4 @@
-import { ThemeDefinition, guid } from "../../models";
+import { LegacyThemeDefinition, guid } from "../../models";
 import { Theming } from "./Theming";
 import { ThemeStore } from "./ThemeStore";
 import { App, ComponentPublicInstance } from "vue";
@@ -6,7 +6,7 @@ export type VueThemingInstance = {
     $theming?: Theming;
     themeTargetId?: guid;
     themeDefinitionId?: guid;
-    themeDefinition?: ThemeDefinition;
+    themeDefinition?: LegacyThemeDefinition;
     inheritanceTheme?: {
         id: string;
     };

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

@@ -1,4 +1,4 @@
-import { Color, ThemeColorDefinition, ThemeStyling, ThemeDefinition, BorderDefinition } from "../../models";
+import { Color, LegacyThemeColorDefinition, ThemeStyling, LegacyThemeDefinition, LegacyBorderDefinition } from "../../models";
 import { OmniaTheming } from "../OmniaTheming";
 import { guid, ThemeType } from "../../models";
 export declare class ThemeManager {
@@ -12,7 +12,7 @@ export declare class ThemeManager {
     static ParseColor(color: string): Color;
     static ExtractReplacementColors(color: string): string;
     static InjectReplacementColors(color: string): string;
-    static EnsureDefaultBorder(themeDefinition: ThemeDefinition): void;
+    static EnsureDefaultBorder(themeDefinition: LegacyThemeDefinition): void;
     /**
      * We had model mismatch of BorderDefinition between client-side and server-side.
      *
@@ -21,8 +21,8 @@ export declare class ThemeManager {
      *
      * So this soft migration is all about that
      */
-    static MigrateBorder(borderDefinition: BorderDefinition): void;
-    static CreateThemeStylingFromDefinition(themeDefinition: ThemeColorDefinition): ThemeStyling;
-    static CreateDefaultBorderDefinition(): BorderDefinition;
-    static CreateThemeDefinition(primaryColor: string, secondaryColor: string, name: string, themeType: ThemeType, id?: guid, readOnly?: boolean): ThemeDefinition;
+    static MigrateBorder(borderDefinition: LegacyBorderDefinition): void;
+    static CreateThemeStylingFromDefinition(themeDefinition: LegacyThemeColorDefinition): ThemeStyling;
+    static CreateDefaultBorderDefinition(): LegacyBorderDefinition;
+    static CreateThemeDefinition(primaryColor: string, secondaryColor: string, name: string, themeType: ThemeType, id?: guid, readOnly?: boolean): LegacyThemeDefinition;
 }

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

@@ -1,13 +1,13 @@
 import { OmniaContext } from "../..";
 import { Store } from "../../stores";
-import { ThemeDefinitionSettings, ThemeDefinition, ThemeTargetRegistration, ThemeTargetMapping } from "../../models";
+import { ThemeDefinitionSettings, LegacyThemeDefinition, ThemeTargetRegistration, ThemeTargetMapping } from "../../models";
 import { IMessageBusSubscriptionHandler, guid } from "../../models";
 import { OmniaTheming } from "../OmniaTheming";
 import { SettingsService } from "../../services";
 import { Theming } from "./Theming";
 declare class InternalThemeStore extends Store {
     showThemeDefinitionEditor: import("../../stores").StoreState<boolean>;
-    themeDefinitions: import("../../stores").StoreState<ThemeDefinition[]>;
+    themeDefinitions: import("../../stores").StoreState<LegacyThemeDefinition[]>;
     themeTargetRegistrations: import("../../stores").StoreState<ThemeTargetRegistration[]>;
     themeTargetMappings: import("../../stores").StoreState<ThemeTargetMapping[]>;
     themingInstances: import("../../stores").StoreState<Theming[]>;
@@ -37,8 +37,8 @@ export declare class ThemeStore extends Store {
         getThemingByTargetIdWithFallback: (themeTargetId: guid) => Theming;
         getAllThemeTargetMappings: () => ThemeTargetMapping[];
         getThemeTargetMappingById: (id: guid) => ThemeTargetMapping;
-        getAllThemeDefinitions: () => ThemeDefinition[];
-        getThemeDefinitionById: (id: guid) => ThemeDefinition;
+        getAllThemeDefinitions: () => LegacyThemeDefinition[];
+        getThemeDefinitionById: (id: guid) => LegacyThemeDefinition;
         getThemeTargetRegistrationsById: (id: guid) => ThemeTargetRegistration;
         getAllThemeTargetRegistrations: () => ThemeTargetRegistration[];
     };
@@ -48,13 +48,13 @@ export declare class ThemeStore extends Store {
         createThemeTargetMappingForRegistration: import("../../stores").StoreMutation<(themeTargetRegistration: ThemeTargetRegistration) => void, (themeTargetRegistration: ThemeTargetRegistration) => IMessageBusSubscriptionHandler>;
         addThemeTargetRegistration: import("../../stores").StoreMutation<(themeTargetRegistration: ThemeTargetRegistration) => void, (themeTargetRegistration: ThemeTargetRegistration) => IMessageBusSubscriptionHandler>;
         removeAllCustomThemeDefintions: import("../../stores").StoreMutation<() => void, () => IMessageBusSubscriptionHandler>;
-        addThemeDefinition: import("../../stores").StoreMutation<(theme: ThemeDefinition, forceUpdate?: boolean) => void, (theme: ThemeDefinition, forceUpdate?: boolean) => IMessageBusSubscriptionHandler>;
+        addThemeDefinition: import("../../stores").StoreMutation<(theme: LegacyThemeDefinition, forceUpdate?: boolean) => void, (theme: LegacyThemeDefinition, forceUpdate?: boolean) => IMessageBusSubscriptionHandler>;
     };
     actions: {
         updateThemeTargetMapping: import("../../stores").StoreAction<unknown, (themeTargetMapping: ThemeTargetMapping) => void, (result: void, themeTargetMapping: ThemeTargetMapping) => void, (failureReason: any, themeTargetMapping: ThemeTargetMapping) => void, (themeTargetMapping: ThemeTargetMapping) => Promise<void>>;
         ensureThemeDefinitions: import("../../stores").StoreAction<unknown, () => void, (result: void) => void, (failureReason: any) => void, () => Promise<void>>;
-        saveThemeDefintion: import("../../stores").StoreAction<unknown, (themeDefinition: ThemeDefinition) => void, (result: void, themeDefinition: ThemeDefinition) => void, (failureReason: any, themeDefinition: ThemeDefinition) => void, (themeDefinition: ThemeDefinition) => Promise<void>>;
-        deleteThemeDefintion: import("../../stores").StoreAction<unknown, (themeDefinition: ThemeDefinition) => void, (result: void, themeDefinition: ThemeDefinition) => void, (failureReason: any, themeDefinition: ThemeDefinition) => void, (themeDefinition: ThemeDefinition) => Promise<void>>;
+        saveThemeDefintion: import("../../stores").StoreAction<unknown, (themeDefinition: LegacyThemeDefinition) => void, (result: void, themeDefinition: LegacyThemeDefinition) => void, (failureReason: any, themeDefinition: LegacyThemeDefinition) => void, (themeDefinition: LegacyThemeDefinition) => Promise<void>>;
+        deleteThemeDefintion: import("../../stores").StoreAction<unknown, (themeDefinition: LegacyThemeDefinition) => void, (result: void, themeDefinition: LegacyThemeDefinition) => void, (failureReason: any, themeDefinition: LegacyThemeDefinition) => void, (themeDefinition: LegacyThemeDefinition) => Promise<void>>;
     };
     private updateBusinessProfileThemeMapping;
 }

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

@@ -1,5 +1,5 @@
 import { guid } from "../../models";
-import { ThemeTargetMapping, ThemeStyling, ThemeDefinition, ThemeColors } from "../../models";
+import { ThemeTargetMapping, ThemeStyling, LegacyThemeDefinition, ThemeColors } from "../../models";
 export interface ITheming {
     colors: ThemeColors;
     body: ThemeStyling;
@@ -27,7 +27,7 @@ export declare class Theming implements ITheming {
     setThemeTargetMapping(themeTargetMapping: ThemeTargetMapping): void;
     private get themingModel();
     private breakThemingInheritance;
-    setThemeDefinition(themingDefinition: ThemeDefinition): void;
+    setThemeDefinition(themingDefinition: LegacyThemeDefinition): void;
     private getThemeDefinition;
     private getOmniaState;
 }
@@ -36,6 +36,6 @@ export declare class Theming implements ITheming {
  */
 export declare function useTheme(): {
     theming: ITheming;
-    setTheming: (themingDefinition: ThemeDefinition) => void;
+    setTheming: (themingDefinition: LegacyThemeDefinition) => void;
 };
 export {};

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

@@ -323,8 +323,8 @@ declare const _default: {
         };
         label?: string;
         disabled?: boolean;
-        modelValue?: TimePeriodSettings;
         "v-model"?: TimePeriodSettings;
+        modelValue?: TimePeriodSettings;
         "onUpdate:modelValue"?: (value: TimePeriodSettings) => any | void;
         hideDetails?: boolean;
         min?: number;

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

@@ -354,8 +354,8 @@ declare const _default: {
         };
         label?: string;
         disabled?: boolean;
-        modelValue?: UrlPropertyValue;
         "v-model"?: UrlPropertyValue;
+        modelValue?: UrlPropertyValue;
         "onUpdate:modelValue"?: (value: UrlPropertyValue) => any | void;
         requiredWithValidator?: IValidator;
         defaultUrlResolving?: boolean;

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

@@ -1,3 +1,7 @@
 export declare function useColorSchemaSetup(props: object): import("../aurora/store").ColorSchemaStoreType & {
+    actions: {
+        disableAutoDispose(): void;
+    };
+} & {
     dispose?: () => void;
 };

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

@@ -2,7 +2,7 @@ import { ConstructComponentProps } from "../InternalDefineComponent";
 import { type DraggableComponentProps } from "../draggable/DraggableComponent";
 type DraggableComponentTypings = (props: ConstructComponentProps<Omit<DraggableComponentProps, "containerRef" | "countItems">>) => any;
 export declare const DraggableStyles: {
-    hoverStyle: import("../Styles.stylex").StylexType;
+    hoverStyle: import("../Styles.stylex").StylexValue;
 };
 export declare function useDraggable(): {
     Draggable: DraggableComponentTypings;
@@ -21,7 +21,7 @@ export declare function useDraggable(): {
     } & {
         toned?: boolean;
     } & {
-        colorType?: "base" | "onBase" | "container" | "onContainer";
+        colorType?: "container" | "base" | "onBase" | "onContainer";
     } & {
         variant?: "background" | "default";
     } & {

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

@@ -317,8 +317,8 @@ declare const _default: {
         styles?: {
             container?: import("@omnia/fx-models").NestedCSSPropertiesExtends;
         };
-        modelValue?: UserIdentity;
         "v-model"?: UserIdentity;
+        modelValue?: UserIdentity;
         "onUpdate:modelValue"?: (value: UserIdentity) => any | void;
         offsetX?: number;
         offsetY?: number;

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

@@ -1,3 +1,3 @@
 import { VelcronDefinition, VelcronRenderContext } from "@omnia/fx-models";
-import { NestedCSSProperties } from "typestyle/lib/types";
-export declare function velcronStylesProvider(result: NestedCSSProperties, definition: VelcronDefinition, renderCtx: VelcronRenderContext): string;
+import { type CSSProperties } from "../Styles.stylex";
+export declare function velcronStyleProvider(result: CSSProperties, definition: VelcronDefinition, renderCtx: VelcronRenderContext): import("../Styles.stylex").StylexValue;

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

@@ -454,19 +454,19 @@ declare const _default: {
             }>;
         };
         icon?: IIcon;
-        title?: string;
         container?: boolean;
-        colorSchemaType?: "background" | "primary" | "secondary" | import("@omnia/fx-models").ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";
+        title?: string;
         colors?: import("@omnia/fx/ux").ColorSchemaStoreType;
-        modelValue?: boolean;
-        "v-model"?: boolean;
-        "onUpdate:modelValue"?: (value: boolean) => any | void;
+        colorSchemaType?: "background" | "primary" | "secondary" | import("@omnia/fx-models").ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";
         "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

@@ -370,10 +370,10 @@ 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>;
+        colorSchemaType?: "background" | "primary" | "secondary" | import("@omnia/fx-models").ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";
         "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

@@ -332,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

@@ -5,6 +5,7 @@ import { DynamicState, VelcronDefinition, VelcronEffects, useVelcronThemingStore
 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;
@@ -37,6 +38,7 @@ export interface BuiltInComponentRenderers {
     "slide-panel": unknown;
     "editor": unknown;
     "link": unknown;
+    "motion": unknown;
 }
 export interface ColorSchemaReference {
     name: string;
@@ -327,23 +329,17 @@ 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;

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

@@ -9,5 +9,5 @@ export declare class VelcronDataBinder {
     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>, state: Partial<T>): void;
+    }, 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, StylexValue } 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) => StylexValue;
     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) => StylexValue, 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, renderCtx: VelcronRenderContext): 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): StylexValue;
     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/editor/stores/VelcronEditorStore.d.ts

@@ -1,7 +1,7 @@
 import { guid, TreeViewItem, VelcronAppDefinition, VelcronDefinition, VelcronDefinitionRegistrationWithoutApp } from "@omnia/fx-models";
 import { AppTreeItem, AppValidationState, EditorAppTreeItem, StatePropertyAppTreeItem, editorModes } from "../models/Shared";
 import { CodeEditorState, VelcronComponentDescriptor, codeEditorTabs, AddVelcronComponentMode } from "../models";
-import { ThemeDefinitionV2, VelcronRenderContext, VelcronEditor } from "../../core";
+import { ResolvedThemeDefinition, VelcronRenderContext, VelcronEditor } from "../../core";
 type canvasMode = "split-spacing" | "design";
 export declare const useVelcronEditorStore: () => {
     get: {
@@ -32,7 +32,7 @@ export declare const useVelcronEditorStore: () => {
         definition(asJson?: boolean): VelcronAppDefinition | string;
     };
     state: {
-        previewTheme: ThemeDefinitionV2;
+        previewTheme: ResolvedThemeDefinition;
         previewRenderContext: VelcronRenderContext;
         canvasMode: canvasMode;
         appData: {};
@@ -347,7 +347,7 @@ export declare const useVelcronEditorStore: () => {
         updateHistory(): void;
     };
     events: {
-        onMutatedPreviewTheme: import("@omnia/fx").MessageBusExposeOnlySubscription<ThemeDefinitionV2>;
+        onMutatedPreviewTheme: import("@omnia/fx").MessageBusExposeOnlySubscription<ResolvedThemeDefinition>;
         onMutatedPreviewRenderContext: import("@omnia/fx").MessageBusExposeOnlySubscription<VelcronRenderContext>;
         onMutatedCanvasMode: import("@omnia/fx").MessageBusExposeOnlySubscription<canvasMode>;
         onMutatedAppData: import("@omnia/fx").MessageBusExposeOnlySubscription<{}>;

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

@@ -1,5 +1,5 @@
-import { VelcronAppDefinition, VelcronRenderContext } from "@omnia/fx-models";
-import { ThemeDefinitionV2, VelcronRenderContextEventHandlers, ColorSchemaTypes, ColorSchemaType, DynamicState } from "../core";
+import { ColorSchemaType, ColorSchemaTypes, ResolvedThemeDefinition, VelcronAppDefinition, VelcronRenderContext } from "@omnia/fx-models";
+import { VelcronRenderContextEventHandlers, DynamicState } from "../core";
 declare const _default: {
     new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
         colorSchemaType: {
@@ -21,7 +21,7 @@ declare const _default: {
             type: import("vue").PropType<boolean>;
         };
         themeDefinition: {
-            type: import("vue").PropType<ThemeDefinitionV2>;
+            type: import("vue").PropType<ResolvedThemeDefinition>;
         };
         eventHandlers: {
             type: import("vue").PropType<VelcronRenderContextEventHandlers>;
@@ -68,7 +68,7 @@ declare const _default: {
             type: import("vue").PropType<boolean>;
         };
         themeDefinition: {
-            type: import("vue").PropType<ThemeDefinitionV2>;
+            type: import("vue").PropType<ResolvedThemeDefinition>;
         };
         eventHandlers: {
             type: import("vue").PropType<VelcronRenderContextEventHandlers>;
@@ -109,7 +109,7 @@ declare const _default: {
         type: import("vue").PropType<boolean>;
     };
     themeDefinition: {
-        type: import("vue").PropType<ThemeDefinitionV2>;
+        type: import("vue").PropType<ResolvedThemeDefinition>;
     };
     eventHandlers: {
         type: import("vue").PropType<VelcronRenderContextEventHandlers>;
@@ -135,9 +135,9 @@ declare const _default: {
     } & {
         container?: boolean;
         active?: boolean;
-        colorSchemaType?: "background" | "primary" | "secondary" | ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";
         colors?: import("@omnia/fx/ux").ColorSchemaStoreType;
-        themeDefinition?: ThemeDefinitionV2;
+        colorSchemaType?: "background" | "primary" | "secondary" | ColorSchemaTypes | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "neutral" | "warning" | "notification" | "error" | "info" | "success" | "dynamic";
+        themeDefinition?: ResolvedThemeDefinition;
         context?: VelcronRenderContext;
         editMode?: boolean;
         eventHandlers?: VelcronRenderContextEventHandlers;

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

@@ -2,6 +2,6 @@
  * Styles for the VelcronRenderer component
  */
 declare const _default: {
-    container: import("@omnia/fx/ux").StylexType;
+    container: import("@omnia/fx/ux").StylexValue;
 };
 export default _default;

package/internal-do-not-import-from-here/ux/velcron/renderer/components/Motion.d.ts

@@ -0,0 +1,29 @@
+import { VelcronRenderContext, VelcronMotionDefinition } from "../../core";
+declare const _default: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        definition: import("vue").Prop<VelcronMotionDefinition, VelcronMotionDefinition>;
+        renderContext: import("vue").Prop<VelcronRenderContext, VelcronRenderContext>;
+    }>>, {}, {}, {}, {}, 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<{
+        definition: import("vue").Prop<VelcronMotionDefinition, VelcronMotionDefinition>;
+        renderContext: import("vue").Prop<VelcronRenderContext, VelcronRenderContext>;
+    }>>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    definition: import("vue").Prop<VelcronMotionDefinition, VelcronMotionDefinition>;
+    renderContext: import("vue").Prop<VelcronRenderContext, VelcronRenderContext>;
+}>>, {}, {}, {}, {}, 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<{} & {
+        definition?: VelcronMotionDefinition;
+        renderContext?: VelcronRenderContext;
+    }>, never>;
+};
+export default _default;