@omnia/fx 8.0.18-vnext → 8.0.19-dev

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

@@ -1,61 +1,63 @@
-import { VelcronComponentDescriptor } from "./VelcronDescriptors";
-import { VelcronEvent, VelcronOnChangedEvent, VelcronOnClosedEvent, VelcronOnCloseRequestedEvent, VelcronOnLoadEvent, VelcronOnPressEvent } from "./VelcronEvents";
+import { VelcronEvent, VelcronOnUpdatedEvent, VelcronOnClosedEvent, VelcronOnCloseRequestedEvent, VelcronOnEditModeEvent, VelcronOnLoadEvent, VelcronOnPressEvent } from "./VelcronEvents";
 import { VelcroncomponentArrayType, VelcronPrimitiveType } from "./VelcronTypes";
-import { AssignOperators, VelcronHorizontalAlignments, VelcronIconTypes, VelcronActionTypes, VerticalAlignments } from "./Enums";
-import { ColorSchema, ColorSchemaType, ColorSchemaTypes, useVelcronThemingStore } from "..";
+import { AssignOperators, VelcronHorizontalAlignments, VelcronIconTypes, VelcronActionTypes, VelcronVerticalAlignments } from "./Enums";
+import { DynamicState, VelcronPropertyEditor, useVelcronThemingStore } from "..";
+import { GuidValue, PropertyConfiguration, PropertyValue, PropertyDefinition, PropertySetupBase } from "@omnia/fx/models";
+import { useVelcronColorSchemaStore } from "../stores/VelcronColorSchema";
+import { useVelcronBlueprintStore } from "../stores/VelcronBlueprint";
 export interface ResolvedComponentRenderer {
     component: unknown;
     definition: VelcronDefinition;
-    customComponent: boolean;
+    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;
-    "FlexView": unknown;
-    "Icon": unknown;
-    "Chip": 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;
+    "slot": unknown;
+    "property": unknown;
+    "checkbox": unknown;
 }
 export interface ColorSchemaReference {
     name: string;
     schema: string;
 }
