@xlr-lib/xlr-sdk 0.1.1--canary.9.190

package/src/__tests__/__snapshots__/sdk.test.ts.snap

@@ -0,0 +1,4443 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Export Test > Exports Typescript Types With Filters 1`] = `
+"import { Expression, Asset, Binding, AssetWrapper } from "@player-ui/types";
+
+/**
+ * This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+ * Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.
+*/
+export interface InputAsset<AnyTextAsset extends Asset = Asset> extends Asset<'input'> {
+    /** Asset container for a field label. */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** Asset container for a note. */
+    note?: AssetWrapper<AnyTextAsset>;
+    /** The location in the data-model to store the data */
+    binding: Binding;
+    /** Optional additional data */
+    metaData?: {
+        /** Additional data to beacon when this input changes */
+        beacon?: string | Record<string, any>;
+    };
+}
+export interface TextAsset extends Asset<'text'> {
+    /** The text to display */
+    value: string;
+    /** Any modifiers on the text */
+    modifiers?: Array<{
+        /** The modifier type */
+        type: string;
+        /** Modifiers can be named when used in strings */
+        name?: string;
+        [key: string]: unknown;
+    } | {
+        /** The link type denotes this as a link */
+        type: 'link';
+        /** An optional expression to run before the link is opened */
+        exp?: Expression;
+        /** metaData about the link's target */
+        metaData: {
+            /** The location of the link to load */
+            ref: string;
+            /** Used to indicate an application specific resolver to use */
+            'mime-type'?: string;
+        };
+    }>;
+}
+/**
+ * User actions can be represented in several places.
+ * Each view typically has one or more actions that allow the user to navigate away from that view.
+ * In addition, several asset types can have actions that apply to that asset only.
+*/
+export interface ActionAsset<AnyTextAsset extends Asset = Asset> extends Asset<'action'> {
+    /** The transition value of the action in the state machine */
+    value?: string;
+    /** A text-like asset for the action's label */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** An optional expression to execute before transitioning */
+    exp?: Expression;
+    /** An optional string that describes the action for screen-readers */
+    accessibility?: string;
+    /** Additional optional data to assist with the action interactions on the page */
+    metaData?: {
+        /** Additional data to beacon */
+        beacon?: string | Record<string, any>;
+        /** Force transition to the next view without checking for validation */
+        skipValidation?: boolean;
+    };
+}
+export interface InfoAsset extends Asset<'info'> {
+    /** The string value to show */
+    title?: AssetWrapper;
+    /** subtitle */
+    subTitle?: AssetWrapper;
+    /** Primary place for info */
+    primaryInfo?: AssetWrapper;
+    /** List of actions to show at the bottom of the page */
+    actions?: Array<AssetWrapper>;
+}
+export interface CollectionAsset extends Asset<'collection'> {
+    /** An optional label to title the collection */
+    label?: AssetWrapper;
+    /** The string value to show */
+    values?: Array<AssetWrapper>;
+}"
+`;
+
+exports[`Export Test > Exports Typescript Types With Transforms 1`] = `
+"import { Expression, Asset, Binding, AssetWrapper } from "@player-ui/types";
+
+/**
+ * This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+ * Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.
+*/
+export interface InputAsset<AnyTextAsset extends Asset = Asset> extends Asset<'input'> {
+    /** Asset container for a field label. */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** Asset container for a note. */
+    note?: AssetWrapper<AnyTextAsset>;
+    /** The location in the data-model to store the data */
+    binding: Binding;
+    /** Optional additional data */
+    metaData?: {
+        /** Additional data to beacon when this input changes */
+        beacon?: string | Record<string, any>;
+    };
+    transformed?: true;
+}
+export interface TextAsset extends Asset<'text'> {
+    /** The text to display */
+    value: string;
+    /** Any modifiers on the text */
+    modifiers?: Array<{
+        /** The modifier type */
+        type: string;
+        /** Modifiers can be named when used in strings */
+        name?: string;
+        [key: string]: unknown;
+    } | {
+        /** The link type denotes this as a link */
+        type: 'link';
+        /** An optional expression to run before the link is opened */
+        exp?: Expression;
+        /** metaData about the link's target */
+        metaData: {
+            /** The location of the link to load */
+            ref: string;
+            /** Used to indicate an application specific resolver to use */
+            'mime-type'?: string;
+        };
+    }>;
+    transformed?: true;
+}
+/**
+ * User actions can be represented in several places.
+ * Each view typically has one or more actions that allow the user to navigate away from that view.
+ * In addition, several asset types can have actions that apply to that asset only.
+*/
+export interface ActionAsset<AnyTextAsset extends Asset = Asset> extends Asset<'action'> {
+    /** The transition value of the action in the state machine */
+    value?: string;
+    /** A text-like asset for the action's label */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** An optional expression to execute before transitioning */
+    exp?: Expression;
+    /** An optional string that describes the action for screen-readers */
+    accessibility?: string;
+    /** Additional optional data to assist with the action interactions on the page */
+    metaData?: {
+        /** Additional data to beacon */
+        beacon?: string | Record<string, any>;
+        /** Force transition to the next view without checking for validation */
+        skipValidation?: boolean;
+    };
+    transformed?: true;
+}
+export interface InfoAsset extends Asset<'info'> {
+    /** The string value to show */
+    title?: AssetWrapper;
+    /** subtitle */
+    subTitle?: AssetWrapper;
+    /** Primary place for info */
+    primaryInfo?: AssetWrapper;
+    /** List of actions to show at the bottom of the page */
+    actions?: Array<AssetWrapper>;
+    transformed?: true;
+}
+export interface CollectionAsset extends Asset<'collection'> {
+    /** An optional label to title the collection */
+    label?: AssetWrapper;
+    /** The string value to show */
+    values?: Array<AssetWrapper>;
+    transformed?: true;
+}"
+`;
+
+exports[`Export Test > Exports Typescript types 1`] = `
+"import { Expression, Asset, Binding, AssetWrapper } from "@player-ui/types";
+
+/** An asset is the smallest unit of user interaction in a player view */
+export interface Asset<T extends string = string> {
+    /** Each asset requires a unique id per view */
+    id: string;
+    /** The asset type determines the semantics of how a user interacts with a page */
+    type: T;
+    [key: string]: unknown;
+}
+/** An asset that contains a Binding. */
+export interface AssetBinding extends Asset {
+    /** A binding that points to somewhere in the data model */
+    binding: Binding;
+}
+/** A single case statement to use in a switch */
+export interface SwitchCase<T extends Asset = Asset> {
+    /** The Asset to use if this case is applicable */
+    asset: T;
+    /** An expression to execute to determine if this case applies */
+    case: Expression | true;
+}
+/** A switch can replace an asset with the applicable case on first render */
+export type Switch<T extends Asset = Asset> = Array<{
+    /** The Asset to use if this case is applicable */
+    asset: T;
+    /** An expression to execute to determine if this case applies */
+    case: Expression | true;
+}>;
+/** An object that contains an asset */
+export interface AssetWrapper<T extends Asset = Asset> {
+    /** An asset instance */
+    asset: T;
+    [key: string]: unknown;
+}
+export type AssetWrapperOrSwitch<T extends Asset = Asset> = (AssetWrapper<T> & {
+    /** The dynamicSwitch property can't exist at the same time as 'asset' */
+    dynamicSwitch?: never;
+    /** The staticSwitch property can't exist at the same time as 'asset' */
+    staticSwitch?: never;
+}) | ({
+    /** A static switch only evaluates the applicable base on first render of the view */
+    staticSwitch: Array<{
+        /** The Asset to use if this case is applicable */
+        asset: T;
+        /** An expression to execute to determine if this case applies */
+        case: Expression | true;
+    }>;
+} & {
+    /** The staticSwitch property can't exist at the same time as 'asset' */
+    asset?: never;
+    /** The staticSwitch property can't exist at the same time as 'dynamicSwitch' */
+    dynamicSwitch?: never;
+}) | ({
+    /** A dynamic switch re-evaluates the applicable case as data changes */
+    dynamicSwitch: Array<{
+        /** The Asset to use if this case is applicable */
+        asset: T;
+        /** An expression to execute to determine if this case applies */
+        case: Expression | true;
+    }>;
+} & {
+    /** The dynamicSwitch property can't exist at the same time as 'asset' */
+    asset?: never;
+    /** The dynamicSwitch property can't exist at the same time as 'staticSwitch' */
+    staticSwitch?: never;
+});
+export type AssetSwitch<T extends Asset = Asset> = {
+    /** A static switch only evaluates the applicable base on first render of the view */
+    staticSwitch: Array<{
+        /** The Asset to use if this case is applicable */
+        asset: T;
+        /** An expression to execute to determine if this case applies */
+        case: Expression | true;
+    }>;
+} | {
+    /** A dynamic switch re-evaluates the applicable case as data changes */
+    dynamicSwitch: Array<{
+        /** The Asset to use if this case is applicable */
+        asset: T;
+        /** An expression to execute to determine if this case applies */
+        case: Expression | true;
+    }>;
+};
+export interface StaticSwitch<T extends Asset = Asset> {
+    /** A static switch only evaluates the applicable base on first render of the view */
+    staticSwitch: Array<{
+        /** The Asset to use if this case is applicable */
+        asset: T;
+        /** An expression to execute to determine if this case applies */
+        case: Expression | true;
+    }>;
+}
+export interface DynamicSwitch<T extends Asset = Asset> {
+    /** A dynamic switch re-evaluates the applicable case as data changes */
+    dynamicSwitch: Array<{
+        /** The Asset to use if this case is applicable */
+        asset: T;
+        /** An expression to execute to determine if this case applies */
+        case: Expression | true;
+    }>;
+}
+/**
+ * Expressions are a specialized way of executing code.
+ * If the expression is a composite, the last expression executed is the return value
+*/
+export type Expression = string | Array<string>;
+export type ExpressionRef = \`@[\${string}]@\`;
+/** Bindings describe locations in the data model. */
+export type Binding = string;
+export type BindingRef = \`{{\${string}}}\`;
+/** The data-model is the location that all user data is stored */
+export type DataModel = Record<any, unknown>;
+/** The navigation section of the flow describes a State Machine for the user. */
+export type Navigation = {
+    /** The name of the Flow to begin on */
+    BEGIN: string;
+} & Record<string, string | {
+    /** The first state to kick off the state machine */
+    startState: string;
+    /** An optional expression to run when this Flow starts */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run when this Flow ends */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    [key: string]: undefined | string | Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    } | ({
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'VIEW';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** An id corresponding to a view from the 'views' array */
+        ref: string;
+        /** View meta-properties */
+        attributes?: {
+            [key: string]: any;
+        };
+        [key: string]: unknown;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'END';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /**
+         * A description of _how_ the flow ended.
+         * If this is a flow started from another flow, the outcome determines the flow transition
+        */
+        outcome: string;
+        [key: string]: unknown;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'FLOW';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** A reference to a FLOW id state to run */
+        ref: string;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'ACTION';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /**
+         * An expression to execute.
+         * The return value determines the transition to take
+        */
+        exp: Expression;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'ASYNC_ACTION';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /**
+         * An expression to execute.
+         * The return value determines the transition to take
+        */
+        exp: Expression;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** Whether the expression(s) should be awaited before transitioning */
+        await: boolean;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'EXTERNAL';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** A reference for this external state */
+        ref: string;
+        [key: string]: unknown;
+    });
+}>;
+/** An object with an expression in it */
+export interface ExpressionObject {
+    /** The expression to run */
+    exp?: Expression;
+}
+/** A state machine in the navigation */
+export interface NavigationFlow {
+    /** The first state to kick off the state machine */
+    startState: string;
+    /** An optional expression to run when this Flow starts */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run when this Flow ends */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    [key: string]: undefined | string | Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    } | ({
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'VIEW';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** An id corresponding to a view from the 'views' array */
+        ref: string;
+        /** View meta-properties */
+        attributes?: {
+            [key: string]: any;
+        };
+        [key: string]: unknown;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'END';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /**
+         * A description of _how_ the flow ended.
+         * If this is a flow started from another flow, the outcome determines the flow transition
+        */
+        outcome: string;
+        [key: string]: unknown;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'FLOW';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** A reference to a FLOW id state to run */
+        ref: string;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'ACTION';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /**
+         * An expression to execute.
+         * The return value determines the transition to take
+        */
+        exp: Expression;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'ASYNC_ACTION';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /**
+         * An expression to execute.
+         * The return value determines the transition to take
+        */
+        exp: Expression;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** Whether the expression(s) should be awaited before transitioning */
+        await: boolean;
+    } | {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'EXTERNAL';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /** A mapping of transition-name to FlowState name */
+        transitions: Record<string, string>;
+        /** A reference for this external state */
+        ref: string;
+        [key: string]: unknown;
+    });
+}
+export type NavigationFlowTransition = Record<string, string>;
+/** The base representation of a state within a Flow */
+export interface NavigationBaseState<T extends string = any> {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: T;
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /**
+     * TS gets really confused with both the ActionState and the onStart state both declaring the \`exp\` property
+     * So this explicity says there should never be an exp prop on a state node that's not of type 'ACTION'
+    */
+    exp?: T extends 'ACTION' | 'ASYNC_ACTION' ? Expression : never;
+}
+/** A generic state that can transition to another state */
+export interface NavigationFlowTransitionableState<T extends string = any> {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: T;
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /**
+     * TS gets really confused with both the ActionState and the onStart state both declaring the \`exp\` property
+     * So this explicity says there should never be an exp prop on a state node that's not of type 'ACTION'
+    */
+    exp?: T extends 'ACTION' | 'ASYNC_ACTION' ? Expression : never;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+}
+/** A state representing a view */
+export interface NavigationFlowViewState {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'VIEW';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** An id corresponding to a view from the 'views' array */
+    ref: string;
+    /** View meta-properties */
+    attributes?: {
+        [key: string]: any;
+    };
+    [key: string]: unknown;
+}
+/** An END state of the flow. */
+export interface NavigationFlowEndState {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'END';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /**
+     * A description of _how_ the flow ended.
+     * If this is a flow started from another flow, the outcome determines the flow transition
+    */
+    outcome: string;
+    [key: string]: unknown;
+}
+/** Action states execute an expression to determine the next state to transition to */
+export interface NavigationFlowActionState {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'ACTION';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /**
+     * An expression to execute.
+     * The return value determines the transition to take
+    */
+    exp: Expression;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+}
+/** Action states execute an expression to determine the next state to transition to */
+export interface NavigationFlowAsyncActionState {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'ASYNC_ACTION';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /**
+     * An expression to execute.
+     * The return value determines the transition to take
+    */
+    exp: Expression;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** Whether the expression(s) should be awaited before transitioning */
+    await: boolean;
+}
+/**
+ * External Flow states represent states in the FSM that can't be resolved internally in Player.
+ * The flow will wait for the embedded application to manage moving to the next state via a transition
+*/
+export interface NavigationFlowExternalState {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'EXTERNAL';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** A reference for this external state */
+    ref: string;
+    [key: string]: unknown;
+}
+export interface NavigationFlowFlowState {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'FLOW';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** A reference to a FLOW id state to run */
+    ref: string;
+}
+export type NavigationFlowState = {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'VIEW';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** An id corresponding to a view from the 'views' array */
+    ref: string;
+    /** View meta-properties */
+    attributes?: {
+        [key: string]: any;
+    };
+    [key: string]: unknown;
+} | {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'END';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /**
+     * A description of _how_ the flow ended.
+     * If this is a flow started from another flow, the outcome determines the flow transition
+    */
+    outcome: string;
+    [key: string]: unknown;
+} | {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'FLOW';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** A reference to a FLOW id state to run */
+    ref: string;
+} | {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'ACTION';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /**
+     * An expression to execute.
+     * The return value determines the transition to take
+    */
+    exp: Expression;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+} | {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'ASYNC_ACTION';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /**
+     * An expression to execute.
+     * The return value determines the transition to take
+    */
+    exp: Expression;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** Whether the expression(s) should be awaited before transitioning */
+    await: boolean;
+} | {
+    /** Add comments that will not be processing, but are useful for code explanation */
+    _comment?: string;
+    /** A property to determine the type of state this is */
+    state_type: 'EXTERNAL';
+    /** An optional expression to run when this view renders */
+    onStart?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    /** An optional expression to run before view transition */
+    onEnd?: Expression | {
+        /** The expression to run */
+        exp?: Expression;
+    };
+    exp?: never;
+    /** A mapping of transition-name to FlowState name */
+    transitions: Record<string, string>;
+    /** A reference for this external state */
+    ref: string;
+    [key: string]: unknown;
+};
+/** The data at the end of a flow */
+export interface FlowResult {
+    /** The outcome describes _how_ the flow ended (forwards, backwards, etc) */
+    endState: {
+        /** Add comments that will not be processing, but are useful for code explanation */
+        _comment?: string;
+        /** A property to determine the type of state this is */
+        state_type: 'END';
+        /** An optional expression to run when this view renders */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run before view transition */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        exp?: never;
+        /**
+         * A description of _how_ the flow ended.
+         * If this is a flow started from another flow, the outcome determines the flow transition
+        */
+        outcome: string;
+        [key: string]: unknown;
+    };
+    /** The serialized data-model */
+    data?: any;
+}
+/** Any object that contains 1 or more templates */
+export interface Templatable {
+    /** A list of templates to process for this node */
+    template?: Array<{
+        /** A pointer to the data-model containing an array of elements to map over */
+        data: Binding;
+        /**
+         * The template to iterate over using each value in the supplied template data.
+         * Any reference to _index_ is replaced with the current iteration index.
+        */
+        value: ValueType;
+        /** should the template be recomputed when data changes */
+        dynamic?: boolean;
+        /**
+         * A property on the parent object to store the new map under.
+         * If it already exists, values are appended to the end.
+        */
+        output: Key;
+        /** Specifies the template placement in relation to existing elements */
+        placement?: 'prepend' | 'append';
+    }>;
+}
+/** A template describes a mapping from a data array -> array of objects */
+export interface Template<ValueType extends any = unknown, Key extends string = string> {
+    /** A pointer to the data-model containing an array of elements to map over */
+    data: Binding;
+    /**
+     * The template to iterate over using each value in the supplied template data.
+     * Any reference to _index_ is replaced with the current iteration index.
+    */
+    value: ValueType;
+    /** should the template be recomputed when data changes */
+    dynamic?: boolean;
+    /**
+     * A property on the parent object to store the new map under.
+     * If it already exists, values are appended to the end.
+    */
+    output: Key;
+    /** Specifies the template placement in relation to existing elements */
+    placement?: 'prepend' | 'append';
+}
+export type View<T extends Asset = Asset> = unknown extends Asset ? T & {
+    /** Each view can optionally supply a list of validations to run against a particular view */
+    validation?: Array<{
+        /**
+         * The name of the referenced validation type
+         * This will be used to lookup the proper handler
+        */
+        type: string;
+        /** An optional means of overriding the default message if the validation is triggered */
+        message?: string;
+        /** An optional means of overriding the default severity of the validation if triggered */
+        severity?: 'error' | 'warning';
+        /** When to run this particular validation */
+        trigger?: 'navigation' | 'change' | 'load';
+        /** Cross-field references and validation must run against the default (deformatted) value */
+        dataTarget?: never;
+        /** Where the error should be displayed */
+        displayTarget?: 'page' | 'section' | 'field';
+        /**
+         * If the validation blocks navigation
+         * true/false - always/never block navigation
+         * once - only block navigation if the validation has not been triggered before
+        */
+        blocking?: boolean | 'once';
+        /** The binding to associate this validation with */
+        ref?: Binding;
+        [key: string]: unknown;
+    }>;
+} : T;
+/** The JSON payload for running Player */
+export interface Flow<T extends Asset = Asset> {
+    /** A unique identifier for the flow */
+    id: string;
+    /** A list of views (each with an ID) that can be shown to a user */
+    views?: Array<unknown extends Asset ? T & {
+        /** Each view can optionally supply a list of validations to run against a particular view */
+        validation?: Array<{
+            /**
+             * The name of the referenced validation type
+             * This will be used to lookup the proper handler
+            */
+            type: string;
+            /** An optional means of overriding the default message if the validation is triggered */
+            message?: string;
+            /** An optional means of overriding the default severity of the validation if triggered */
+            severity?: 'error' | 'warning';
+            /** When to run this particular validation */
+            trigger?: 'navigation' | 'change' | 'load';
+            /** Cross-field references and validation must run against the default (deformatted) value */
+            dataTarget?: never;
+            /** Where the error should be displayed */
+            displayTarget?: 'page' | 'section' | 'field';
+            /**
+             * If the validation blocks navigation
+             * true/false - always/never block navigation
+             * once - only block navigation if the validation has not been triggered before
+            */
+            blocking?: boolean | 'once';
+            /** The binding to associate this validation with */
+            ref?: Binding;
+            [key: string]: unknown;
+        }>;
+    } : T>;
+    /**
+     * The schema for the supplied (or referenced data).
+     * This is used for validation, formatting, etc
+    */
+    schema?: {
+        /** The ROOT object is the top level object to use */
+        ROOT: {
+            [key: string]: {
+                /** The reference of the base type to use */
+                type: string;
+                /**
+                 * Any additional validations that are associated with this property
+                 * These will add to any base validations associated with the "type"
+                */
+                validation?: Array<{
+                    /**
+                     * The name of the referenced validation type
+                     * This will be used to lookup the proper handler
+                    */
+                    type: string;
+                    /** An optional means of overriding the default message if the validation is triggered */
+                    message?: string;
+                    /** An optional means of overriding the default severity of the validation if triggered */
+                    severity?: 'error' | 'warning';
+                    /** When to run this particular validation */
+                    trigger?: 'navigation' | 'change' | 'load';
+                    /**
+                     * Each validation is passed the value of the data to run it's validation against.
+                     * By default, this is the value stored in the data-model (deformatted).
+                     * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                    */
+                    dataTarget?: 'formatted' | 'deformatted';
+                    /** Where the error should be displayed */
+                    displayTarget?: 'page' | 'section' | 'field';
+                    /**
+                     * If the validation blocks navigation
+                     * true/false - always/never block navigation
+                     * once - only block navigation if the validation has not been triggered before
+                    */
+                    blocking?: boolean | 'once';
+                    [key: string]: unknown;
+                }>;
+                /**
+                 * A reference to a specific data format to use.
+                 * If none is specified, will fallback to that of the base type
+                */
+                format?: {
+                    /** The name of the formatter (and de-formatter) to use */
+                    type: string;
+                    [key: string]: unknown;
+                };
+                /**
+                 * A default value for this property.
+                 * Any reads for this property will result in this default value being written to the model.
+                */
+                default?: T;
+                [key: string]: unknown;
+            } | {
+                /** The reference of the base type to use */
+                type: string;
+                /**
+                 * Any additional validations that are associated with this property
+                 * These will add to any base validations associated with the "type"
+                */
+                validation?: Array<{
+                    /**
+                     * The name of the referenced validation type
+                     * This will be used to lookup the proper handler
+                    */
+                    type: string;
+                    /** An optional means of overriding the default message if the validation is triggered */
+                    message?: string;
+                    /** An optional means of overriding the default severity of the validation if triggered */
+                    severity?: 'error' | 'warning';
+                    /** When to run this particular validation */
+                    trigger?: 'navigation' | 'change' | 'load';
+                    /**
+                     * Each validation is passed the value of the data to run it's validation against.
+                     * By default, this is the value stored in the data-model (deformatted).
+                     * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                    */
+                    dataTarget?: 'formatted' | 'deformatted';
+                    /** Where the error should be displayed */
+                    displayTarget?: 'page' | 'section' | 'field';
+                    /**
+                     * If the validation blocks navigation
+                     * true/false - always/never block navigation
+                     * once - only block navigation if the validation has not been triggered before
+                    */
+                    blocking?: boolean | 'once';
+                    [key: string]: unknown;
+                }>;
+                /**
+                 * A reference to a specific data format to use.
+                 * If none is specified, will fallback to that of the base type
+                */
+                format?: {
+                    /** The name of the formatter (and de-formatter) to use */
+                    type: string;
+                    [key: string]: unknown;
+                };
+                /**
+                 * A default value for this property.
+                 * Any reads for this property will result in this default value being written to the model.
+                */
+                default?: T;
+                /** boolean to define if its a record */
+                isRecord: boolean;
+                /** This property is mutually exclusive with RecordType and can not be used with ArrayType */
+                isArray?: never;
+                [key: string]: unknown;
+            } | {
+                /** The reference of the base type to use */
+                type: string;
+                /**
+                 * Any additional validations that are associated with this property
+                 * These will add to any base validations associated with the "type"
+                */
+                validation?: Array<{
+                    /**
+                     * The name of the referenced validation type
+                     * This will be used to lookup the proper handler
+                    */
+                    type: string;
+                    /** An optional means of overriding the default message if the validation is triggered */
+                    message?: string;
+                    /** An optional means of overriding the default severity of the validation if triggered */
+                    severity?: 'error' | 'warning';
+                    /** When to run this particular validation */
+                    trigger?: 'navigation' | 'change' | 'load';
+                    /**
+                     * Each validation is passed the value of the data to run it's validation against.
+                     * By default, this is the value stored in the data-model (deformatted).
+                     * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                    */
+                    dataTarget?: 'formatted' | 'deformatted';
+                    /** Where the error should be displayed */
+                    displayTarget?: 'page' | 'section' | 'field';
+                    /**
+                     * If the validation blocks navigation
+                     * true/false - always/never block navigation
+                     * once - only block navigation if the validation has not been triggered before
+                    */
+                    blocking?: boolean | 'once';
+                    [key: string]: unknown;
+                }>;
+                /**
+                 * A reference to a specific data format to use.
+                 * If none is specified, will fallback to that of the base type
+                */
+                format?: {
+                    /** The name of the formatter (and de-formatter) to use */
+                    type: string;
+                    [key: string]: unknown;
+                };
+                /**
+                 * A default value for this property.
+                 * Any reads for this property will result in this default value being written to the model.
+                */
+                default?: T;
+                /** boolean to define if its an array */
+                isArray: boolean;
+                /** This property is mutually exclusive with ArrayType and can not be used with RecordType */
+                isRecord?: never;
+                [key: string]: unknown;
+            };
+        };
+        [key: string]: {
+            [key: string]: {
+                /** The reference of the base type to use */
+                type: string;
+                /**
+                 * Any additional validations that are associated with this property
+                 * These will add to any base validations associated with the "type"
+                */
+                validation?: Array<{
+                    /**
+                     * The name of the referenced validation type
+                     * This will be used to lookup the proper handler
+                    */
+                    type: string;
+                    /** An optional means of overriding the default message if the validation is triggered */
+                    message?: string;
+                    /** An optional means of overriding the default severity of the validation if triggered */
+                    severity?: 'error' | 'warning';
+                    /** When to run this particular validation */
+                    trigger?: 'navigation' | 'change' | 'load';
+                    /**
+                     * Each validation is passed the value of the data to run it's validation against.
+                     * By default, this is the value stored in the data-model (deformatted).
+                     * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                    */
+                    dataTarget?: 'formatted' | 'deformatted';
+                    /** Where the error should be displayed */
+                    displayTarget?: 'page' | 'section' | 'field';
+                    /**
+                     * If the validation blocks navigation
+                     * true/false - always/never block navigation
+                     * once - only block navigation if the validation has not been triggered before
+                    */
+                    blocking?: boolean | 'once';
+                    [key: string]: unknown;
+                }>;
+                /**
+                 * A reference to a specific data format to use.
+                 * If none is specified, will fallback to that of the base type
+                */
+                format?: {
+                    /** The name of the formatter (and de-formatter) to use */
+                    type: string;
+                    [key: string]: unknown;
+                };
+                /**
+                 * A default value for this property.
+                 * Any reads for this property will result in this default value being written to the model.
+                */
+                default?: T;
+                [key: string]: unknown;
+            } | {
+                /** The reference of the base type to use */
+                type: string;
+                /**
+                 * Any additional validations that are associated with this property
+                 * These will add to any base validations associated with the "type"
+                */
+                validation?: Array<{
+                    /**
+                     * The name of the referenced validation type
+                     * This will be used to lookup the proper handler
+                    */
+                    type: string;
+                    /** An optional means of overriding the default message if the validation is triggered */
+                    message?: string;
+                    /** An optional means of overriding the default severity of the validation if triggered */
+                    severity?: 'error' | 'warning';
+                    /** When to run this particular validation */
+                    trigger?: 'navigation' | 'change' | 'load';
+                    /**
+                     * Each validation is passed the value of the data to run it's validation against.
+                     * By default, this is the value stored in the data-model (deformatted).
+                     * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                    */
+                    dataTarget?: 'formatted' | 'deformatted';
+                    /** Where the error should be displayed */
+                    displayTarget?: 'page' | 'section' | 'field';
+                    /**
+                     * If the validation blocks navigation
+                     * true/false - always/never block navigation
+                     * once - only block navigation if the validation has not been triggered before
+                    */
+                    blocking?: boolean | 'once';
+                    [key: string]: unknown;
+                }>;
+                /**
+                 * A reference to a specific data format to use.
+                 * If none is specified, will fallback to that of the base type
+                */
+                format?: {
+                    /** The name of the formatter (and de-formatter) to use */
+                    type: string;
+                    [key: string]: unknown;
+                };
+                /**
+                 * A default value for this property.
+                 * Any reads for this property will result in this default value being written to the model.
+                */
+                default?: T;
+                /** boolean to define if its a record */
+                isRecord: boolean;
+                /** This property is mutually exclusive with RecordType and can not be used with ArrayType */
+                isArray?: never;
+                [key: string]: unknown;
+            } | {
+                /** The reference of the base type to use */
+                type: string;
+                /**
+                 * Any additional validations that are associated with this property
+                 * These will add to any base validations associated with the "type"
+                */
+                validation?: Array<{
+                    /**
+                     * The name of the referenced validation type
+                     * This will be used to lookup the proper handler
+                    */
+                    type: string;
+                    /** An optional means of overriding the default message if the validation is triggered */
+                    message?: string;
+                    /** An optional means of overriding the default severity of the validation if triggered */
+                    severity?: 'error' | 'warning';
+                    /** When to run this particular validation */
+                    trigger?: 'navigation' | 'change' | 'load';
+                    /**
+                     * Each validation is passed the value of the data to run it's validation against.
+                     * By default, this is the value stored in the data-model (deformatted).
+                     * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                    */
+                    dataTarget?: 'formatted' | 'deformatted';
+                    /** Where the error should be displayed */
+                    displayTarget?: 'page' | 'section' | 'field';
+                    /**
+                     * If the validation blocks navigation
+                     * true/false - always/never block navigation
+                     * once - only block navigation if the validation has not been triggered before
+                    */
+                    blocking?: boolean | 'once';
+                    [key: string]: unknown;
+                }>;
+                /**
+                 * A reference to a specific data format to use.
+                 * If none is specified, will fallback to that of the base type
+                */
+                format?: {
+                    /** The name of the formatter (and de-formatter) to use */
+                    type: string;
+                    [key: string]: unknown;
+                };
+                /**
+                 * A default value for this property.
+                 * Any reads for this property will result in this default value being written to the model.
+                */
+                default?: T;
+                /** boolean to define if its an array */
+                isArray: boolean;
+                /** This property is mutually exclusive with ArrayType and can not be used with RecordType */
+                isRecord?: never;
+                [key: string]: unknown;
+            };
+        };
+    };
+    /** Any initial data that the flow can use */
+    data?: Record<any, unknown>;
+    /** A state machine to drive a user through the experience */
+    navigation: {
+        /** The name of the Flow to begin on */
+        BEGIN: string;
+    } & Record<string, string | {
+        /** The first state to kick off the state machine */
+        startState: string;
+        /** An optional expression to run when this Flow starts */
+        onStart?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        /** An optional expression to run when this Flow ends */
+        onEnd?: Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        };
+        [key: string]: undefined | string | Expression | {
+            /** The expression to run */
+            exp?: Expression;
+        } | ({
+            /** Add comments that will not be processing, but are useful for code explanation */
+            _comment?: string;
+            /** A property to determine the type of state this is */
+            state_type: 'VIEW';
+            /** An optional expression to run when this view renders */
+            onStart?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /** An optional expression to run before view transition */
+            onEnd?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            exp?: never;
+            /** A mapping of transition-name to FlowState name */
+            transitions: Record<string, string>;
+            /** An id corresponding to a view from the 'views' array */
+            ref: string;
+            /** View meta-properties */
+            attributes?: {
+                [key: string]: any;
+            };
+            [key: string]: unknown;
+        } | {
+            /** Add comments that will not be processing, but are useful for code explanation */
+            _comment?: string;
+            /** A property to determine the type of state this is */
+            state_type: 'END';
+            /** An optional expression to run when this view renders */
+            onStart?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /** An optional expression to run before view transition */
+            onEnd?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            exp?: never;
+            /**
+             * A description of _how_ the flow ended.
+             * If this is a flow started from another flow, the outcome determines the flow transition
+            */
+            outcome: string;
+            [key: string]: unknown;
+        } | {
+            /** Add comments that will not be processing, but are useful for code explanation */
+            _comment?: string;
+            /** A property to determine the type of state this is */
+            state_type: 'FLOW';
+            /** An optional expression to run when this view renders */
+            onStart?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /** An optional expression to run before view transition */
+            onEnd?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            exp?: never;
+            /** A mapping of transition-name to FlowState name */
+            transitions: Record<string, string>;
+            /** A reference to a FLOW id state to run */
+            ref: string;
+        } | {
+            /** Add comments that will not be processing, but are useful for code explanation */
+            _comment?: string;
+            /** A property to determine the type of state this is */
+            state_type: 'ACTION';
+            /** An optional expression to run when this view renders */
+            onStart?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /** An optional expression to run before view transition */
+            onEnd?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /**
+             * An expression to execute.
+             * The return value determines the transition to take
+            */
+            exp: Expression;
+            /** A mapping of transition-name to FlowState name */
+            transitions: Record<string, string>;
+        } | {
+            /** Add comments that will not be processing, but are useful for code explanation */
+            _comment?: string;
+            /** A property to determine the type of state this is */
+            state_type: 'ASYNC_ACTION';
+            /** An optional expression to run when this view renders */
+            onStart?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /** An optional expression to run before view transition */
+            onEnd?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /**
+             * An expression to execute.
+             * The return value determines the transition to take
+            */
+            exp: Expression;
+            /** A mapping of transition-name to FlowState name */
+            transitions: Record<string, string>;
+            /** Whether the expression(s) should be awaited before transitioning */
+            await: boolean;
+        } | {
+            /** Add comments that will not be processing, but are useful for code explanation */
+            _comment?: string;
+            /** A property to determine the type of state this is */
+            state_type: 'EXTERNAL';
+            /** An optional expression to run when this view renders */
+            onStart?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            /** An optional expression to run before view transition */
+            onEnd?: Expression | {
+                /** The expression to run */
+                exp?: Expression;
+            };
+            exp?: never;
+            /** A mapping of transition-name to FlowState name */
+            transitions: Record<string, string>;
+            /** A reference for this external state */
+            ref: string;
+            [key: string]: unknown;
+        });
+    }>;
+    [key: string]: unknown;
+}
+/** The authored schema object in the JSON payload */
+export interface Schema.Schema {
+    /** The ROOT object is the top level object to use */
+    ROOT: {
+        [key: string]: {
+            /** The reference of the base type to use */
+            type: string;
+            /**
+             * Any additional validations that are associated with this property
+             * These will add to any base validations associated with the "type"
+            */
+            validation?: Array<{
+                /**
+                 * The name of the referenced validation type
+                 * This will be used to lookup the proper handler
+                */
+                type: string;
+                /** An optional means of overriding the default message if the validation is triggered */
+                message?: string;
+                /** An optional means of overriding the default severity of the validation if triggered */
+                severity?: 'error' | 'warning';
+                /** When to run this particular validation */
+                trigger?: 'navigation' | 'change' | 'load';
+                /**
+                 * Each validation is passed the value of the data to run it's validation against.
+                 * By default, this is the value stored in the data-model (deformatted).
+                 * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                */
+                dataTarget?: 'formatted' | 'deformatted';
+                /** Where the error should be displayed */
+                displayTarget?: 'page' | 'section' | 'field';
+                /**
+                 * If the validation blocks navigation
+                 * true/false - always/never block navigation
+                 * once - only block navigation if the validation has not been triggered before
+                */
+                blocking?: boolean | 'once';
+                [key: string]: unknown;
+            }>;
+            /**
+             * A reference to a specific data format to use.
+             * If none is specified, will fallback to that of the base type
+            */
+            format?: {
+                /** The name of the formatter (and de-formatter) to use */
+                type: string;
+                [key: string]: unknown;
+            };
+            /**
+             * A default value for this property.
+             * Any reads for this property will result in this default value being written to the model.
+            */
+            default?: T;
+            [key: string]: unknown;
+        } | {
+            /** The reference of the base type to use */
+            type: string;
+            /**
+             * Any additional validations that are associated with this property
+             * These will add to any base validations associated with the "type"
+            */
+            validation?: Array<{
+                /**
+                 * The name of the referenced validation type
+                 * This will be used to lookup the proper handler
+                */
+                type: string;
+                /** An optional means of overriding the default message if the validation is triggered */
+                message?: string;
+                /** An optional means of overriding the default severity of the validation if triggered */
+                severity?: 'error' | 'warning';
+                /** When to run this particular validation */
+                trigger?: 'navigation' | 'change' | 'load';
+                /**
+                 * Each validation is passed the value of the data to run it's validation against.
+                 * By default, this is the value stored in the data-model (deformatted).
+                 * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                */
+                dataTarget?: 'formatted' | 'deformatted';
+                /** Where the error should be displayed */
+                displayTarget?: 'page' | 'section' | 'field';
+                /**
+                 * If the validation blocks navigation
+                 * true/false - always/never block navigation
+                 * once - only block navigation if the validation has not been triggered before
+                */
+                blocking?: boolean | 'once';
+                [key: string]: unknown;
+            }>;
+            /**
+             * A reference to a specific data format to use.
+             * If none is specified, will fallback to that of the base type
+            */
+            format?: {
+                /** The name of the formatter (and de-formatter) to use */
+                type: string;
+                [key: string]: unknown;
+            };
+            /**
+             * A default value for this property.
+             * Any reads for this property will result in this default value being written to the model.
+            */
+            default?: T;
+            /** boolean to define if its a record */
+            isRecord: boolean;
+            /** This property is mutually exclusive with RecordType and can not be used with ArrayType */
+            isArray?: never;
+            [key: string]: unknown;
+        } | {
+            /** The reference of the base type to use */
+            type: string;
+            /**
+             * Any additional validations that are associated with this property
+             * These will add to any base validations associated with the "type"
+            */
+            validation?: Array<{
+                /**
+                 * The name of the referenced validation type
+                 * This will be used to lookup the proper handler
+                */
+                type: string;
+                /** An optional means of overriding the default message if the validation is triggered */
+                message?: string;
+                /** An optional means of overriding the default severity of the validation if triggered */
+                severity?: 'error' | 'warning';
+                /** When to run this particular validation */
+                trigger?: 'navigation' | 'change' | 'load';
+                /**
+                 * Each validation is passed the value of the data to run it's validation against.
+                 * By default, this is the value stored in the data-model (deformatted).
+                 * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                */
+                dataTarget?: 'formatted' | 'deformatted';
+                /** Where the error should be displayed */
+                displayTarget?: 'page' | 'section' | 'field';
+                /**
+                 * If the validation blocks navigation
+                 * true/false - always/never block navigation
+                 * once - only block navigation if the validation has not been triggered before
+                */
+                blocking?: boolean | 'once';
+                [key: string]: unknown;
+            }>;
+            /**
+             * A reference to a specific data format to use.
+             * If none is specified, will fallback to that of the base type
+            */
+            format?: {
+                /** The name of the formatter (and de-formatter) to use */
+                type: string;
+                [key: string]: unknown;
+            };
+            /**
+             * A default value for this property.
+             * Any reads for this property will result in this default value being written to the model.
+            */
+            default?: T;
+            /** boolean to define if its an array */
+            isArray: boolean;
+            /** This property is mutually exclusive with ArrayType and can not be used with RecordType */
+            isRecord?: never;
+            [key: string]: unknown;
+        };
+    };
+    [key: string]: {
+        [key: string]: {
+            /** The reference of the base type to use */
+            type: string;
+            /**
+             * Any additional validations that are associated with this property
+             * These will add to any base validations associated with the "type"
+            */
+            validation?: Array<{
+                /**
+                 * The name of the referenced validation type
+                 * This will be used to lookup the proper handler
+                */
+                type: string;
+                /** An optional means of overriding the default message if the validation is triggered */
+                message?: string;
+                /** An optional means of overriding the default severity of the validation if triggered */
+                severity?: 'error' | 'warning';
+                /** When to run this particular validation */
+                trigger?: 'navigation' | 'change' | 'load';
+                /**
+                 * Each validation is passed the value of the data to run it's validation against.
+                 * By default, this is the value stored in the data-model (deformatted).
+                 * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                */
+                dataTarget?: 'formatted' | 'deformatted';
+                /** Where the error should be displayed */
+                displayTarget?: 'page' | 'section' | 'field';
+                /**
+                 * If the validation blocks navigation
+                 * true/false - always/never block navigation
+                 * once - only block navigation if the validation has not been triggered before
+                */
+                blocking?: boolean | 'once';
+                [key: string]: unknown;
+            }>;
+            /**
+             * A reference to a specific data format to use.
+             * If none is specified, will fallback to that of the base type
+            */
+            format?: {
+                /** The name of the formatter (and de-formatter) to use */
+                type: string;
+                [key: string]: unknown;
+            };
+            /**
+             * A default value for this property.
+             * Any reads for this property will result in this default value being written to the model.
+            */
+            default?: T;
+            [key: string]: unknown;
+        } | {
+            /** The reference of the base type to use */
+            type: string;
+            /**
+             * Any additional validations that are associated with this property
+             * These will add to any base validations associated with the "type"
+            */
+            validation?: Array<{
+                /**
+                 * The name of the referenced validation type
+                 * This will be used to lookup the proper handler
+                */
+                type: string;
+                /** An optional means of overriding the default message if the validation is triggered */
+                message?: string;
+                /** An optional means of overriding the default severity of the validation if triggered */
+                severity?: 'error' | 'warning';
+                /** When to run this particular validation */
+                trigger?: 'navigation' | 'change' | 'load';
+                /**
+                 * Each validation is passed the value of the data to run it's validation against.
+                 * By default, this is the value stored in the data-model (deformatted).
+                 * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                */
+                dataTarget?: 'formatted' | 'deformatted';
+                /** Where the error should be displayed */
+                displayTarget?: 'page' | 'section' | 'field';
+                /**
+                 * If the validation blocks navigation
+                 * true/false - always/never block navigation
+                 * once - only block navigation if the validation has not been triggered before
+                */
+                blocking?: boolean | 'once';
+                [key: string]: unknown;
+            }>;
+            /**
+             * A reference to a specific data format to use.
+             * If none is specified, will fallback to that of the base type
+            */
+            format?: {
+                /** The name of the formatter (and de-formatter) to use */
+                type: string;
+                [key: string]: unknown;
+            };
+            /**
+             * A default value for this property.
+             * Any reads for this property will result in this default value being written to the model.
+            */
+            default?: T;
+            /** boolean to define if its a record */
+            isRecord: boolean;
+            /** This property is mutually exclusive with RecordType and can not be used with ArrayType */
+            isArray?: never;
+            [key: string]: unknown;
+        } | {
+            /** The reference of the base type to use */
+            type: string;
+            /**
+             * Any additional validations that are associated with this property
+             * These will add to any base validations associated with the "type"
+            */
+            validation?: Array<{
+                /**
+                 * The name of the referenced validation type
+                 * This will be used to lookup the proper handler
+                */
+                type: string;
+                /** An optional means of overriding the default message if the validation is triggered */
+                message?: string;
+                /** An optional means of overriding the default severity of the validation if triggered */
+                severity?: 'error' | 'warning';
+                /** When to run this particular validation */
+                trigger?: 'navigation' | 'change' | 'load';
+                /**
+                 * Each validation is passed the value of the data to run it's validation against.
+                 * By default, this is the value stored in the data-model (deformatted).
+                 * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+                */
+                dataTarget?: 'formatted' | 'deformatted';
+                /** Where the error should be displayed */
+                displayTarget?: 'page' | 'section' | 'field';
+                /**
+                 * If the validation blocks navigation
+                 * true/false - always/never block navigation
+                 * once - only block navigation if the validation has not been triggered before
+                */
+                blocking?: boolean | 'once';
+                [key: string]: unknown;
+            }>;
+            /**
+             * A reference to a specific data format to use.
+             * If none is specified, will fallback to that of the base type
+            */
+            format?: {
+                /** The name of the formatter (and de-formatter) to use */
+                type: string;
+                [key: string]: unknown;
+            };
+            /**
+             * A default value for this property.
+             * Any reads for this property will result in this default value being written to the model.
+            */
+            default?: T;
+            /** boolean to define if its an array */
+            isArray: boolean;
+            /** This property is mutually exclusive with ArrayType and can not be used with RecordType */
+            isRecord?: never;
+            [key: string]: unknown;
+        };
+    };
+}
+/** A Node describes a specific object in the tree */
+export interface Schema.Node {
+    [key: string]: {
+        /** The reference of the base type to use */
+        type: string;
+        /**
+         * Any additional validations that are associated with this property
+         * These will add to any base validations associated with the "type"
+        */
+        validation?: Array<{
+            /**
+             * The name of the referenced validation type
+             * This will be used to lookup the proper handler
+            */
+            type: string;
+            /** An optional means of overriding the default message if the validation is triggered */
+            message?: string;
+            /** An optional means of overriding the default severity of the validation if triggered */
+            severity?: 'error' | 'warning';
+            /** When to run this particular validation */
+            trigger?: 'navigation' | 'change' | 'load';
+            /**
+             * Each validation is passed the value of the data to run it's validation against.
+             * By default, this is the value stored in the data-model (deformatted).
+             * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+            */
+            dataTarget?: 'formatted' | 'deformatted';
+            /** Where the error should be displayed */
+            displayTarget?: 'page' | 'section' | 'field';
+            /**
+             * If the validation blocks navigation
+             * true/false - always/never block navigation
+             * once - only block navigation if the validation has not been triggered before
+            */
+            blocking?: boolean | 'once';
+            [key: string]: unknown;
+        }>;
+        /**
+         * A reference to a specific data format to use.
+         * If none is specified, will fallback to that of the base type
+        */
+        format?: {
+            /** The name of the formatter (and de-formatter) to use */
+            type: string;
+            [key: string]: unknown;
+        };
+        /**
+         * A default value for this property.
+         * Any reads for this property will result in this default value being written to the model.
+        */
+        default?: T;
+        [key: string]: unknown;
+    } | {
+        /** The reference of the base type to use */
+        type: string;
+        /**
+         * Any additional validations that are associated with this property
+         * These will add to any base validations associated with the "type"
+        */
+        validation?: Array<{
+            /**
+             * The name of the referenced validation type
+             * This will be used to lookup the proper handler
+            */
+            type: string;
+            /** An optional means of overriding the default message if the validation is triggered */
+            message?: string;
+            /** An optional means of overriding the default severity of the validation if triggered */
+            severity?: 'error' | 'warning';
+            /** When to run this particular validation */
+            trigger?: 'navigation' | 'change' | 'load';
+            /**
+             * Each validation is passed the value of the data to run it's validation against.
+             * By default, this is the value stored in the data-model (deformatted).
+             * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+            */
+            dataTarget?: 'formatted' | 'deformatted';
+            /** Where the error should be displayed */
+            displayTarget?: 'page' | 'section' | 'field';
+            /**
+             * If the validation blocks navigation
+             * true/false - always/never block navigation
+             * once - only block navigation if the validation has not been triggered before
+            */
+            blocking?: boolean | 'once';
+            [key: string]: unknown;
+        }>;
+        /**
+         * A reference to a specific data format to use.
+         * If none is specified, will fallback to that of the base type
+        */
+        format?: {
+            /** The name of the formatter (and de-formatter) to use */
+            type: string;
+            [key: string]: unknown;
+        };
+        /**
+         * A default value for this property.
+         * Any reads for this property will result in this default value being written to the model.
+        */
+        default?: T;
+        /** boolean to define if its a record */
+        isRecord: boolean;
+        /** This property is mutually exclusive with RecordType and can not be used with ArrayType */
+        isArray?: never;
+        [key: string]: unknown;
+    } | {
+        /** The reference of the base type to use */
+        type: string;
+        /**
+         * Any additional validations that are associated with this property
+         * These will add to any base validations associated with the "type"
+        */
+        validation?: Array<{
+            /**
+             * The name of the referenced validation type
+             * This will be used to lookup the proper handler
+            */
+            type: string;
+            /** An optional means of overriding the default message if the validation is triggered */
+            message?: string;
+            /** An optional means of overriding the default severity of the validation if triggered */
+            severity?: 'error' | 'warning';
+            /** When to run this particular validation */
+            trigger?: 'navigation' | 'change' | 'load';
+            /**
+             * Each validation is passed the value of the data to run it's validation against.
+             * By default, this is the value stored in the data-model (deformatted).
+             * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+            */
+            dataTarget?: 'formatted' | 'deformatted';
+            /** Where the error should be displayed */
+            displayTarget?: 'page' | 'section' | 'field';
+            /**
+             * If the validation blocks navigation
+             * true/false - always/never block navigation
+             * once - only block navigation if the validation has not been triggered before
+            */
+            blocking?: boolean | 'once';
+            [key: string]: unknown;
+        }>;
+        /**
+         * A reference to a specific data format to use.
+         * If none is specified, will fallback to that of the base type
+        */
+        format?: {
+            /** The name of the formatter (and de-formatter) to use */
+            type: string;
+            [key: string]: unknown;
+        };
+        /**
+         * A default value for this property.
+         * Any reads for this property will result in this default value being written to the model.
+        */
+        default?: T;
+        /** boolean to define if its an array */
+        isArray: boolean;
+        /** This property is mutually exclusive with ArrayType and can not be used with RecordType */
+        isRecord?: never;
+        [key: string]: unknown;
+    };
+}
+export type Schema.DataTypes = {
+    /** The reference of the base type to use */
+    type: string;
+    /**
+     * Any additional validations that are associated with this property
+     * These will add to any base validations associated with the "type"
+    */
+    validation?: Array<{
+        /**
+         * The name of the referenced validation type
+         * This will be used to lookup the proper handler
+        */
+        type: string;
+        /** An optional means of overriding the default message if the validation is triggered */
+        message?: string;
+        /** An optional means of overriding the default severity of the validation if triggered */
+        severity?: 'error' | 'warning';
+        /** When to run this particular validation */
+        trigger?: 'navigation' | 'change' | 'load';
+        /**
+         * Each validation is passed the value of the data to run it's validation against.
+         * By default, this is the value stored in the data-model (deformatted).
+         * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+        */
+        dataTarget?: 'formatted' | 'deformatted';
+        /** Where the error should be displayed */
+        displayTarget?: 'page' | 'section' | 'field';
+        /**
+         * If the validation blocks navigation
+         * true/false - always/never block navigation
+         * once - only block navigation if the validation has not been triggered before
+        */
+        blocking?: boolean | 'once';
+        [key: string]: unknown;
+    }>;
+    /**
+     * A reference to a specific data format to use.
+     * If none is specified, will fallback to that of the base type
+    */
+    format?: {
+        /** The name of the formatter (and de-formatter) to use */
+        type: string;
+        [key: string]: unknown;
+    };
+    /**
+     * A default value for this property.
+     * Any reads for this property will result in this default value being written to the model.
+    */
+    default?: T;
+    [key: string]: unknown;
+} | {
+    /** The reference of the base type to use */
+    type: string;
+    /**
+     * Any additional validations that are associated with this property
+     * These will add to any base validations associated with the "type"
+    */
+    validation?: Array<{
+        /**
+         * The name of the referenced validation type
+         * This will be used to lookup the proper handler
+        */
+        type: string;
+        /** An optional means of overriding the default message if the validation is triggered */
+        message?: string;
+        /** An optional means of overriding the default severity of the validation if triggered */
+        severity?: 'error' | 'warning';
+        /** When to run this particular validation */
+        trigger?: 'navigation' | 'change' | 'load';
+        /**
+         * Each validation is passed the value of the data to run it's validation against.
+         * By default, this is the value stored in the data-model (deformatted).
+         * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+        */
+        dataTarget?: 'formatted' | 'deformatted';
+        /** Where the error should be displayed */
+        displayTarget?: 'page' | 'section' | 'field';
+        /**
+         * If the validation blocks navigation
+         * true/false - always/never block navigation
+         * once - only block navigation if the validation has not been triggered before
+        */
+        blocking?: boolean | 'once';
+        [key: string]: unknown;
+    }>;
+    /**
+     * A reference to a specific data format to use.
+     * If none is specified, will fallback to that of the base type
+    */
+    format?: {
+        /** The name of the formatter (and de-formatter) to use */
+        type: string;
+        [key: string]: unknown;
+    };
+    /**
+     * A default value for this property.
+     * Any reads for this property will result in this default value being written to the model.
+    */
+    default?: T;
+    /** boolean to define if its a record */
+    isRecord: boolean;
+    /** This property is mutually exclusive with RecordType and can not be used with ArrayType */
+    isArray?: never;
+    [key: string]: unknown;
+} | {
+    /** The reference of the base type to use */
+    type: string;
+    /**
+     * Any additional validations that are associated with this property
+     * These will add to any base validations associated with the "type"
+    */
+    validation?: Array<{
+        /**
+         * The name of the referenced validation type
+         * This will be used to lookup the proper handler
+        */
+        type: string;
+        /** An optional means of overriding the default message if the validation is triggered */
+        message?: string;
+        /** An optional means of overriding the default severity of the validation if triggered */
+        severity?: 'error' | 'warning';
+        /** When to run this particular validation */
+        trigger?: 'navigation' | 'change' | 'load';
+        /**
+         * Each validation is passed the value of the data to run it's validation against.
+         * By default, this is the value stored in the data-model (deformatted).
+         * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+        */
+        dataTarget?: 'formatted' | 'deformatted';
+        /** Where the error should be displayed */
+        displayTarget?: 'page' | 'section' | 'field';
+        /**
+         * If the validation blocks navigation
+         * true/false - always/never block navigation
+         * once - only block navigation if the validation has not been triggered before
+        */
+        blocking?: boolean | 'once';
+        [key: string]: unknown;
+    }>;
+    /**
+     * A reference to a specific data format to use.
+     * If none is specified, will fallback to that of the base type
+    */
+    format?: {
+        /** The name of the formatter (and de-formatter) to use */
+        type: string;
+        [key: string]: unknown;
+    };
+    /**
+     * A default value for this property.
+     * Any reads for this property will result in this default value being written to the model.
+    */
+    default?: T;
+    /** boolean to define if its an array */
+    isArray: boolean;
+    /** This property is mutually exclusive with ArrayType and can not be used with RecordType */
+    isRecord?: never;
+    [key: string]: unknown;
+};
+/** Each prop in the object can have a specific DataType */
+export interface Schema.DataType<T extends any = unknown> {
+    /** The reference of the base type to use */
+    type: string;
+    /**
+     * Any additional validations that are associated with this property
+     * These will add to any base validations associated with the "type"
+    */
+    validation?: Array<{
+        /**
+         * The name of the referenced validation type
+         * This will be used to lookup the proper handler
+        */
+        type: string;
+        /** An optional means of overriding the default message if the validation is triggered */
+        message?: string;
+        /** An optional means of overriding the default severity of the validation if triggered */
+        severity?: 'error' | 'warning';
+        /** When to run this particular validation */
+        trigger?: 'navigation' | 'change' | 'load';
+        /**
+         * Each validation is passed the value of the data to run it's validation against.
+         * By default, this is the value stored in the data-model (deformatted).
+         * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+        */
+        dataTarget?: 'formatted' | 'deformatted';
+        /** Where the error should be displayed */
+        displayTarget?: 'page' | 'section' | 'field';
+        /**
+         * If the validation blocks navigation
+         * true/false - always/never block navigation
+         * once - only block navigation if the validation has not been triggered before
+        */
+        blocking?: boolean | 'once';
+        [key: string]: unknown;
+    }>;
+    /**
+     * A reference to a specific data format to use.
+     * If none is specified, will fallback to that of the base type
+    */
+    format?: {
+        /** The name of the formatter (and de-formatter) to use */
+        type: string;
+        [key: string]: unknown;
+    };
+    /**
+     * A default value for this property.
+     * Any reads for this property will result in this default value being written to the model.
+    */
+    default?: T;
+    [key: string]: unknown;
+}
+/** Determines if the Datatype is a record object */
+export interface Schema.RecordType {
+    /** The reference of the base type to use */
+    type: string;
+    /**
+     * Any additional validations that are associated with this property
+     * These will add to any base validations associated with the "type"
+    */
+    validation?: Array<{
+        /**
+         * The name of the referenced validation type
+         * This will be used to lookup the proper handler
+        */
+        type: string;
+        /** An optional means of overriding the default message if the validation is triggered */
+        message?: string;
+        /** An optional means of overriding the default severity of the validation if triggered */
+        severity?: 'error' | 'warning';
+        /** When to run this particular validation */
+        trigger?: 'navigation' | 'change' | 'load';
+        /**
+         * Each validation is passed the value of the data to run it's validation against.
+         * By default, this is the value stored in the data-model (deformatted).
+         * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+        */
+        dataTarget?: 'formatted' | 'deformatted';
+        /** Where the error should be displayed */
+        displayTarget?: 'page' | 'section' | 'field';
+        /**
+         * If the validation blocks navigation
+         * true/false - always/never block navigation
+         * once - only block navigation if the validation has not been triggered before
+        */
+        blocking?: boolean | 'once';
+        [key: string]: unknown;
+    }>;
+    /**
+     * A reference to a specific data format to use.
+     * If none is specified, will fallback to that of the base type
+    */
+    format?: {
+        /** The name of the formatter (and de-formatter) to use */
+        type: string;
+        [key: string]: unknown;
+    };
+    /**
+     * A default value for this property.
+     * Any reads for this property will result in this default value being written to the model.
+    */
+    default?: T;
+    /** boolean to define if its a record */
+    isRecord: boolean;
+    /** This property is mutually exclusive with RecordType and can not be used with ArrayType */
+    isArray?: never;
+    [key: string]: unknown;
+}
+/** Determines if the DataType is an Array Object */
+export interface Schema.ArrayType {
+    /** The reference of the base type to use */
+    type: string;
+    /**
+     * Any additional validations that are associated with this property
+     * These will add to any base validations associated with the "type"
+    */
+    validation?: Array<{
+        /**
+         * The name of the referenced validation type
+         * This will be used to lookup the proper handler
+        */
+        type: string;
+        /** An optional means of overriding the default message if the validation is triggered */
+        message?: string;
+        /** An optional means of overriding the default severity of the validation if triggered */
+        severity?: 'error' | 'warning';
+        /** When to run this particular validation */
+        trigger?: 'navigation' | 'change' | 'load';
+        /**
+         * Each validation is passed the value of the data to run it's validation against.
+         * By default, this is the value stored in the data-model (deformatted).
+         * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+        */
+        dataTarget?: 'formatted' | 'deformatted';
+        /** Where the error should be displayed */
+        displayTarget?: 'page' | 'section' | 'field';
+        /**
+         * If the validation blocks navigation
+         * true/false - always/never block navigation
+         * once - only block navigation if the validation has not been triggered before
+        */
+        blocking?: boolean | 'once';
+        [key: string]: unknown;
+    }>;
+    /**
+     * A reference to a specific data format to use.
+     * If none is specified, will fallback to that of the base type
+    */
+    format?: {
+        /** The name of the formatter (and de-formatter) to use */
+        type: string;
+        [key: string]: unknown;
+    };
+    /**
+     * A default value for this property.
+     * Any reads for this property will result in this default value being written to the model.
+    */
+    default?: T;
+    /** boolean to define if its an array */
+    isArray: boolean;
+    /** This property is mutually exclusive with ArrayType and can not be used with RecordType */
+    isRecord?: never;
+    [key: string]: unknown;
+}
+/** Helper to compliment \`Schema.DataType\` to provide a way to export a reference to a data type instead of the whole object */
+export interface Language.DataTypeRef {
+    /** Name of the type in Player Core */
+    type: string;
+}
+/** A reference to a specific formatter */
+export interface Formatting.Reference {
+    /** The name of the formatter (and de-formatter) to use */
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * How serious are you about this error?
+ * Warning validations are reserved for errors that could be ignored by the user without consequence
+ * Errors must be fixed before proceeding
+*/
+export type Validation.Severity = 'error' | 'warning';
+/**
+ * When to _first_ start caring about a validation of a data-val.
+ *
+ * load - only check once the first time the binding appears on screen
+ * change - check anytime the data changes
+ * navigation - check once the user attempts to navigate away from a view
+*/
+export type Validation.Trigger = 'navigation' | 'change' | 'load';
+/**
+ * Where the error/warning should be displayed.
+ * - \`field\` is the default display target. This renders the error/warning directly underneath the field.
+ * - \`section\` is used to display a message at a parent node that is designated as a "section"
+ * - \`page\` a special section used to display a message at the top of the page.
+*/
+export type Validation.DisplayTarget = 'page' | 'section' | 'field';
+/** A reference to a validation object */
+export interface Validation.Reference {
+    /**
+     * The name of the referenced validation type
+     * This will be used to lookup the proper handler
+    */
+    type: string;
+    /** An optional means of overriding the default message if the validation is triggered */
+    message?: string;
+    /** An optional means of overriding the default severity of the validation if triggered */
+    severity?: 'error' | 'warning';
+    /** When to run this particular validation */
+    trigger?: 'navigation' | 'change' | 'load';
+    /**
+     * Each validation is passed the value of the data to run it's validation against.
+     * By default, this is the value stored in the data-model (deformatted).
+     * In the off chance you'd like this validator to run against the formatted value (the one the user sees), set this option
+    */
+    dataTarget?: 'formatted' | 'deformatted';
+    /** Where the error should be displayed */
+    displayTarget?: 'page' | 'section' | 'field';
+    /**
+     * If the validation blocks navigation
+     * true/false - always/never block navigation
+     * once - only block navigation if the validation has not been triggered before
+    */
+    blocking?: boolean | 'once';
+    [key: string]: unknown;
+}
+export interface Validation.CrossfieldReference {
+    /**
+     * The name of the referenced validation type
+     * This will be used to lookup the proper handler
+    */
+    type: string;
+    /** An optional means of overriding the default message if the validation is triggered */
+    message?: string;
+    /** An optional means of overriding the default severity of the validation if triggered */
+    severity?: 'error' | 'warning';
+    /** When to run this particular validation */
+    trigger?: 'navigation' | 'change' | 'load';
+    /** Cross-field references and validation must run against the default (deformatted) value */
+    dataTarget?: never;
+    /** Where the error should be displayed */
+    displayTarget?: 'page' | 'section' | 'field';
+    /**
+     * If the validation blocks navigation
+     * true/false - always/never block navigation
+     * once - only block navigation if the validation has not been triggered before
+    */
+    blocking?: boolean | 'once';
+    /** The binding to associate this validation with */
+    ref?: Binding;
+    [key: string]: unknown;
+}
+/**
+ * This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+ * Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.
+*/
+export interface InputAsset<AnyTextAsset extends Asset = Asset> extends Asset<'input'> {
+    /** Asset container for a field label. */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** Asset container for a note. */
+    note?: AssetWrapper<AnyTextAsset>;
+    /** The location in the data-model to store the data */
+    binding: Binding;
+    /** Optional additional data */
+    metaData?: {
+        /** Additional data to beacon when this input changes */
+        beacon?: string | Record<string, any>;
+    };
+}
+export interface TextAsset extends Asset<'text'> {
+    /** The text to display */
+    value: string;
+    /** Any modifiers on the text */
+    modifiers?: Array<{
+        /** The modifier type */
+        type: string;
+        /** Modifiers can be named when used in strings */
+        name?: string;
+        [key: string]: unknown;
+    } | {
+        /** The link type denotes this as a link */
+        type: 'link';
+        /** An optional expression to run before the link is opened */
+        exp?: Expression;
+        /** metaData about the link's target */
+        metaData: {
+            /** The location of the link to load */
+            ref: string;
+            /** Used to indicate an application specific resolver to use */
+            'mime-type'?: string;
+        };
+    }>;
+}
+/**
+ * User actions can be represented in several places.
+ * Each view typically has one or more actions that allow the user to navigate away from that view.
+ * In addition, several asset types can have actions that apply to that asset only.
+*/
+export interface ActionAsset<AnyTextAsset extends Asset = Asset> extends Asset<'action'> {
+    /** The transition value of the action in the state machine */
+    value?: string;
+    /** A text-like asset for the action's label */
+    label?: AssetWrapper<AnyTextAsset>;
+    /** An optional expression to execute before transitioning */
+    exp?: Expression;
+    /** An optional string that describes the action for screen-readers */
+    accessibility?: string;
+    /** Additional optional data to assist with the action interactions on the page */
+    metaData?: {
+        /** Additional data to beacon */
+        beacon?: string | Record<string, any>;
+        /** Force transition to the next view without checking for validation */
+        skipValidation?: boolean;
+    };
+}
+export interface InfoAsset extends Asset<'info'> {
+    /** The string value to show */
+    title?: AssetWrapper;
+    /** subtitle */
+    subTitle?: AssetWrapper;
+    /** Primary place for info */
+    primaryInfo?: AssetWrapper;
+    /** List of actions to show at the bottom of the page */
+    actions?: Array<AssetWrapper>;
+}
+export interface CollectionAsset extends Asset<'collection'> {
+    /** An optional label to title the collection */
+    label?: AssetWrapper;
+    /** The string value to show */
+    values?: Array<AssetWrapper>;
+}"
+`;
+
+exports[`Object Recall > Optimized 1`] = `
+{
+  "additionalProperties": {
+    "type": "unknown",
+  },
+  "description": "This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.",
+  "extends": undefined,
+  "genericTokens": [
+    {
+      "constraints": {
+        "additionalProperties": {
+          "type": "unknown",
+        },
+        "description": "An asset is the smallest unit of user interaction in a player view",
+        "extends": undefined,
+        "genericTokens": [
+          {
+            "constraints": {
+              "type": "string",
+            },
+            "default": {
+              "type": "string",
+            },
+            "symbol": "T",
+          },
+        ],
+        "name": "Asset",
+        "properties": {
+          "id": {
+            "node": {
+              "description": "Each asset requires a unique id per view",
+              "title": "Asset.id",
+              "type": "string",
+            },
+            "required": true,
+          },
+          "type": {
+            "node": {
+              "description": "The asset type determines the semantics of how a user interacts with a page",
+              "title": "Asset.type",
+              "type": "string",
+            },
+            "required": true,
+          },
+        },
+        "source": "src/index.ts",
+        "title": "Asset",
+        "type": "object",
+      },
+      "default": {
+        "additionalProperties": {
+          "type": "unknown",
+        },
+        "description": "An asset is the smallest unit of user interaction in a player view",
+        "extends": undefined,
+        "genericTokens": [
+          {
+            "constraints": {
+              "type": "string",
+            },
+            "default": {
+              "type": "string",
+            },
+            "symbol": "T",
+          },
+        ],
+        "name": "Asset",
+        "properties": {
+          "id": {
+            "node": {
+              "description": "Each asset requires a unique id per view",
+              "title": "Asset.id",
+              "type": "string",
+            },
+            "required": true,
+          },
+          "type": {
+            "node": {
+              "description": "The asset type determines the semantics of how a user interacts with a page",
+              "title": "Asset.type",
+              "type": "string",
+            },
+            "required": true,
+          },
+        },
+        "source": "src/index.ts",
+        "title": "Asset",
+        "type": "object",
+      },
+      "symbol": "AnyTextAsset",
+    },
+  ],
+  "name": "InputAsset",
+  "properties": {
+    "binding": {
+      "node": {
+        "description": "Bindings describe locations in the data model.",
+        "name": "Binding",
+        "source": "src/index.ts",
+        "title": "Binding",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "id": {
+      "node": {
+        "description": "Each asset requires a unique id per view",
+        "title": "Asset.id",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "label": {
+      "node": {
+        "additionalProperties": {
+          "type": "unknown",
+        },
+        "description": "An object that contains an asset",
+        "extends": undefined,
+        "genericTokens": [],
+        "name": "AssetWrapper",
+        "properties": {
+          "asset": {
+            "node": {
+              "additionalProperties": {
+                "type": "unknown",
+              },
+              "description": "An asset is the smallest unit of user interaction in a player view",
+              "extends": undefined,
+              "genericTokens": [
+                {
+                  "constraints": {
+                    "type": "string",
+                  },
+                  "default": {
+                    "type": "string",
+                  },
+                  "symbol": "T",
+                },
+              ],
+              "name": "Asset",
+              "properties": {
+                "id": {
+                  "node": {
+                    "description": "Each asset requires a unique id per view",
+                    "title": "Asset.id",
+                    "type": "string",
+                  },
+                  "required": true,
+                },
+                "type": {
+                  "node": {
+                    "description": "The asset type determines the semantics of how a user interacts with a page",
+                    "title": "Asset.type",
+                    "type": "string",
+                  },
+                  "required": true,
+                },
+              },
+              "source": "src/index.ts",
+              "title": "Asset",
+              "type": "object",
+            },
+            "required": true,
+          },
+        },
+        "source": "src/index.ts",
+        "title": "AssetWrapper",
+        "type": "object",
+      },
+      "required": false,
+    },
+    "metaData": {
+      "node": {
+        "additionalProperties": false,
+        "description": "Optional additional data",
+        "extends": undefined,
+        "properties": {
+          "beacon": {
+            "node": {
+              "description": "Additional data to beacon when this input changes",
+              "name": "BeaconDataType",
+              "or": [
+                {
+                  "title": "BeaconDataType",
+                  "type": "string",
+                },
+                {
+                  "keyType": {
+                    "type": "string",
+                  },
+                  "title": "BeaconDataType",
+                  "type": "record",
+                  "valueType": {
+                    "type": "any",
+                  },
+                },
+              ],
+              "source": "/private/var/tmp/_bazel_kreddy8/6fc13ccb395252816f0c23d8394e8532/sandbox/darwin-sandbox/134/execroot/player/node_modules/@player-ui/beacon-plugin/dist/index.d.ts",
+              "title": "InputAsset.metaData.beacon",
+              "type": "or",
+            },
+            "required": false,
+          },
+        },
+        "title": "InputAsset.metaData",
+        "type": "object",
+      },
+      "required": false,
+    },
+    "note": {
+      "node": {
+        "additionalProperties": {
+          "type": "unknown",
+        },
+        "description": "An object that contains an asset",
+        "extends": undefined,
+        "genericTokens": [],
+        "name": "AssetWrapper",
+        "properties": {
+          "asset": {
+            "node": {
+              "additionalProperties": {
+                "type": "unknown",
+              },
+              "description": "An asset is the smallest unit of user interaction in a player view",
+              "extends": undefined,
+              "genericTokens": [
+                {
+                  "constraints": {
+                    "type": "string",
+                  },
+                  "default": {
+                    "type": "string",
+                  },
+                  "symbol": "T",
+                },
+              ],
+              "name": "Asset",
+              "properties": {
+                "id": {
+                  "node": {
+                    "description": "Each asset requires a unique id per view",
+                    "title": "Asset.id",
+                    "type": "string",
+                  },
+                  "required": true,
+                },
+                "type": {
+                  "node": {
+                    "description": "The asset type determines the semantics of how a user interacts with a page",
+                    "title": "Asset.type",
+                    "type": "string",
+                  },
+                  "required": true,
+                },
+              },
+              "source": "src/index.ts",
+              "title": "Asset",
+              "type": "object",
+            },
+            "required": true,
+          },
+        },
+        "source": "src/index.ts",
+        "title": "AssetWrapper",
+        "type": "object",
+      },
+      "required": false,
+    },
+    "type": {
+      "node": {
+        "const": "input",
+        "description": "The asset type determines the semantics of how a user interacts with a page",
+        "title": "Asset.type",
+        "type": "string",
+      },
+      "required": true,
+    },
+  },
+  "source": "src/index.ts",
+  "title": "Asset",
+  "type": "object",
+}
+`;
+
+exports[`Object Recall > Processed 1`] = `
+{
+  "additionalProperties": {
+    "type": "unknown",
+  },
+  "description": "This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.",
+  "extends": undefined,
+  "genericTokens": [
+    {
+      "constraints": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "default": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "symbol": "AnyTextAsset",
+    },
+  ],
+  "name": "InputAsset",
+  "properties": {
+    "binding": {
+      "node": {
+        "description": "The location in the data-model to store the data",
+        "ref": "Binding",
+        "title": "InputAsset.binding",
+        "type": "ref",
+      },
+      "required": true,
+    },
+    "id": {
+      "node": {
+        "description": "Each asset requires a unique id per view",
+        "title": "Asset.id",
+        "type": "string",
+      },
+      "required": true,
+    },
+    "label": {
+      "node": {
+        "description": "Asset container for a field label.",
+        "genericArguments": [
+          {
+            "ref": "Asset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapper<AnyTextAsset>",
+        "title": "InputAsset.label",
+        "type": "ref",
+      },
+      "required": false,
+    },
+    "metaData": {
+      "node": {
+        "additionalProperties": false,
+        "description": "Optional additional data",
+        "extends": undefined,
+        "properties": {
+          "beacon": {
+            "node": {
+              "description": "Additional data to beacon when this input changes",
+              "name": "BeaconDataType",
+              "or": [
+                {
+                  "title": "BeaconDataType",
+                  "type": "string",
+                },
+                {
+                  "keyType": {
+                    "type": "string",
+                  },
+                  "title": "BeaconDataType",
+                  "type": "record",
+                  "valueType": {
+                    "type": "any",
+                  },
+                },
+              ],
+              "source": "/private/var/tmp/_bazel_kreddy8/6fc13ccb395252816f0c23d8394e8532/sandbox/darwin-sandbox/134/execroot/player/node_modules/@player-ui/beacon-plugin/dist/index.d.ts",
+              "title": "InputAsset.metaData.beacon",
+              "type": "or",
+            },
+            "required": false,
+          },
+        },
+        "title": "InputAsset.metaData",
+        "type": "object",
+      },
+      "required": false,
+    },
+    "note": {
+      "node": {
+        "description": "Asset container for a note.",
+        "genericArguments": [
+          {
+            "ref": "Asset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapper<AnyTextAsset>",
+        "title": "InputAsset.note",
+        "type": "ref",
+      },
+      "required": false,
+    },
+    "type": {
+      "node": {
+        "const": "input",
+        "description": "The asset type determines the semantics of how a user interacts with a page",
+        "title": "Asset.type",
+        "type": "string",
+      },
+      "required": true,
+    },
+  },
+  "source": "src/index.ts",
+  "title": "Asset",
+  "type": "object",
+}
+`;
+
+exports[`Object Recall > Raw 1`] = `
+{
+  "additionalProperties": false,
+  "description": "This is the most generic way of gathering data. The input is bound to a data model using the 'binding' property.
+Players can get field type information from the 'schema' definition, thus to decide the input controls for visual rendering.",
+  "extends": {
+    "genericArguments": [
+      {
+        "const": "input",
+        "type": "string",
+      },
+    ],
+    "ref": "Asset<'input'>",
+    "type": "ref",
+  },
+  "genericTokens": [
+    {
+      "constraints": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "default": {
+        "ref": "Asset",
+        "type": "ref",
+      },
+      "symbol": "AnyTextAsset",
+    },
+  ],
+  "name": "InputAsset",
+  "properties": {
+    "binding": {
+      "node": {
+        "description": "The location in the data-model to store the data",
+        "ref": "Binding",
+        "title": "InputAsset.binding",
+        "type": "ref",
+      },
+      "required": true,
+    },
+    "label": {
+      "node": {
+        "description": "Asset container for a field label.",
+        "genericArguments": [
+          {
+            "ref": "AnyTextAsset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapper<AnyTextAsset>",
+        "title": "InputAsset.label",
+        "type": "ref",
+      },
+      "required": false,
+    },
+    "metaData": {
+      "node": {
+        "additionalProperties": false,
+        "description": "Optional additional data",
+        "properties": {
+          "beacon": {
+            "node": {
+              "description": "Additional data to beacon when this input changes",
+              "name": "BeaconDataType",
+              "or": [
+                {
+                  "title": "BeaconDataType",
+                  "type": "string",
+                },
+                {
+                  "keyType": {
+                    "type": "string",
+                  },
+                  "title": "BeaconDataType",
+                  "type": "record",
+                  "valueType": {
+                    "type": "any",
+                  },
+                },
+              ],
+              "source": "/private/var/tmp/_bazel_kreddy8/6fc13ccb395252816f0c23d8394e8532/sandbox/darwin-sandbox/134/execroot/player/node_modules/@player-ui/beacon-plugin/dist/index.d.ts",
+              "title": "InputAsset.metaData.beacon",
+              "type": "or",
+            },
+            "required": false,
+          },
+        },
+        "title": "InputAsset.metaData",
+        "type": "object",
+      },
+      "required": false,
+    },
+    "note": {
+      "node": {
+        "description": "Asset container for a note.",
+        "genericArguments": [
+          {
+            "ref": "AnyTextAsset",
+            "type": "ref",
+          },
+        ],
+        "ref": "AssetWrapper<AnyTextAsset>",
+        "title": "InputAsset.note",
+        "type": "ref",
+      },
+      "required": false,
+    },
+  },
+  "source": "/private/var/tmp/_bazel_kreddy8/6fc13ccb395252816f0c23d8394e8532/sandbox/darwin-sandbox/134/execroot/player/node_modules/@player-ui/reference-assets-plugin/dist/index.d.ts",
+  "title": "InputAsset",
+  "type": "object",
+}
+`;
+
+exports[`Validation > Basic Validation By Name 1`] = `
+[
+  {
+    "expected": "string",
+    "message": "Expected type "string" but got "number"",
+    "node": {
+      "children": [
+        {
+          "length": 4,
+          "offset": 13,
+          "parent": [Circular],
+          "type": "string",
+          "value": "id",
+        },
+        {
+          "length": 1,
+          "offset": 19,
+          "parent": [Circular],
+          "type": "number",
+          "value": 1,
+        },
+      ],
+      "colonOffset": 17,
+      "length": 7,
+      "offset": 13,
+      "parent": {
+        "children": [
+          [Circular],
+          {
+            "children": [
+              {
+                "length": 6,
+                "offset": 28,
+                "parent": [Circular],
+                "type": "string",
+                "value": "type",
+              },
+              {
+                "length": 7,
+                "offset": 36,
+                "parent": [Circular],
+                "type": "string",
+                "value": "input",
+              },
+            ],
+            "colonOffset": 34,
+            "length": 15,
+            "offset": 28,
+            "parent": [Circular],
+            "type": "property",
+          },
+          {
+            "children": [
+              {
+                "length": 9,
+                "offset": 51,
+                "parent": [Circular],
+                "type": "string",
+                "value": "binding",
+              },
+              {
+                "length": 11,
+                "offset": 62,
+                "parent": [Circular],
+                "type": "string",
+                "value": "some.data",
+              },
+            ],
+            "colonOffset": 60,
+            "length": 22,
+            "offset": 51,
+            "parent": [Circular],
+            "type": "property",
+          },
+          {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              {
+                "children": [
+                  {
+                    "children": [
+                      {
+                        "length": 7,
+                        "offset": 100,
+                        "parent": [Circular],
+                        "type": "string",
+                        "value": "asset",
+                      },
+                      {
+                        "children": [
+                          {
+                            "children": [
+                              {
+                                "length": 7,
+                                "offset": 121,
+                                "parent": [Circular],
+                                "type": "string",
+                                "value": "value",
+                              },
+                              {
+                                "length": 17,
+                                "offset": 130,
+                                "parent": [Circular],
+                                "type": "string",
+                                "value": "{{input.label}}",
+                              },
+                            ],
+                            "colonOffset": 128,
+                            "length": 26,
+                            "offset": 121,
+                            "parent": [Circular],
+                            "type": "property",
+                          },
+                        ],
+                        "length": 48,
+                        "offset": 109,
+                        "parent": [Circular],
+                        "type": "object",
+                      },
+                    ],
+                    "colonOffset": 107,
+                    "length": 57,
+                    "offset": 100,
+                    "parent": [Circular],
+                    "type": "property",
+                  },
+                ],
+                "length": 75,
+                "offset": 90,
+                "parent": [Circular],
+                "type": "object",
+              },
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": [Circular],
+            "type": "property",
+          },
+        ],
+        "length": 165,
+        "offset": 5,
+        "type": "object",
+      },
+      "type": "property",
+    },
+    "severity": 1,
+    "type": "type",
+  },
+  {
+    "message": "Property "id" missing from type "Asset"",
+    "node": {
+      "children": [
+        {
+          "children": [
+            {
+              "length": 7,
+              "offset": 121,
+              "parent": [Circular],
+              "type": "string",
+              "value": "value",
+            },
+            {
+              "length": 17,
+              "offset": 130,
+              "parent": [Circular],
+              "type": "string",
+              "value": "{{input.label}}",
+            },
+          ],
+          "colonOffset": 128,
+          "length": 26,
+          "offset": 121,
+          "parent": [Circular],
+          "type": "property",
+        },
+      ],
+      "length": 48,
+      "offset": 109,
+      "parent": {
+        "children": [
+          {
+            "length": 7,
+            "offset": 100,
+            "parent": [Circular],
+            "type": "string",
+            "value": "asset",
+          },
+          [Circular],
+        ],
+        "colonOffset": 107,
+        "length": 57,
+        "offset": 100,
+        "parent": {
+          "children": [
+            [Circular],
+          ],
+          "length": 75,
+          "offset": 90,
+          "parent": {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              [Circular],
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": {
+              "children": [
+                {
+                  "children": [
+                    {
+                      "length": 4,
+                      "offset": 13,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "id",
+                    },
+                    {
+                      "length": 1,
+                      "offset": 19,
+                      "parent": [Circular],
+                      "type": "number",
+                      "value": 1,
+                    },
+                  ],
+                  "colonOffset": 17,
+                  "length": 7,
+                  "offset": 13,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 6,
+                      "offset": 28,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "type",
+                    },
+                    {
+                      "length": 7,
+                      "offset": 36,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "input",
+                    },
+                  ],
+                  "colonOffset": 34,
+                  "length": 15,
+                  "offset": 28,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 9,
+                      "offset": 51,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "binding",
+                    },
+                    {
+                      "length": 11,
+                      "offset": 62,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "some.data",
+                    },
+                  ],
+                  "colonOffset": 60,
+                  "length": 22,
+                  "offset": 51,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                [Circular],
+              ],
+              "length": 165,
+              "offset": 5,
+              "type": "object",
+            },
+            "type": "property",
+          },
+          "type": "object",
+        },
+        "type": "property",
+      },
+      "type": "object",
+    },
+    "severity": 1,
+    "type": "missing",
+  },
+  {
+    "message": "Property "type" missing from type "Asset"",
+    "node": {
+      "children": [
+        {
+          "children": [
+            {
+              "length": 7,
+              "offset": 121,
+              "parent": [Circular],
+              "type": "string",
+              "value": "value",
+            },
+            {
+              "length": 17,
+              "offset": 130,
+              "parent": [Circular],
+              "type": "string",
+              "value": "{{input.label}}",
+            },
+          ],
+          "colonOffset": 128,
+          "length": 26,
+          "offset": 121,
+          "parent": [Circular],
+          "type": "property",
+        },
+      ],
+      "length": 48,
+      "offset": 109,
+      "parent": {
+        "children": [
+          {
+            "length": 7,
+            "offset": 100,
+            "parent": [Circular],
+            "type": "string",
+            "value": "asset",
+          },
+          [Circular],
+        ],
+        "colonOffset": 107,
+        "length": 57,
+        "offset": 100,
+        "parent": {
+          "children": [
+            [Circular],
+          ],
+          "length": 75,
+          "offset": 90,
+          "parent": {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              [Circular],
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": {
+              "children": [
+                {
+                  "children": [
+                    {
+                      "length": 4,
+                      "offset": 13,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "id",
+                    },
+                    {
+                      "length": 1,
+                      "offset": 19,
+                      "parent": [Circular],
+                      "type": "number",
+                      "value": 1,
+                    },
+                  ],
+                  "colonOffset": 17,
+                  "length": 7,
+                  "offset": 13,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 6,
+                      "offset": 28,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "type",
+                    },
+                    {
+                      "length": 7,
+                      "offset": 36,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "input",
+                    },
+                  ],
+                  "colonOffset": 34,
+                  "length": 15,
+                  "offset": 28,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 9,
+                      "offset": 51,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "binding",
+                    },
+                    {
+                      "length": 11,
+                      "offset": 62,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "some.data",
+                    },
+                  ],
+                  "colonOffset": 60,
+                  "length": 22,
+                  "offset": 51,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                [Circular],
+              ],
+              "length": 165,
+              "offset": 5,
+              "type": "object",
+            },
+            "type": "property",
+          },
+          "type": "object",
+        },
+        "type": "property",
+      },
+      "type": "object",
+    },
+    "severity": 1,
+    "type": "missing",
+  },
+]
+`;
+
+exports[`Validation > Basic Validation By Type (optimized) 1`] = `
+[
+  {
+    "expected": "string",
+    "message": "Expected type "string" but got "number"",
+    "node": {
+      "children": [
+        {
+          "length": 4,
+          "offset": 13,
+          "parent": [Circular],
+          "type": "string",
+          "value": "id",
+        },
+        {
+          "length": 1,
+          "offset": 19,
+          "parent": [Circular],
+          "type": "number",
+          "value": 1,
+        },
+      ],
+      "colonOffset": 17,
+      "length": 7,
+      "offset": 13,
+      "parent": {
+        "children": [
+          [Circular],
+          {
+            "children": [
+              {
+                "length": 6,
+                "offset": 28,
+                "parent": [Circular],
+                "type": "string",
+                "value": "type",
+              },
+              {
+                "length": 7,
+                "offset": 36,
+                "parent": [Circular],
+                "type": "string",
+                "value": "input",
+              },
+            ],
+            "colonOffset": 34,
+            "length": 15,
+            "offset": 28,
+            "parent": [Circular],
+            "type": "property",
+          },
+          {
+            "children": [
+              {
+                "length": 9,
+                "offset": 51,
+                "parent": [Circular],
+                "type": "string",
+                "value": "binding",
+              },
+              {
+                "length": 11,
+                "offset": 62,
+                "parent": [Circular],
+                "type": "string",
+                "value": "some.data",
+              },
+            ],
+            "colonOffset": 60,
+            "length": 22,
+            "offset": 51,
+            "parent": [Circular],
+            "type": "property",
+          },
+          {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              {
+                "children": [
+                  {
+                    "children": [
+                      {
+                        "length": 7,
+                        "offset": 100,
+                        "parent": [Circular],
+                        "type": "string",
+                        "value": "asset",
+                      },
+                      {
+                        "children": [
+                          {
+                            "children": [
+                              {
+                                "length": 7,
+                                "offset": 121,
+                                "parent": [Circular],
+                                "type": "string",
+                                "value": "value",
+                              },
+                              {
+                                "length": 17,
+                                "offset": 130,
+                                "parent": [Circular],
+                                "type": "string",
+                                "value": "{{input.label}}",
+                              },
+                            ],
+                            "colonOffset": 128,
+                            "length": 26,
+                            "offset": 121,
+                            "parent": [Circular],
+                            "type": "property",
+                          },
+                        ],
+                        "length": 48,
+                        "offset": 109,
+                        "parent": [Circular],
+                        "type": "object",
+                      },
+                    ],
+                    "colonOffset": 107,
+                    "length": 57,
+                    "offset": 100,
+                    "parent": [Circular],
+                    "type": "property",
+                  },
+                ],
+                "length": 75,
+                "offset": 90,
+                "parent": [Circular],
+                "type": "object",
+              },
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": [Circular],
+            "type": "property",
+          },
+        ],
+        "length": 165,
+        "offset": 5,
+        "type": "object",
+      },
+      "type": "property",
+    },
+    "severity": 1,
+    "type": "type",
+  },
+  {
+    "message": "Property "id" missing from type "Asset"",
+    "node": {
+      "children": [
+        {
+          "children": [
+            {
+              "length": 7,
+              "offset": 121,
+              "parent": [Circular],
+              "type": "string",
+              "value": "value",
+            },
+            {
+              "length": 17,
+              "offset": 130,
+              "parent": [Circular],
+              "type": "string",
+              "value": "{{input.label}}",
+            },
+          ],
+          "colonOffset": 128,
+          "length": 26,
+          "offset": 121,
+          "parent": [Circular],
+          "type": "property",
+        },
+      ],
+      "length": 48,
+      "offset": 109,
+      "parent": {
+        "children": [
+          {
+            "length": 7,
+            "offset": 100,
+            "parent": [Circular],
+            "type": "string",
+            "value": "asset",
+          },
+          [Circular],
+        ],
+        "colonOffset": 107,
+        "length": 57,
+        "offset": 100,
+        "parent": {
+          "children": [
+            [Circular],
+          ],
+          "length": 75,
+          "offset": 90,
+          "parent": {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              [Circular],
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": {
+              "children": [
+                {
+                  "children": [
+                    {
+                      "length": 4,
+                      "offset": 13,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "id",
+                    },
+                    {
+                      "length": 1,
+                      "offset": 19,
+                      "parent": [Circular],
+                      "type": "number",
+                      "value": 1,
+                    },
+                  ],
+                  "colonOffset": 17,
+                  "length": 7,
+                  "offset": 13,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 6,
+                      "offset": 28,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "type",
+                    },
+                    {
+                      "length": 7,
+                      "offset": 36,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "input",
+                    },
+                  ],
+                  "colonOffset": 34,
+                  "length": 15,
+                  "offset": 28,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 9,
+                      "offset": 51,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "binding",
+                    },
+                    {
+                      "length": 11,
+                      "offset": 62,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "some.data",
+                    },
+                  ],
+                  "colonOffset": 60,
+                  "length": 22,
+                  "offset": 51,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                [Circular],
+              ],
+              "length": 165,
+              "offset": 5,
+              "type": "object",
+            },
+            "type": "property",
+          },
+          "type": "object",
+        },
+        "type": "property",
+      },
+      "type": "object",
+    },
+    "severity": 1,
+    "type": "missing",
+  },
+  {
+    "message": "Property "type" missing from type "Asset"",
+    "node": {
+      "children": [
+        {
+          "children": [
+            {
+              "length": 7,
+              "offset": 121,
+              "parent": [Circular],
+              "type": "string",
+              "value": "value",
+            },
+            {
+              "length": 17,
+              "offset": 130,
+              "parent": [Circular],
+              "type": "string",
+              "value": "{{input.label}}",
+            },
+          ],
+          "colonOffset": 128,
+          "length": 26,
+          "offset": 121,
+          "parent": [Circular],
+          "type": "property",
+        },
+      ],
+      "length": 48,
+      "offset": 109,
+      "parent": {
+        "children": [
+          {
+            "length": 7,
+            "offset": 100,
+            "parent": [Circular],
+            "type": "string",
+            "value": "asset",
+          },
+          [Circular],
+        ],
+        "colonOffset": 107,
+        "length": 57,
+        "offset": 100,
+        "parent": {
+          "children": [
+            [Circular],
+          ],
+          "length": 75,
+          "offset": 90,
+          "parent": {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              [Circular],
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": {
+              "children": [
+                {
+                  "children": [
+                    {
+                      "length": 4,
+                      "offset": 13,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "id",
+                    },
+                    {
+                      "length": 1,
+                      "offset": 19,
+                      "parent": [Circular],
+                      "type": "number",
+                      "value": 1,
+                    },
+                  ],
+                  "colonOffset": 17,
+                  "length": 7,
+                  "offset": 13,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 6,
+                      "offset": 28,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "type",
+                    },
+                    {
+                      "length": 7,
+                      "offset": 36,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "input",
+                    },
+                  ],
+                  "colonOffset": 34,
+                  "length": 15,
+                  "offset": 28,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 9,
+                      "offset": 51,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "binding",
+                    },
+                    {
+                      "length": 11,
+                      "offset": 62,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "some.data",
+                    },
+                  ],
+                  "colonOffset": 60,
+                  "length": 22,
+                  "offset": 51,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                [Circular],
+              ],
+              "length": 165,
+              "offset": 5,
+              "type": "object",
+            },
+            "type": "property",
+          },
+          "type": "object",
+        },
+        "type": "property",
+      },
+      "type": "object",
+    },
+    "severity": 1,
+    "type": "missing",
+  },
+]
+`;
+
+exports[`Validation > Basic Validation By Type (unoptimized) 1`] = `
+[
+  {
+    "expected": "string",
+    "message": "Expected type "string" but got "number"",
+    "node": {
+      "children": [
+        {
+          "length": 4,
+          "offset": 13,
+          "parent": [Circular],
+          "type": "string",
+          "value": "id",
+        },
+        {
+          "length": 1,
+          "offset": 19,
+          "parent": [Circular],
+          "type": "number",
+          "value": 1,
+        },
+      ],
+      "colonOffset": 17,
+      "length": 7,
+      "offset": 13,
+      "parent": {
+        "children": [
+          [Circular],
+          {
+            "children": [
+              {
+                "length": 6,
+                "offset": 28,
+                "parent": [Circular],
+                "type": "string",
+                "value": "type",
+              },
+              {
+                "length": 7,
+                "offset": 36,
+                "parent": [Circular],
+                "type": "string",
+                "value": "input",
+              },
+            ],
+            "colonOffset": 34,
+            "length": 15,
+            "offset": 28,
+            "parent": [Circular],
+            "type": "property",
+          },
+          {
+            "children": [
+              {
+                "length": 9,
+                "offset": 51,
+                "parent": [Circular],
+                "type": "string",
+                "value": "binding",
+              },
+              {
+                "length": 11,
+                "offset": 62,
+                "parent": [Circular],
+                "type": "string",
+                "value": "some.data",
+              },
+            ],
+            "colonOffset": 60,
+            "length": 22,
+            "offset": 51,
+            "parent": [Circular],
+            "type": "property",
+          },
+          {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              {
+                "children": [
+                  {
+                    "children": [
+                      {
+                        "length": 7,
+                        "offset": 100,
+                        "parent": [Circular],
+                        "type": "string",
+                        "value": "asset",
+                      },
+                      {
+                        "children": [
+                          {
+                            "children": [
+                              {
+                                "length": 7,
+                                "offset": 121,
+                                "parent": [Circular],
+                                "type": "string",
+                                "value": "value",
+                              },
+                              {
+                                "length": 17,
+                                "offset": 130,
+                                "parent": [Circular],
+                                "type": "string",
+                                "value": "{{input.label}}",
+                              },
+                            ],
+                            "colonOffset": 128,
+                            "length": 26,
+                            "offset": 121,
+                            "parent": [Circular],
+                            "type": "property",
+                          },
+                        ],
+                        "length": 48,
+                        "offset": 109,
+                        "parent": [Circular],
+                        "type": "object",
+                      },
+                    ],
+                    "colonOffset": 107,
+                    "length": 57,
+                    "offset": 100,
+                    "parent": [Circular],
+                    "type": "property",
+                  },
+                ],
+                "length": 75,
+                "offset": 90,
+                "parent": [Circular],
+                "type": "object",
+              },
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": [Circular],
+            "type": "property",
+          },
+        ],
+        "length": 165,
+        "offset": 5,
+        "type": "object",
+      },
+      "type": "property",
+    },
+    "severity": 1,
+    "type": "type",
+  },
+  {
+    "message": "Property "id" missing from type "Asset"",
+    "node": {
+      "children": [
+        {
+          "children": [
+            {
+              "length": 7,
+              "offset": 121,
+              "parent": [Circular],
+              "type": "string",
+              "value": "value",
+            },
+            {
+              "length": 17,
+              "offset": 130,
+              "parent": [Circular],
+              "type": "string",
+              "value": "{{input.label}}",
+            },
+          ],
+          "colonOffset": 128,
+          "length": 26,
+          "offset": 121,
+          "parent": [Circular],
+          "type": "property",
+        },
+      ],
+      "length": 48,
+      "offset": 109,
+      "parent": {
+        "children": [
+          {
+            "length": 7,
+            "offset": 100,
+            "parent": [Circular],
+            "type": "string",
+            "value": "asset",
+          },
+          [Circular],
+        ],
+        "colonOffset": 107,
+        "length": 57,
+        "offset": 100,
+        "parent": {
+          "children": [
+            [Circular],
+          ],
+          "length": 75,
+          "offset": 90,
+          "parent": {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              [Circular],
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": {
+              "children": [
+                {
+                  "children": [
+                    {
+                      "length": 4,
+                      "offset": 13,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "id",
+                    },
+                    {
+                      "length": 1,
+                      "offset": 19,
+                      "parent": [Circular],
+                      "type": "number",
+                      "value": 1,
+                    },
+                  ],
+                  "colonOffset": 17,
+                  "length": 7,
+                  "offset": 13,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 6,
+                      "offset": 28,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "type",
+                    },
+                    {
+                      "length": 7,
+                      "offset": 36,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "input",
+                    },
+                  ],
+                  "colonOffset": 34,
+                  "length": 15,
+                  "offset": 28,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 9,
+                      "offset": 51,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "binding",
+                    },
+                    {
+                      "length": 11,
+                      "offset": 62,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "some.data",
+                    },
+                  ],
+                  "colonOffset": 60,
+                  "length": 22,
+                  "offset": 51,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                [Circular],
+              ],
+              "length": 165,
+              "offset": 5,
+              "type": "object",
+            },
+            "type": "property",
+          },
+          "type": "object",
+        },
+        "type": "property",
+      },
+      "type": "object",
+    },
+    "severity": 1,
+    "type": "missing",
+  },
+  {
+    "message": "Property "type" missing from type "Asset"",
+    "node": {
+      "children": [
+        {
+          "children": [
+            {
+              "length": 7,
+              "offset": 121,
+              "parent": [Circular],
+              "type": "string",
+              "value": "value",
+            },
+            {
+              "length": 17,
+              "offset": 130,
+              "parent": [Circular],
+              "type": "string",
+              "value": "{{input.label}}",
+            },
+          ],
+          "colonOffset": 128,
+          "length": 26,
+          "offset": 121,
+          "parent": [Circular],
+          "type": "property",
+        },
+      ],
+      "length": 48,
+      "offset": 109,
+      "parent": {
+        "children": [
+          {
+            "length": 7,
+            "offset": 100,
+            "parent": [Circular],
+            "type": "string",
+            "value": "asset",
+          },
+          [Circular],
+        ],
+        "colonOffset": 107,
+        "length": 57,
+        "offset": 100,
+        "parent": {
+          "children": [
+            [Circular],
+          ],
+          "length": 75,
+          "offset": 90,
+          "parent": {
+            "children": [
+              {
+                "length": 7,
+                "offset": 81,
+                "parent": [Circular],
+                "type": "string",
+                "value": "label",
+              },
+              [Circular],
+            ],
+            "colonOffset": 88,
+            "length": 84,
+            "offset": 81,
+            "parent": {
+              "children": [
+                {
+                  "children": [
+                    {
+                      "length": 4,
+                      "offset": 13,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "id",
+                    },
+                    {
+                      "length": 1,
+                      "offset": 19,
+                      "parent": [Circular],
+                      "type": "number",
+                      "value": 1,
+                    },
+                  ],
+                  "colonOffset": 17,
+                  "length": 7,
+                  "offset": 13,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 6,
+                      "offset": 28,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "type",
+                    },
+                    {
+                      "length": 7,
+                      "offset": 36,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "input",
+                    },
+                  ],
+                  "colonOffset": 34,
+                  "length": 15,
+                  "offset": 28,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                {
+                  "children": [
+                    {
+                      "length": 9,
+                      "offset": 51,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "binding",
+                    },
+                    {
+                      "length": 11,
+                      "offset": 62,
+                      "parent": [Circular],
+                      "type": "string",
+                      "value": "some.data",
+                    },
+                  ],
+                  "colonOffset": 60,
+                  "length": 22,
+                  "offset": 51,
+                  "parent": [Circular],
+                  "type": "property",
+                },
+                [Circular],
+              ],
+              "length": 165,
+              "offset": 5,
+              "type": "object",
+            },
+            "type": "property",
+          },
+          "type": "object",
+        },
+        "type": "property",
+      },
+      "type": "object",
+    },
+    "severity": 1,
+    "type": "missing",
+  },
+]
+`;