-export interface VelcronState {
-    colorSchemas?: {
-        [key: string]: ColorSchemaReference;
-    };
-}
 export interface OnItemRenderedHookResult {
     cssClass: string;
     containerRenderer?: VelcronContainerRenderer;
 }
 export interface VelcronRenderContext {
     id?: string;
-    rootContext: VelcronState;
-    currentContext: VelcronState;
+    rootContext: DynamicState;
+    currentContext: DynamicState;
     theming?: ReturnType<typeof useVelcronThemingStore>;
-    colorSchemaType?: ColorSchemaTypes | ColorSchemaType;
-    colorSchema?: ColorSchema;
+    colors?: ReturnType<typeof useVelcronColorSchemaStore>;
+    blueprints?: ReturnType<typeof useVelcronBlueprintStore>;
     actions?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
     components?: Array<VelcronCustomComponentDefinition>;
     properties?: {
         [name: string]: VelcronPrimitiveType | VelcroncomponentArrayType;
     };
     computed?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
     parent?: VelcronRenderContext;
     hooks?: VelcronRenderContextHooks;
     eventHandlers?: VelcronRenderContextEventHandlers;
+    editMode?: boolean;
+    disposers: Array<() => void>;
 }
 export interface VelcronRenderContextEventHandlers {
     receiving?: {
@@ -67,6 +69,7 @@ export interface VelcronRenderContextHooks {
     dialogVisibilityChanged?: ((visible: boolean) => void);
     onItemSelected?: ((item: VelcronDefinition) => void);
     onItemRendered?: ((item: VelcronDefinition) => OnItemRenderedHookResult);
+    onItemCreatedProps?: ((item: VelcronDefinition) => object);
 }
 export interface VelcronContainerRenderer {
     definition: VelcronDefinition;
@@ -108,18 +111,34 @@ export interface VelcronDefinitionBase {
      */
     key?: string;
 }
-export interface VelcronCustomThemeSettings {
-    colorSchema?: string;
-    color?: string;
-    opacity?: number;
-}
-export interface VelcronDefinition extends VelcronDefinitionBase {
+export interface VelcronDefinition extends VelcronDefinitionBase, VelcronDimensionStyling {
     body?: Array<VelcronDefinition>;
     style?: VelcronStyling;
     foreach?: string;
     if?: string;
     events?: VelcronEvent;
 }
+export type VelcronBindableProp<TPropType = string> = TPropType | string;
+export interface VelcronDefinitionWithEditMode extends VelcronDefinition {
+    edit?: VelcronBindableProp<boolean>;
+    bind?: VelcronBindableProp;
+}
+interface VelcronDimensionStyling {
+    margin?: VelcronSpacing;
+    padding?: VelcronSpacing;
+}
+export interface VelcronColorStyling {
+    colorSchemaType?: string;
+    colorType?: string;
+    filled?: boolean;
+    toned?: boolean;
+    color?: string;
+}
+export interface VelcronTextStyling {
+    text: string;
+    typography?: string;
+    size?: string;
+}
 export interface VelcronStyling {
     margin?: number;
     marginTop?: number;
@@ -138,131 +157,166 @@ export interface VelcronCardStyling extends VelcronStyling {
     elevation: number;
 }
 export interface VelcronSpacing {
-    top: number;
-    right: number;
-    bottom: number;
-    left: number;
+    top?: number | string;
+    right?: number | string;
+    bottom?: number | string;
+    left?: number | string;
 }
 export interface VelcronIcon {
     type: VelcronIconTypes;
     name: string;
 }
-export interface VelcronAppDefinition extends VelcronDefinitionBase {
-    type: "App";
+export interface VelcronAppDefinition<TState extends DynamicState = DynamicState> extends VelcronDefinitionBase {
+    type: "velcron";
+    version?: string;
+    name?: string;
     body?: Array<VelcronDefinition>;
-    events?: VelcronOnLoadEvent & VelcronOnPressEvent;
+    events?: VelcronOnLoadEvent & VelcronOnEditModeEvent;
     actions?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
     components?: Array<VelcronCustomComponentDefinition>;
-    state?: VelcronState;
+    propEditors?: Array<VelcronPropertyEditor>;
+    state?: TState;
     computed?: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     };
 }
 export interface VelcronComponentDefinition extends VelcronDefinition {
     type: string;
-    events: VelcronOnPressEvent;
+    events?: any;
+    properties?: {
+        [name: string]: any;
+    };
+    icon?: any;
+}
+export interface VelcronRenderProp {
+    required?: boolean;
+    defaultValue?: any;
 }
 /*** Built-in Components *********************************************************************/
-export interface VelcronViewDefinition extends VelcronDefinition {
-    type: "View";
-    style?: VelcronStyling;
+export interface VelcronViewDefinition extends VelcronDefinition, VelcronColorStyling {
+    type: "view";
     events?: VelcronOnPressEvent;
+    direction?: VelcronBindableProp<"row" | "column" | "row-reverse" | "column-reverse">;
+    columnStyle?: object;
+    hAlign?: VelcronHorizontalAlignments;
+    vAlign?: VelcronVerticalAlignments;
+    grow?: number;
+    absolute?: VelcronSpacing;
+    border?: VelcronBorder;
+    borderRadius?: VelcronDimensions;
+    width?: number | string;
+    minWidth?: number | string;
+    height?: number | string;
+    minHeight?: number | string;
 }
-export interface VelcronCardDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
-    type: "Card";
+export interface VelcronCardDefinition extends VelcronDefinition, VelcronColorStyling {
+    type: "card";
     style?: VelcronCardStyling;
     footer?: Array<VelcronDefinition>;
     events?: VelcronOnPressEvent;
 }
-export interface VelcronTextDefinition extends VelcronDefinition {
-    type: "Text";
-    text: string;
-    color?: string;
-    lineClamp: number;
-    noWrap: boolean;
-    typography?: string;
-    events?: VelcronOnPressEvent;
+export interface VelcronTextDefinition extends VelcronDefinitionWithEditMode, VelcronColorStyling, VelcronTextStyling {
+    type: "text";
+    editLabel?: VelcronBindableProp;
+    lineClamp?: number;
+    noWrap?: boolean;
+    events?: VelcronOnPressEvent & VelcronOnUpdatedEvent;
 }
 export declare enum VelcronImageRatios {
-    square = 1,
-    landscape = 2
+    square = "square",
+    landscape = "landscape"
 }
 export interface VelcronImageDefinition extends VelcronDefinition {
-    type: "Image";
-    source: string;
-    ratio: VelcronImageRatios;
+    type: "image";
+    url?: VelcronBindableProp<string>;
+    bind?: VelcronBindableProp<string>;
+    ratio?: VelcronImageRatios | string;
+    cover?: VelcronBindableProp<boolean>;
     borderRadius?: VelcronDimensions;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronButtonDefinition extends VelcronDefinition {
-    type: "Button";
+    type: "button";
     text: string;
-    color: string;
     icon?: VelcronIcon;
     disabled?: boolean;
     events?: VelcronOnPressEvent;
 }
 export interface VelcronTextInputDefinition extends VelcronDefinition {
-    type: "TextInput";
+    type: "text-input";
     label?: string;
     bind: string;
     initialValue?: string;
-    events: VelcronOnChangedEvent;
+    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, VelcronCustomThemeSettings {
-    type: "Icon";
+export interface VelcronIconDefinition extends VelcronDefinition, VelcronColorStyling {
+    type: "icon";
     icon: string;
-    background?: boolean;
-    size?: number;
+    size?: VelcronBindableProp<number>;
     events?: VelcronOnPressEvent;
 }
-export interface VelcronFlexViewDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
-    type: "FlexView";
-    column?: boolean;
-    body: Array<VelcronDefinition>;
-    columnStyle?: object;
-    horizontalAlignment?: VelcronHorizontalAlignments;
-    verticalAlignment?: VerticalAlignments;
-    grow?: number;
-    border?: VelcronBorder;
-    borderRadius?: VelcronDimensions;
-    width: string;
+export interface VelcronMarkdownDefinition extends VelcronDefinitionWithEditMode, VelcronColorStyling, VelcronTextStyling {
+    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;
+    colorType?: string;
+    toned?: boolean;
+    opacity?: number;
 }
-export interface VelcronChipDefinition extends VelcronDefinition, VelcronCustomThemeSettings {
-    type: "Chip";
+export interface VelcronChipDefinition extends VelcronDefinition {
+    type: "chip";
     text: string;
     icon?: VelcronIcon;
     disabled?: boolean;
     events?: VelcronOnPressEvent;
 }
-/*** Custom Components ***********************************************************************/
-export type VelcronCustomComponentDefinition = VelcronComponentDescriptor & VelcronComponentDefinition;
+export interface VelcronSlotDefinition extends VelcronDefinition {
+    type: "slot";
+    bind: VelcronBindableProp<string>;
+}
+export interface VelcronPropertyDefinition extends VelcronDefinition {
+    type: "property";
+    bind: VelcronBindableProp<string>;
+}
+export interface VelcronCheckboxDefinition extends VelcronDefinition {
+    type: "checkbox";
+    label: VelcronBindableProp<string>;
+    value: string;
+    bind: VelcronBindableProp<string>;
+    disabled: VelcronBindableProp<boolean>;
+    events: VelcronOnUpdatedEvent;
+}
+export interface VelcronPropertyDefinitionValue {
+    definitionId: GuidValue;
+    value: PropertyValue;
+    configuration: PropertyConfiguration<PropertyDefinition<any, any, any, PropertySetupBase>>;
+}
+export type VelcronCustomComponentDefinition = VelcronComponentDefinition;
 export type VelcronRenderProps<TDefinition> = {
     definition: TDefinition;
     renderContext: VelcronRenderContext;
 };
+export {};

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

@@ -4,8 +4,11 @@ export type VelcronOnPressEvent = {
 export type VelcronOnLoadEvent = {
     onLoaded?: Array<string>;
 };
-export type VelcronOnChangedEvent = {
-    onChanged?: Array<string>;
+export type VelcronOnEditModeEvent = {
+    onEditMode?: Array<string>;
+};
+export type VelcronOnUpdatedEvent = {
+    onUpdated?: Array<string>;
 };
 export type VelcronOnCloseRequestedEvent = {
     onCloseRequested?: Array<string>;

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

@@ -0,0 +1,137 @@
+import { TypographySize, TypographyType, VelcronImageRatios } from "@omnia/fx-models";
+export interface ResolvedPropertyEditor {
+    editor: VelcronPropertyEditor;
+}
+export interface VelcronPropertyEditor<TSettings = any> {
+    name?: string;
+    category?: string;
+    type: BuiltInPropertyEditorType | string;
+    settings?: TSettings;
+    stateMapping?: string;
+    propertyMapping?: boolean;
+    multiple?: boolean;
+    component?: unknown;
+}
+export interface BuiltInPropertyEditors {
+    text: unknown;
+    slider: unknown;
+    switch: unknown;
+    alignment: unknown;
+    color: unknown;
+    markdown: unknown;
+    icon: unknown;
+    image: unknown;
+    typography: unknown;
+    "color-schema-type": unknown;
+}
+export type BuiltInPropertyEditorType = "text" | "slider" | "switch" | "alignment" | "color" | "markdown" | "icon" | "image" | "typography" | "color-schema-type";
+export declare enum BuiltInPropertyEditorTypes {
+    text = "text",
+    slider = "slider",
+    switch = "switch",
+    alignment = "alignment",
+    color = "color",
+    markdown = "markdown",
+    icon = "icon",
+    image = "image",
+    typography = "typography",
+    "color-schema-type" = "color-schema-type"
+}
+export interface VelcronSliderPropertyEditorSettings {
+    min: number;
+    max: number;
+    step: number;
+}
+export interface VelcronTypographyEditorSettings {
+    type: "title" | "text";
+}
+export interface VelcronSliderPropertyEditor extends VelcronPropertyEditor<VelcronSliderPropertyEditorSettings> {
+    type: "slider";
+}
+export interface VelcronTextPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "text";
+}
+export interface VelcronEnterprisePropertyEditor extends VelcronPropertyEditor<any> {
+    type: "enterprise-property";
+}
+export interface VelcronTypographyPropertyEditor extends VelcronPropertyEditor<VelcronTypographyEditorSettings> {
+    type: "typography";
+}
+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 VelcronColorSchemaPropertyEditor extends VelcronPropertyEditor<any> {
+    type: "color-schema-type";
+}
+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 VelcronState {
+    images?: VelcronImagesState;
+    styling?: VelcronStylingState;
+    colorSchema?: VelcronColorSchemaState;
+    content?: VelcronContentState;
+    header?: VelcronHeaderState;
+    properties?: VelcronPropertiesState;
+}
+export interface VelcronHeaderState {
+    title?: VelcronTextState;
+    icon?: string;
+}
+export declare const VelcronHeaderStateBinding: {
+    title: {
+        text: string;
+        typography: {
+            editor: any;
+            type: any;
+            size: any;
+            toned: any;
+        };
+    };
+    icon: string;
+};
+export interface VelcronTextState {
+    text: string;
+    typography?: VelcronTypographyState;
+}
+export interface VelcronTypographyState {
+    type?: TypographyType;
+    size?: TypographySize;
+    toned?: boolean;
+}
+export interface VelcronContentState {
+    caption?: VelcronTextState;
+    main?: VelcronTextState;
+    title?: VelcronTextState;
+    summary?: VelcronTextState;
+}
+export interface VelcronPropertiesState {
+    user: any;
+    mappings: Array<any>;
+}
+export interface VelcronImagesState {
+    main?: VelcronImageState;
+}
+export interface VelcronImageState {
+    url?: string;
+    ratio?: VelcronImageRatios;
+    caption?: VelcronTextState;
+}
+export interface VelcronStylingState {
+}
+export interface VelcronColorSchemaState {
+    type?: string;
+    filled?: boolean;
+}

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

@@ -1,7 +1,8 @@
 export * from "./VelcronDefinitions";
 export * from "./ViewModelAndContext";
-export * from "./VelcronDescriptors";
 export * from "./VelcronEvents";
 export * from "./VelcronTypes";
 export * from "./Enums";
 export * from "./VelcronUnitProvider";
+export * from "./VelcronPropertyEditorDefinitions";
+export * from "./ActionHooks";

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

@@ -1,13 +1,16 @@
-import { VelcronAction, VelcronActionWithAutoAwait, VelcronRenderContext, DeferredPromise } from "../models";
+import { VelcronAction, VelcronActionWithAutoAwait, VelcronRenderContext, DeferredPromise, VelcronActionHooks } from "../models";
 import { IActionHandler } from "../actions";
 export declare class VelcronActions {
     static _actionHandlers: {
         [name: string]: IActionHandler;
     } | null;
+    static actionHooks: {
+        [name: string]: VelcronActionHooks;
+    };
     static registerAction(name: string, handler: IActionHandler): void;
     static parseAndExecuteActions(templates: Array<string>, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): void;
     static parseFunction(target: {
-        [name: string]: [];
+        [name: string]: Array<string>;
     }, template: string, renderContext: VelcronRenderContext, params: Array<VelcronActionParameterValue>, foundCb: (name: string, params: {}) => void): void;
     static getActionFromTemplate(partialTemplate: string, eventId: string, renderContext: VelcronRenderContext, customActionContext?: VelcronCustomActionExecutionContext): VelcronAction;
     static valueIsAction(value: string): boolean;
@@ -15,6 +18,9 @@ export declare class VelcronActions {
     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;
     private static extractParameterValues;
 }
 interface VelcronActionParameterValue {

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

@@ -1,18 +1,22 @@
 export declare const VelcronConstants: {
     components: {
-        app: string;
+        velcron: string;
         view: string;
         card: string;
         text: string;
         image: string;
         button: string;
-        textInput: string;
-        progressCircle: string;
-        webView: string;
+        "text-input": string;
+        "progress-circle": string;
+        "web-view": string;
+        "custom-component": string;
         dialog: string;
-        flexView: string;
         icon: string;
         chip: string;
+        markdown: string;
+        slot: string;
+        property: string;
+        checkbox: string;
     };
     events: {
         idTokenStart: string;
@@ -25,5 +29,9 @@ export declare const VelcronConstants: {
     properties: {
         tokenStart: string;
         tokenEnd: string;
+        propsToken: string;
+    };
+    context: {
+        thisToken: string;
     };
 };

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

@@ -1,10 +1,10 @@
-import { VelcronAppDefinition, VelcronDefinition, VelcronRenderContext, DeferredPromise } from "../models";
+import { VelcronAppDefinition, VelcronDefinition, VelcronRenderContext, DeferredPromise, VelcronBindableProp } from "../models";
 export interface ParseResult<T> {
     is: boolean;
     value: T;
 }
 export declare class VelcronData {
-    static dataBind(renderContext: VelcronRenderContext, text: string): string;
+    static dataBind(renderContext: VelcronRenderContext, text: VelcronBindableProp<any>): string;
     static addCtxToVariableNames(template: string, skipIfNameStartsWith?: string, skipIfNameMatches?: Array<string>, overridePrefixWhenNameMatches?: {
         [name: string]: string;
     }): string;
@@ -26,7 +26,7 @@ export declare class VelcronData {
     static extendObject(obj: any): any;
     static getOrSetObjectByPath<T>(object: Object, path: string, value?: any): T | null;
     static getOrSetObjectByPathUsingRenderContext<T>(renderContext: VelcronRenderContext, path: string, value?: any): T;
-    static getTokens(template: any): string[];
+    static getTokens(template: any, removeBrackets: boolean): string[];
     static ensureEventId(event: string): string;
     static ensureKeys(ui: VelcronDefinition | VelcronAppDefinition, generateNewKeys?: boolean): void;
     static removeKeys(ui: VelcronDefinition | VelcronAppDefinition): void;

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

@@ -0,0 +1,9 @@
+import { BuiltInPropertyEditors, ResolvedPropertyEditor } from "../models";
+export declare class VelcronPropertyEditors {
+    private static editors;
+    static registerEditor(type: string, editor: any): void;
+    static hasEditors(): boolean;
+    static hasEditor(type: string): any;
+    static registerEditors(editors: BuiltInPropertyEditors): void;
+    static getEditor(editor: string): ResolvedPropertyEditor;
+}

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

@@ -1,4 +1,5 @@
-import { BuiltInComponentRenderers, VelcronState, ResolvedComponentRenderer, VelcronCustomComponentDefinition, VelcronDefinition, VelcronRenderContext } from "../models";
+import { BuiltInComponentRenderers, ResolvedComponentRenderer, VelcronDefinition, VelcronRenderContext } from "../models";
+import { DynamicState } from "..";
 export declare class VelcronRenderers {
     private static components;
     static registerComponent(type: string, component: any): void;
@@ -7,35 +8,6 @@ export declare class VelcronRenderers {
     static registerComponents(components: BuiltInComponentRenderers): void;
     static getComponent(definition: VelcronDefinition, renderContext: VelcronRenderContext): ResolvedComponentRenderer;
     static definitionContainsCustomColorSchema(definition: VelcronDefinition): boolean;
-    static createNewRendererContext(currentRenderCtx: VelcronRenderContext, definition: VelcronDefinition, newViewModel?: VelcronState): {
-        rootContext: VelcronState;
-        theming: {
-            state: {
-                currentTheme: import("..").ThemeDefinitionV2;
-            };
-            get: {
-                colorSchema: (colorSchemaType: import("..").ColorSchemaTypes) => import("..").ColorSchema;
-                typography: (typographyType: import("..").TypographyTypes) => import("..").TypographyTypeDefinition;
-                color: (colorSchemaType: import("..").ColorSchemaTypes, colorType: import("..").ColorTypes) => string;
-                colorDefinition: (colorSchemaType: import("..").ColorSchemaTypes, colorType: import("..").ColorTypes) => import("..").ColorDefinition;
-                complementaryColorType: (colorType: import("..").ColorTypes) => import("..").ColorTypes;
-                complementaryColor: (colorSchemaType: import("..").ColorSchemaTypes, colorType: import("..").ColorTypes) => string;
-                complementaryColorDefinition: (colorSchemaType: import("..").ColorSchemaTypes, colorType: import("..").ColorTypes) => import("..").ColorDefinition;
-                currentTheme: () => import("..").ThemeDefinitionV2;
-            };
-            actions: {
-                setTheme(newTheme: import("..").ThemeDefinitionV2): void;
-            };
-        };
-        currentContext: VelcronState;
-        actions: {
-            [name: string]: [];
-        };
-        components: VelcronCustomComponentDefinition[];
-        hooks: import("..").VelcronRenderContextHooks;
-        computed: {
-            [name: string]: [];
-        };
-    };
-    static ensureRenderContext(rendererInfo: ResolvedComponentRenderer, definition: VelcronDefinition, currentRenderCtx: VelcronRenderContext, newViewModel?: VelcronState): VelcronRenderContext;
+    static createNewRendererContext(currentRenderCtx: VelcronRenderContext, definition: VelcronDefinition, newViewModel?: DynamicState): VelcronRenderContext;
+    static ensureRenderContext(rendererInfo: ResolvedComponentRenderer, definition: VelcronDefinition, currentRenderCtx: VelcronRenderContext, newViewModel?: DynamicState): VelcronRenderContext;
 }