@player-ui/player 0.3.0-next.3 → 0.3.0-next.5

package/dist/index.d.ts

@@ -1,64 +1,1047 @@
 import * as _player_ui_types from '@player-ui/types';
-import { Asset, Validation, Flow, FlowResult, NavigationFlowViewState, View } from '@player-ui/types';
+import { Formatting, NavigationFlowState, NavigationFlow, NavigationFlowEndState, Navigation, Asset, Expression, Binding, Schema, Validation, View as View$1, Flow, FlowResult, NavigationFlowViewState } from '@player-ui/types';
 export * from '@player-ui/types';
-import { BindingInstance, BindingFactory, BindingParser, BindingLike } from '@player-ui/binding';
-export * from '@player-ui/binding';
-import { DataModelMiddleware, DataModelWithParser, DataModelOptions, DataPipeline, BatchSetTransaction, Updates, PipelinedDataModel } from '@player-ui/data';
-export * from '@player-ui/data';
-import { ExpressionEvaluator } from '@player-ui/expressions';
-export * from '@player-ui/expressions';
-import { FlowController } from '@player-ui/flow';
-export * from '@player-ui/flow';
-import { Logger, TapableLogger } from '@player-ui/logger';
-export * from '@player-ui/logger';
-import { SchemaController } from '@player-ui/schema';
-export * from '@player-ui/schema';
-export * from '@player-ui/string-resolver';
-import * as _player_ui_validator from '@player-ui/validator';
-import { ValidatorRegistry, ValidationResponse, ValidatorContext, ValidationObject, WarningValidationResponse, ErrorValidationResponse } from '@player-ui/validator';
-export * from '@player-ui/validator';
-import { Node, Resolve, ViewPlugin, Resolver, ViewInstance } from '@player-ui/view';
-export * from '@player-ui/view';
-import { SyncHook, SyncWaterfallHook, SyncBailHook } from 'tapable-ts';
-import { ConstantsController } from '@player-ui/constants';
+import { SyncBailHook, SyncWaterfallHook, SyncHook } from 'tapable-ts';
 import { Registry } from '@player-ui/partial-match-registry';
 
-interface Store {
-    useLocalState<T>(initialState: T): readonly [T, (value: T) => void];
-    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (value: T) => void];
+interface Node$1<T extends string> {
+    /** The basic node type */
+    name: T;
 }
-interface SharedStore {
-    getLocalStateFunction<T>(key: string | symbol, countKey: symbol): (initialState: T) => readonly [T, (value: T) => void];
-    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (value: T) => void];
+/**
+ * An AST node that represents a nested path in the model
+ * foo.{{bar}}.baz (this is {{bar}})
+ */
+interface PathNode extends Node$1<'PathNode'> {
+    /** The path in the model that this node represents */
+    path: Array<AnyNode>;
 }
-/** A store that holds on to state for a transform */
-declare class LocalStateStore implements SharedStore {
-    private state;
-    private updateCallback?;
-    constructor(onUpdate?: () => void);
-    removeKey(key: symbol | string): void;
+/**
+ * A segment representing a query
+ * [foo=bar]
+ */
+interface QueryNode extends Node$1<'Query'> {
+    /** The key to query */
+    key: AnyNode;
+    /** The target value */
+    value?: AnyNode;
+}
+/** A simple segment */
+interface ValueNode extends Node$1<'Value'> {
+    /** The segment value */
+    value: string | number;
+}
+/** A nested expression */
+interface ExpressionNode$1 extends Node$1<'Expression'> {
+    /** The expression */
+    value: string;
+}
+/**
+ * A binding segment that's multiple smaller ones
+ * {{foo}}_bar_{{baz}}
+ */
+interface ConcatenatedNode extends Node$1<'Concatenated'> {
+    /** A list of nested paths, or value nodes to concat together to form a segment */
+    value: Array<PathNode | ValueNode | ExpressionNode$1>;
+}
+declare type AnyNode = PathNode | QueryNode | ValueNode | ConcatenatedNode | ExpressionNode$1;
+
+interface BindingParserOptions {
+    /** Get the value for a specific binding */
+    get: (binding: BindingInstance) => any;
+    /**
+     * Set the values for bindings.
+     * This is used when the query syntax needs to modify an object
+     */
+    set: (transaction: Array<[BindingInstance, any]>) => void;
+    /**
+     * Get the result of evaluating an expression
+     */
+    evaluate: (exp: string) => any;
+}
+declare type Getter = (path: BindingInstance) => any;
+declare type RawBindingSegment = number | string;
+declare type RawBinding = string | RawBindingSegment[];
+declare type BindingLike = RawBinding | BindingInstance;
+declare type BindingFactory = (raw: RawBinding, options?: Partial<BindingParserOptions>) => BindingInstance;
+/**
+ * A path in the data model
+ */
+declare class BindingInstance {
+    private split;
+    private joined;
+    private factory;
+    constructor(raw: RawBinding, factory?: (rawBinding: RawBinding) => BindingInstance);
+    asArray(): RawBindingSegment[];
+    asString(): string;
+    /**
+     * Check to see if the given binding is a sub-path of the current one
+     */
+    contains(binding: BindingInstance): boolean;
+    relative(binding: BindingInstance): RawBindingSegment[];
+    parent(): BindingInstance;
+    key(): RawBindingSegment;
+    /**
+     * This is a utility method to get a binding that is a descendent of this binding
+     *
+     * @param relative - The relative path to descend to
+     */
+    descendent(relative: BindingLike): BindingInstance;
+}
+
+interface NormalizedResult {
+    /** The normalized path */
+    path: Array<string | number>;
+    /** Any new updates that need to happen for this binding to be resolved */
+    updates?: Record<string, any>;
+}
+interface ResolveBindingASTOptions {
+    /** Get the value of the model at the given path */
+    getValue: (path: Array<string | number>) => any;
+    /** Convert the value into valid path segments */
+    convertToPath: (value: any) => string;
+    /** Convert the value into valid path segments */
+    evaluate: (exp: string) => any;
+}
+
+/** Check if the parameter representing a binding is already of the Binding class */
+declare function isBinding(binding: BindingLike): binding is BindingInstance;
+/** Convert the string to an int if you can, otherwise just return the original string */
+declare function maybeConvertToNum(i: string): string | number;
+/**
+ * utility to convert binding into binding segments.
+ */
+declare function getBindingSegments(binding: BindingLike): Array<string | number>;
+/** Like _.findIndex, but ignores types */
+declare function findInArray<T extends Record<string | number, object>>(array: Array<T>, key: string | number, value: T): number | undefined;
+
+declare const SIMPLE_BINDING_REGEX: RegExp;
+/** A parser for creating bindings from a string */
+declare class BindingParser {
+    private cache;
+    private parseCache;
+    private parserOptions;
+    hooks: {
+        skipOptimization: SyncBailHook<[string], boolean, Record<string, any>>;
+        beforeResolveNode: SyncWaterfallHook<[AnyNode, Required<NormalizedResult> & ResolveBindingASTOptions], Record<string, any>>;
+    };
+    constructor(options?: Partial<BindingParserOptions>);
+    /**
+     * Takes a binding path, parses it, and returns an equivalent, normalized
+     * representation of that path.
+     */
+    private normalizePath;
+    private getBindingForNormalizedResult;
+    parse(rawBinding: BindingLike, overrides?: Partial<BindingParserOptions>): BindingInstance;
+}
+
+declare const ROOT_BINDING: BindingInstance;
+declare type BatchSetTransaction = [BindingInstance, any][];
+declare type Updates = Array<{
+    /** The updated binding */
+    binding: BindingInstance;
+    /** The old value */
+    oldValue: any;
+    /** The new value */
+    newValue: any;
+    /** Force the Update to be included even if no data changed */
+    force?: boolean;
+}>;
+/** Options to use when getting or setting data */
+interface DataModelOptions {
+    /**
+     * The data (either to set or get) should represent a formatted value
+     * For setting data, the data will be de-formatted before continuing in the pipeline
+     * For getting data, the data will be formatted before returning
+     */
+    formatted?: boolean;
+    /**
+     * By default, fetching data will ignore any invalid data.
+     * You can choose to grab the queued invalid data if you'd like
+     * This is usually the case for user-inputs
+     */
+    includeInvalid?: boolean;
+    /**
+     * A flag to set to ignore any default value in the schema, and just use the raw value
+     */
+    ignoreDefaultValue?: boolean;
+    /** Other context associated with this request */
+    context?: {
+        /** The data model to use when getting other data from the context of this request */
+        model: DataModelWithParser;
+    };
+}
+interface DataModelWithParser<Options = DataModelOptions> {
+    get(binding: BindingLike, options?: Options): any;
+    set(transaction: [BindingLike, any][], options?: Options): Updates;
+}
+interface DataModelImpl<Options = DataModelOptions> {
+    get(binding: BindingInstance, options?: Options): any;
+    set(transaction: BatchSetTransaction, options?: Options): Updates;
+}
+interface DataModelMiddleware {
+    /** The name of the middleware */
+    name?: string;
+    set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): any;
+    reset?(): void;
+}
+/** Wrap the inputs of the DataModel with calls to parse raw binding inputs */
+declare function withParser<Options = unknown>(model: DataModelImpl<Options>, parseBinding: BindingFactory): DataModelWithParser<Options>;
+/** Wrap a middleware instance in a DataModel compliant API */
+declare function toModel(middleware: DataModelMiddleware, defaultOptions?: DataModelOptions, next?: DataModelImpl): DataModelImpl;
+declare type DataPipeline = Array<DataModelMiddleware | DataModelImpl>;
+/**
+ * Given a set of steps in a pipeline, create the effective data-model
+ */
+declare function constructModelForPipeline(pipeline: DataPipeline): DataModelImpl;
+/** A DataModel that manages middleware data handlers  */
+declare class PipelinedDataModel implements DataModelImpl {
+    private pipeline;
+    private effectiveDataModel;
+    readonly hooks: {
+        onSet: SyncHook<[BatchSetTransaction], Record<string, any>>;
+    };
+    constructor(pipeline?: DataPipeline);
+    setMiddleware(handlers: DataPipeline): void;
+    addMiddleware(handler: DataModelMiddleware): void;
+    reset(model?: {}): void;
+    set(transaction: BatchSetTransaction, options?: DataModelOptions): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions): any;
+}
+
+declare type DependencySets = 'core' | 'children';
+/** A class to track usage of read/writes to/from a data model */
+declare class DependencyTracker {
+    protected readDeps: Set<BindingInstance>;
+    protected writeDeps: Set<BindingInstance>;
+    protected namedSet: DependencySets;
+    private namedDependencySets;
+    constructor();
+    protected createSubset(name: DependencySets, force?: boolean): void;
+    /** Grab all of the bindings that this depended on */
+    getDependencies(name?: DependencySets): Set<BindingInstance>;
+    trackSubset(name: DependencySets): void;
+    trackDefault(): void;
+    /** Grab all of the bindings this wrote to */
+    getModified(name?: DependencySets): Set<BindingInstance>;
+    /**
+     * Check to see if the dataModel has read the value at the given binding
+     *
+     * @param binding - The binding you want to check for
+     */
+    readsBinding(binding: BindingInstance): boolean;
+    /**
+     * Check to see if the dataModel has written to the binding
+     */
+    writesBinding(binding: BindingInstance): boolean;
+    /** Reset all tracking of dependencies */
     reset(): void;
-    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (newState: T) => void];
-    getLocalStateFunction<T>(key: symbol, countKey: symbol): (initialState: T) => readonly [T, (newState: T) => void];
+    protected addReadDep(binding: BindingInstance, namedSet?: DependencySets): void;
+    protected addWriteDep(binding: BindingInstance, namedSet?: DependencySets): void;
+    addChildReadDep(binding: BindingInstance): void;
+}
+/** Middleware that tracks dependencies of read/written data */
+declare class DependencyMiddleware extends DependencyTracker implements DataModelMiddleware {
+    constructor();
+    set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl | undefined): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl | undefined): any;
+}
+/** A data-model that tracks dependencies of read/written data */
+declare class DependencyModel<Options = DataModelOptions> extends DependencyTracker implements DataModelImpl<Options> {
+    private readonly rootModel;
+    constructor(rootModel: DataModelImpl<Options>);
+    set(transaction: BatchSetTransaction, options?: Options): Updates;
+    get(binding: BindingInstance, options?: Options): any;
 }
 
-/** Transform function that is ran on the Asset before it's resolved */
-declare type BeforeTransformFunction<AuthoredAsset extends Asset = Asset> = (asset: Node.Asset<AuthoredAsset> | Node.View<AuthoredAsset>, options: Resolve.NodeResolveOptions, store: Store) => Node.Node;
-/** Transform function that is ran on the Asset after it's resolved */
-declare type TransformFunction<AuthoredAsset extends Asset = Asset, TransformedAsset extends Asset = AuthoredAsset> = (asset: AuthoredAsset, options: Resolve.NodeResolveOptions, store: Store) => TransformedAsset;
-interface TransformFunctions {
-    /** A function that is executed as an AST -> AST transform before resolving the node to a value */
-    beforeResolve?: BeforeTransformFunction<any>;
-    /** A function to resolve an AST to a value */
-    resolve?: TransformFunction<any>;
+/**
+ * A model that does nothing
+ * Helpful for testing and other default DataModel applications
+ */
+declare class NOOPDataModel implements DataModelImpl {
+    get(): undefined;
+    set(): never[];
+}
+/** You only really need 1 instance of the NOOP model */
+declare const NOOP_MODEL: NOOPDataModel;
+
+/**
+ * A data model that stores data in an in-memory JS object
+ */
+declare class LocalModel implements DataModelImpl {
+    model: {
+        [key: string]: any;
+    };
+    constructor(model?: {});
+    reset(model?: {}): void;
+    get(binding?: BindingInstance): any;
+    set(transaction: BatchSetTransaction): Updates;
+}
+
+declare type LogFn = (...args: Array<any>) => void;
+declare const severities: readonly ["trace", "debug", "info", "warn", "error"];
+declare type Severity = typeof severities[number];
+declare type Logger = Record<Severity, LogFn>;
+declare type LoggerProvider = () => Logger | undefined;
+
+declare type ConsoleHandler = Pick<typeof console, 'log' | 'warn' | 'error'>;
+/** A Logger implementation that uses console */
+declare class ConsoleLogger implements Logger {
+    private severity;
+    private _console;
+    constructor(severity?: Severity, _console?: ConsoleHandler);
+    setSeverity(severity: Severity): void;
+    private getConsoleFn;
+    private createHandler;
+    readonly trace: (...args: any[]) => void;
+    readonly debug: (...args: any[]) => void;
+    readonly info: (...args: any[]) => void;
+    readonly warn: (...args: any[]) => void;
+    readonly error: (...args: any[]) => void;
+}
+
+/** A logger implementation that goes nowhere */
+declare class NoopLogger implements Logger {
+    readonly trace: () => void;
+    readonly debug: () => void;
+    readonly info: () => void;
+    readonly warn: () => void;
+    readonly error: () => void;
+}
+
+/** A logger that has a tapable subscriptions to callbacks */
+declare class TapableLogger implements Logger {
+    readonly hooks: {
+        trace: SyncHook<[any[]], Record<string, any>>;
+        debug: SyncHook<[any[]], Record<string, any>>;
+        info: SyncHook<[any[]], Record<string, any>>;
+        warn: SyncHook<[any[]], Record<string, any>>;
+        error: SyncHook<[any[]], Record<string, any>>;
+        log: SyncHook<["error" | "trace" | "debug" | "info" | "warn", any[]], Record<string, any>>;
+    };
+    private logHandlers;
+    private createHandler;
+    addHandler(logHandler: Logger): void;
+    removeHandler(logHandler: Logger): void;
+    readonly trace: (...args: any[]) => void;
+    readonly debug: (...args: any[]) => void;
+    readonly info: (...args: any[]) => void;
+    readonly warn: (...args: any[]) => void;
+    readonly error: (...args: any[]) => void;
+}
+
+/**
+ * The ProxyLogger allows a user to log to another Logger instance that may not exist yet
+ */
+declare class ProxyLogger implements Logger {
+    private proxiedLoggerProvider;
+    constructor(loggerProvider: LoggerProvider);
+    private createHandler;
+    readonly trace: (...args: any[]) => void;
+    readonly debug: (...args: any[]) => void;
+    readonly info: (...args: any[]) => void;
+    readonly warn: (...args: any[]) => void;
+    readonly error: (...args: any[]) => void;
+}
+
+declare type ExpressionLiteralType = string | number | boolean | undefined | null;
+declare type ExpressionType = object | ExpressionLiteralType | Array<ExpressionLiteralType> | ExpressionNode;
+interface OperatorProcessingOptions {
+    /**
+     * When set to a falsy value, the arguments passed to the handler will be raw AST Nodes
+     * This enables lazy evaluation of arguments
+     */
+    resolveParams: boolean;
+}
+declare type BinaryOperatorBasic = (left: any, right: any) => unknown;
+declare type BinaryOperatorAdvanced = OperatorProcessingOptions & ((ctx: ExpressionContext, left: any, right: any) => unknown);
+declare type BinaryOperator = BinaryOperatorAdvanced | BinaryOperatorBasic;
+declare type UnaryOperator = ((arg: any) => unknown) | (((ctx: ExpressionContext, arg: any) => unknown) & OperatorProcessingOptions);
+interface ExpressionContext {
+    /** A means of executing an expression */
+    evaluate: (expr: ExpressionType) => unknown;
+    /** The data model that expression handlers can use when fetching data */
+    model: DataModelWithParser;
+    /** A logger to use */
+    logger?: Logger;
+}
+declare type ExpressionHandler<T extends readonly unknown[] = unknown[], R = void> = ((context: ExpressionContext, ...args: T) => R) & Partial<OperatorProcessingOptions>;
+declare const ExpNodeOpaqueIdentifier: unique symbol;
+/** Checks if the input is an already processed Expression node */
+declare function isExpressionNode(x: any): x is ExpressionNode;
+interface BaseNode<T> {
+    /** The thing to discriminate the AST type on */
+    type: T;
+    /** How to tell this apart from other objects */
+    __id: typeof ExpNodeOpaqueIdentifier;
+}
+/** A helper interface for nodes that container left and right children */
+interface DirectionalNode {
+    /** The left node. Often for the left hand side of an expression */
+    left: ExpressionNode;
+    /** The right child. Often for the right hand side of an expression */
+    right: ExpressionNode;
+}
+interface LiteralNode extends BaseNode<'Literal'> {
+    /** A node that holds a literal value */
+    value: string | number;
+    /** The unprocessed value */
+    raw?: any;
+}
+interface BinaryNode extends BaseNode<'BinaryExpression'>, DirectionalNode {
+    /** The operation to perform on the nodes */
+    operator: string;
+}
+interface LogicalNode extends BaseNode<'LogicalExpression'> {
+    /** The left hand side of the equation */
+    left: any;
+    /** The right hand side of the equation */
+    right: any;
+    /** The logical operation to perform on the nodes */
+    operator: string;
+}
+interface UnaryNode extends BaseNode<'UnaryExpression'> {
+    /** The operation to perform on the node */
+    operator: string;
+    /** The single argument that the operation should be performed on */
+    argument: any;
+}
+declare type ThisNode = BaseNode<'ThisExpression'>;
+interface ModelRefNode extends BaseNode<'ModelRef'> {
+    /** The binding that the model reference points to */
+    ref: string;
+}
+interface ObjectNode extends BaseNode<'Object'> {
+    /**  */
+    attributes: Array<{
+        /** The property name of the object */
+        key: any;
+        /** the associated value */
+        value: any;
+    }>;
+}
+interface MemberExpressionNode extends BaseNode<'MemberExpression'> {
+    /** The object to be introspected */
+    object: ExpressionNode;
+    /** If the property uses . or open-bracket */
+    computed: boolean;
+    /** The property to access on the object */
+    property: ExpressionNode;
+}
+interface ConditionalExpressionNode extends BaseNode<'ConditionalExpression'> {
+    /** The test for the ternary */
+    test: ExpressionNode;
+    /** The truthy case for the ternary */
+    consequent: ExpressionNode;
+    /** The falsy case for the ternary */
+    alternate: ExpressionNode;
+}
+interface CompoundNode extends BaseNode<'Compound'> {
+    /** The contents of the compound expression */
+    body: ExpressionNode[];
+}
+interface CallExpressionNode extends BaseNode<'CallExpression'> {
+    /** The arguments to the function */
+    args: any[];
+    /** The function name */
+    callTarget: IdentifierNode;
+}
+interface ArrayExpressionNode extends BaseNode<'ArrayExpression'> {
+    /** The items in an array */
+    elements: any[];
+}
+interface IdentifierNode extends BaseNode<'Identifier'> {
+    /** The variable name */
+    name: string;
+}
+declare type AssignmentNode = BaseNode<'Assignment'> & DirectionalNode;
+interface ModificationNode extends BaseNode<'Modification'>, DirectionalNode {
+    /** The operator for the modification */
+    operator: string;
+}
+declare type ExpressionNode = LiteralNode | BinaryNode | LogicalNode | UnaryNode | ThisNode | ModelRefNode | MemberExpressionNode | ConditionalExpressionNode | CompoundNode | CallExpressionNode | ArrayExpressionNode | IdentifierNode | AssignmentNode | ModificationNode | ObjectNode;
+declare type ExpressionNodeType = ExpressionNode['type'];
+
+interface HookOptions extends ExpressionContext {
+    /** Given an expression node  */
+    resolveNode: (node: ExpressionNode) => any;
+}
+declare type ExpressionEvaluatorOptions = Omit<HookOptions, 'resolveNode' | 'evaluate'>;
+declare type ExpressionEvaluatorFunction = (exp: ExpressionType, options?: ExpressionEvaluatorOptions) => any;
+/**
+ * The expression evaluator is responsible for parsing and executing anything in the custom expression language
+ * */
+declare class ExpressionEvaluator {
+    private readonly vars;
+    readonly hooks: {
+        /** Resolve an AST node for an expression to a value */
+        resolve: SyncWaterfallHook<[any, ExpressionNode, HookOptions], Record<string, any>>;
+        /**
+         * An optional means of handling an error in the expression execution
+         * Return true if handled, to stop propagation of the error
+         */
+        onError: SyncBailHook<[Error], true, Record<string, any>>;
+    };
+    private readonly expressionsCache;
+    private readonly defaultHookOptions;
+    readonly operators: {
+        binary: Map<string, BinaryOperator>;
+        unary: Map<string, UnaryOperator>;
+        expressions: Map<string, ExpressionHandler<any, any>>;
+    };
+    reset(): void;
+    constructor(defaultOptions: ExpressionEvaluatorOptions);
+    evaluate(expression: ExpressionType, options?: ExpressionEvaluatorOptions): any;
+    addExpressionFunction<T extends readonly unknown[], R>(name: string, handler: ExpressionHandler<T, R>): void;
+    addBinaryOperator(operator: string, handler: BinaryOperator): void;
+    addUnaryOperator(operator: string, handler: UnaryOperator): void;
+    setExpressionVariable(name: string, value: unknown): void;
+    getExpressionVariable(name: string): unknown;
+    private _execAST;
+    private _execString;
+    private _resolveNode;
+}
+
+/** Generates a function by removing the first context argument */
+declare function withoutContext<T extends unknown[], Return>(fn: (...args: T) => Return): ExpressionHandler<T, Return>;
+
+declare type FormatOptions = Omit<Formatting.Reference, 'type'>;
+/**
+ * The return types for the schema don't include options.
+ * These are already sent to the generic formatter function for that type
+ */
+declare type FormatFunction<From, To = From, Options = unknown> = (val: From, options?: Options) => To | undefined;
+declare type FormatHandler<From, To = From> = (val: From) => To;
+interface FormatDefinition<DataModelType, UserDisplayType> {
+    /**
+     * A function to format data (from the data-model to the user).
+     * Defaults to the identify function
+     */
+    format: FormatHandler<DataModelType, UserDisplayType>;
+    /**
+     * A function to invert the formatting (from the user to the data-model)
+     * Defaults to the identify function.
+     */
+    deformat: FormatHandler<UserDisplayType, DataModelType>;
+}
+interface FormatType<DataModelType, UserDisplayType = DataModelType, Options = undefined> {
+    /**
+     * The name of the formatter.
+     * This corresponds to the 'type' format property when creating a DataType
+     */
+    name: string;
+    /**
+     * An optional function to format data for display to the user.
+     * This goes from dataModel -> UI display
+     */
+    format?: FormatFunction<DataModelType | UserDisplayType, UserDisplayType, Options>;
+    /**
+     * An optional function for undo the action of a format function for storage.
+     * This goes from UI -> dataModel
+     */
+    deformat?: FormatFunction<UserDisplayType | DataModelType, DataModelType, Options>;
+}
+
+interface NamedState {
+    /** The name of the navigation node */
+    name: string;
+    /** The nav node */
+    value: NavigationFlowState;
+}
+interface TransitionOptions {
+    /** Ignore any validations or other signals preventing the transition from taking place  */
+    force?: boolean;
+}
+declare type TransitionFunction = (name: string, options?: TransitionOptions) => void;
+/** The Content navigation state machine */
+declare class FlowInstance {
+    private flow;
+    private log?;
+    private history;
+    private flowPromise?;
+    readonly id: string;
+    currentState?: NamedState;
+    readonly hooks: {
+        beforeStart: SyncBailHook<[NavigationFlow], NavigationFlow, Record<string, any>>;
+        /** A callback when the onStart node was present */
+        onStart: SyncHook<[any], Record<string, any>>;
+        /** A callback when the onEnd node was present */
+        onEnd: SyncHook<[any], Record<string, any>>;
+        /** A hook to intercept and block a transition */
+        skipTransition: SyncBailHook<[NamedState | undefined], boolean | undefined, Record<string, any>>;
+        /** A chance to manipulate the flow-node used to calculate the given transition used  */
+        beforeTransition: SyncWaterfallHook<[_player_ui_types.NavigationFlowViewState | _player_ui_types.NavigationFlowFlowState | _player_ui_types.NavigationFlowActionState | _player_ui_types.NavigationFlowExternalState, string], Record<string, any>>;
+        /** A chance to manipulate the flow-node calculated after a transition */
+        resolveTransitionNode: SyncWaterfallHook<[NavigationFlowState], Record<string, any>>;
+        /** A callback when a transition from 1 state to another was made */
+        transition: SyncHook<[NamedState | undefined, NamedState], Record<string, any>>;
+    };
+    constructor(id: string, flow: NavigationFlow, options?: {
+        /** Logger instance to use */
+        logger?: Logger;
+    });
+    /** Start the state machine */
+    start(): Promise<NavigationFlowEndState>;
+    transition(transitionValue: string, options?: TransitionOptions): void;
+    private pushHistory;
+}
+
+/** A manager for the navigation section of a Content blob */
+declare class FlowController {
+    readonly hooks: {
+        flow: SyncHook<[FlowInstance], Record<string, any>>;
+    };
+    private readonly log?;
+    private navigation;
+    private navStack;
+    current?: FlowInstance;
+    constructor(navigation: Navigation, options?: {
+        /** A logger instance to use */
+        logger?: Logger;
+    });
+    /** Navigate to another state in the state-machine */
+    transition(stateTransition: string, options?: TransitionOptions): void;
+    private addNewFlow;
+    private run;
+    start(): Promise<NavigationFlowEndState>;
+}
+
+declare type AnyAssetType = Asset<string>;
+declare enum NodeType {
+    Asset = "asset",
+    View = "view",
+    Applicability = "applicability",
+    Template = "template",
+    Value = "value",
+    MultiNode = "multi-node",
+    Switch = "switch",
+    Unknown = "unknown",
+    Empty = "empty"
+}
+declare namespace Node {
+    type ChildrenTypes = NodeType.Asset | NodeType.Value | NodeType.View;
+    interface Base<T extends NodeType> {
+        /** Every node contains a type to distinguish it from other nodes */
+        type: T;
+        /** Every node (outside of the root) contains a reference to it's parent */
+        parent?: Node;
+    }
+    type PathSegment = string | number;
+    interface Child {
+        /** The path of the child relative to the parent */
+        path: PathSegment[];
+        /** If true, the path points to an array, and the value will be appended to it result */
+        array?: boolean;
+        /** The child node */
+        value: Node;
+    }
+    interface BaseWithChildren<T extends NodeType> extends Base<T> {
+        /** Any node that contains a list of children underneath it */
+        children?: Child[];
+    }
+    interface Asset<T extends AnyAssetType = AnyAssetType> extends BaseWithChildren<NodeType.Asset>, PluginOptions {
+        /** Any asset nested within a view */
+        value: T;
+    }
+    interface View<T extends AnyAssetType = AnyAssetType> extends BaseWithChildren<NodeType.View>, PluginOptions {
+        /** The root of the parsed view */
+        value: T;
+    }
+    interface Applicability extends Base<NodeType.Applicability> {
+        /** The expression to execute that determines applicability of the target node */
+        expression: Expression;
+        /** The node to use if the expression is truthy */
+        value: Node;
+    }
+    interface Template extends Base<NodeType.Template> {
+        /** The location of an array in the model */
+        data: Binding;
+        /** The template to use when mapping over the data */
+        template: unknown;
+        /** The number of nested templates so far */
+        depth: number;
+        /** should the template recomputed when data changes */
+        dynamic?: boolean;
+    }
+    interface Value extends BaseWithChildren<NodeType.Value>, PluginOptions {
+        /** A simple node representing a value */
+        value: any;
+    }
+    interface MultiNode extends Base<NodeType.MultiNode> {
+        /**
+         * Should this list override the target node if they overlap?
+         * If not amend the existing list
+         */
+        override?: boolean;
+        /** A list of values that comprise this node */
+        values: Array<Node>;
+    }
+    interface Switch extends Base<NodeType.Switch> {
+        /** Should this list be re-computed when data changes */
+        dynamic?: boolean;
+        /** A list of cases to evaluate in order */
+        cases: SwitchCase[];
+    }
+    interface SwitchCase {
+        /** The expression to evaluate for a single case statement */
+        case: Expression | true;
+        /** The value to use if this case is true */
+        value: Value;
+    }
+    interface PluginOptions {
+        /** A list of plugins */
+        plugins?: {
+            /** StringResolverPlugin options */
+            stringResolver?: {
+                /**
+                 * An optional array of node properties to skip during string resolution
+                 * Specified in the AssetTransformPlugin
+                 */
+                propertiesToSkip?: string[];
+            };
+        };
+    }
+    type Unknown = Base<NodeType.Unknown>;
+    type Empty = Base<NodeType.Empty>;
+    type ViewOrAsset = View | Asset;
+    type Node = Asset | Applicability | Template | Value | View | MultiNode | Switch | Unknown | Empty;
+}
+
+declare const EMPTY_NODE: Node.Empty;
+interface ParseObjectOptions {
+    /** how nested the templated is */
+    templateDepth?: number;
+}
+/**
+ * The Parser is the way to take an incoming view from the user and parse it into an AST.
+ * It provides a few ways to interact with the parsing, including mutating an object before and after creation of an AST node
+ */
+declare class Parser {
+    readonly hooks: {
+        /**
+         * A hook to interact with an object _before_ parsing it into an AST
+         *
+         * @param value - The object we're are about to parse
+         * @returns - A new value to parse.
+         *  If undefined, the original value is used.
+         *  If null, we stop parsing this node.
+         */
+        onParseObject: SyncWaterfallHook<[object, NodeType], Record<string, any>>;
+        /**
+         * A callback to interact with an AST _after_ we parse it into the AST
+         *
+         * @param value - The object we parsed
+         * @param node - The AST node we generated
+         * @returns - A new AST node to use
+         *   If undefined, the original value is used.
+         *   If null, we ignore this node all together
+         */
+        onCreateASTNode: SyncWaterfallHook<[Node.Node | null | undefined, object], Record<string, any>>;
+        determineNodeType: SyncBailHook<[string | object], NodeType, Record<string, any>>;
+        parseNode: SyncBailHook<[obj: object, nodeType: Node.ChildrenTypes, parseOptions: ParseObjectOptions, determinedNodeType: NodeType | null], Node.Node, Record<string, any>>;
+    };
+    parseView(value: AnyAssetType): Node.View;
+    createASTNode(node: Node.Node | null, value: any): Node.Node | null;
+    parseObject(obj: object, type?: Node.ChildrenTypes, options?: ParseObjectOptions): Node.Node | null;
+}
+
+declare namespace Resolve {
+    interface Validation {
+        /** Fetch the data-type for the given binding */
+        type(binding: BindingLike): Schema.DataType | undefined;
+        /** Get all currently applicable validation errors */
+        getAll(): Map<BindingInstance, ValidationResponse> | undefined;
+        /** Internal Method to lookup if there is a validation for the given binding */
+        _getValidationForBinding(binding: BindingLike): ValidationResponse | undefined;
+        /** Get field level error for the specific binding */
+        get(binding: BindingLike, options?: {
+            /** If this binding should also be tracked for validations */
+            track: boolean;
+        }): ValidationResponse | undefined;
+        /** Get errors for all children regardless of section */
+        getChildren(type: Validation.DisplayTarget): Array<ValidationResponse>;
+        /** Get errors for all children solely in this section */
+        getValidationsForSection(): Array<ValidationResponse>;
+        /** Track errors for this binding, and notify the node of changes */
+        track: (binding: BindingLike) => void;
+        /** Register node as a section */
+        register: (options?: {
+            /** While type of Display Target group it should register as */
+            type: Exclude<Validation.DisplayTarget, 'field'>;
+        }) => void;
+    }
+    interface BaseOptions {
+        /** A logger to use */
+        logger?: Logger;
+        /** An optional set of validation features */
+        validation?: Validation;
+        /** Parse a raw valy into an AST node */
+        parseNode?: (node: any) => Node.Node | null;
+        /** A function to move the state to a new place */
+        transition?: TransitionFunction;
+        /** The hub for data invariants and metaData associated with the data model */
+        schema: SchemaController;
+    }
+    interface NodeDataOptions {
+        /** The data to set or get data from */
+        model: DataModelWithParser<DataModelOptions>;
+        /**
+         * A function to format a given a value (given a binding) for display to the user
+         * Note: this doesn't persist any changes in the model.
+         */
+        format: (binding: BindingLike, value: any) => any;
+        /**
+         * A function to format a given value using a formatting reference.
+         * The default behavior is the identity function.
+         */
+        formatValue: (formatReference: Formatting.Reference, value: any) => any;
+    }
+    type NodeResolveOptions = BaseOptions & {
+        /** Execute the expression and return it's result */
+        evaluate: (exp: ExpressionType) => any;
+        /** All parameters for how to process data */
+        data: NodeDataOptions;
+        /** The data dependencies that were requested during the resolution */
+        getDependencies?(scope?: 'core' | 'children'): Set<BindingInstance>;
+        /** original node */
+        node?: Node.Node;
+    };
+    type ResolverOptions = BaseOptions & {
+        /** The data model to set or get data from */
+        model: DataModelImpl<DataModelOptions>;
+        /** A formatter function to call */
+        format?: (binding: BindingInstance, value: any) => any;
+        /**
+         * A function to format a given value using a formatting reference.
+         * The default behavior is the identity function.
+         */
+        formatValue?: (formatReference: Formatting.Reference, value: any) => any;
+        /** An evaluator to execute an expression */
+        evaluator: ExpressionEvaluator;
+        /** A fn to parse a raw binding into a binding object */
+        parseBinding: BindingFactory;
+    };
+    interface ResolvedNode {
+        /** The original node */
+        node: Node.Node;
+        /** The data dependencies that were requested during the resolution */
+        dependencies: Set<BindingInstance>;
+        /** The final value */
+        value: any;
+    }
+    type NodeTransformFunction = (node: Node.Node, options: NodeResolveOptions) => Node.Node | null;
+    type NodeResolveFunction = (value: any, node: Node.Node, options: NodeResolveOptions) => any;
+    interface Plugin {
+        /** A transform function to migrate an AST to another AST */
+        beforeResolve?: NodeTransformFunction;
+        /** A function to transform an AST to a resolved value */
+        resolve?: NodeResolveFunction;
+        /** A function to process a resolved value before completing the node */
+        afterResolve?: NodeResolveFunction;
+    }
+}
+
+/** Check to see if and of the data-changes affect the given dependencies  */
+declare function caresAboutDataChanges(dataChanges?: Set<BindingInstance>, dependencies?: Set<BindingInstance>): boolean;
+/** Convert the options object for a resolver to one for a node */
+declare function toNodeResolveOptions(resolverOptions: Resolve.ResolverOptions): Resolve.NodeResolveOptions;
+
+interface NodeUpdate extends Resolve.ResolvedNode {
+    /** A flag to track if a node has changed since the last resolution */
+    updated: boolean;
+}
+/**
+ * The Resolver is the way to take a parsed AST graph of a view and resolve it to a concrete representation of the current user state
+ * It combines the ability to mutate ast nodes before resolving, as well as the mutating the resolved objects while parsing
+ */
+declare class Resolver {
+    readonly hooks: {
+        /** A hook to allow skipping of the resolution tree for a specific node */
+        skipResolve: SyncWaterfallHook<[boolean, Node.Node, Resolve.NodeResolveOptions], Record<string, any>>;
+        /** An event emitted before calculating the next update */
+        beforeUpdate: SyncHook<[Set<BindingInstance> | undefined], Record<string, any>>;
+        /** An event emitted after calculating the next update */
+        afterUpdate: SyncHook<[any], Record<string, any>>;
+        /** The options passed to a node to resolve it to an object */
+        resolveOptions: SyncWaterfallHook<[Resolve.NodeResolveOptions, Node.Node], Record<string, any>>;
+        /** A hook to transform the AST node into a new AST node before resolving it */
+        beforeResolve: SyncWaterfallHook<[Node.Node | null, Resolve.NodeResolveOptions], Record<string, any>>;
+        /**
+         * A hook to transform an AST node into it's resolved value.
+         * This runs _before_ any children are resolved
+         */
+        resolve: SyncWaterfallHook<[any, Node.Node, Resolve.NodeResolveOptions], Record<string, any>>;
+        /**
+         * A hook to transform the resolved value of an AST node.
+         * This runs _after_ all children nodes are resolved
+         */
+        afterResolve: SyncWaterfallHook<[any, Node.Node, Resolve.NodeResolveOptions], Record<string, any>>;
+        /** Called at the very end of a node's tree being updated */
+        afterNodeUpdate: SyncHook<[Node.Node, Node.Node | undefined, NodeUpdate], Record<string, any>>;
+    };
+    /**
+     * The AST tree after beforeResolve is ran mapped to the AST before beforeResolve is ran
+     */
+    private readonly ASTMap;
+    /**
+     * The root node in the AST tree we want to resolve
+     */
+    readonly root: Node.Node;
+    /**
+     * The cache of the last resolved values when walking the tree.
+     * This gets recycled every update to avoid stale data if a node is unused in an update
+     */
+    private resolveCache;
+    /**
+     * Cache of node IDs that have been processed to track if nodes have duplicate IDs
+     */
+    private idCache;
+    /**
+     * The parameters required to resolve AST nodes
+     */
+    private readonly options;
+    /**
+     * Tapable logger for logging errors encountered during view resolution
+     */
+    private logger?;
+    constructor(root: Node.Node, options: Resolve.ResolverOptions);
+    getSourceNode(convertedAST: Node.Node): Node.Node | undefined;
+    update(changes?: Set<BindingInstance>): any;
+    private getNodeID;
+    private getPreviousResult;
+    private computeTree;
+}
+
+/** The basic view api */
+interface View {
+    /** The hooks for a view */
+    hooks: {
+        /** A hook when a parser is created for this view */
+        parser: SyncHook<[Parser]>;
+        /** A hook when a resolver is created for this view */
+        resolver: SyncHook<[Resolver]>;
+    };
+}
+/** A plugin for a view */
+interface ViewPlugin {
+    /** Called with a view instance */
+    apply(view: View): void;
+}
+
+/** Config options that are required to resolve/update a view */
+declare type Options$2 = Resolve.NodeResolveOptions;
+
+interface TemplateItemInfo {
+    /** The index of the data for the current iteration of the template */
+    index: number;
+    /** The data for the current iteration of the template */
+    data: any;
+    /** The depth of the template node */
+    depth: number;
+}
+interface TemplateSubstitution {
+    /** Regular expression to find and replace. The global flag will be always be added to this expression. */
+    expression: string | RegExp;
+    /** The value to replace matches with. */
+    value: string;
+}
+/** A view plugin to resolve/manage templates */
+declare class TemplatePlugin implements ViewPlugin {
+    private readonly options;
+    hooks: {
+        resolveTemplateSubstitutions: SyncWaterfallHook<[TemplateSubstitution[], TemplateItemInfo], Record<string, any>>;
+    };
+    constructor(options: Options$2);
+    private parseTemplate;
+    applyParser(parser: Parser): void;
+    applyResolverHooks(resolver: Resolver): void;
+    apply(view: View): void;
+}
+
+/** A plugin that resolves all string references for each node */
+declare class StringResolverPlugin implements ViewPlugin {
+    applyResolver(resolver: Resolver): void;
+    apply(view: View): void;
+}
+
+/** A view plugin to remove inapplicable assets from the tree */
+declare class ApplicabilityPlugin implements ViewPlugin {
+    applyResolver(resolver: Resolver): void;
+    applyParser(parser: Parser): void;
+    apply(view: View): void;
+}
+
+/** A view plugin to resolve switches */
+declare class SwitchPlugin implements ViewPlugin {
+    private readonly options;
+    constructor(options: Options$2);
+    private resolveSwitch;
+    applyParser(parser: Parser): void;
+    applyResolver(resolver: Resolver): void;
+    apply(view: View): void;
+}
+
+/** A stateful view instance from an content */
+declare class ViewInstance implements ValidationProvider {
+    hooks: {
+        onUpdate: SyncHook<[_player_ui_types.Asset<string> & {
+            validation?: _player_ui_types.Validation.CrossfieldReference[] | undefined;
+        }], Record<string, any>>;
+        parser: SyncHook<[Parser], Record<string, any>>;
+        resolver: SyncHook<[Resolver], Record<string, any>>;
+        templatePlugin: SyncHook<[TemplatePlugin], Record<string, any>>;
+    };
+    private resolver?;
+    readonly initialView: View$1;
+    readonly resolverOptions: Resolve.ResolverOptions;
+    private rootNode?;
+    private validationProvider?;
+    private templatePlugin;
+    lastUpdate: Record<string, any> | undefined;
+    constructor(initialView: View$1, resolverOptions: Resolve.ResolverOptions);
+    update(changes?: Set<BindingInstance>): any;
+    getValidationsForBinding(binding: BindingInstance): ValidationObject[] | undefined;
+}
+
+/**
+ * Functions for building AST nodes (relatively) easily
+ */
+declare class Builder {
+    /**
+     * Creates an asset node
+     *
+     * @param value - the value to put in the asset node
+     */
+    static asset<T extends AnyAssetType>(value: T): Node.Asset<T>;
+    /**
+     * Creates a value node
+     *
+     * @param v - The object to put in the value node
+     */
+    static value(v?: object): Node.Value;
+    /**
+     * Creates a multiNode and associates the multiNode as the parent
+     * of all the value nodes
+     *
+     * @param values - the value or applicability nodes to put in the multinode
+     */
+    static multiNode(...values: (Node.Value | Node.Applicability)[]): Node.MultiNode;
+    /**
+     * Adds a child node to a node
+     *
+     * @param node - The node to add a child to
+     * @param path - The path at which to add the child
+     * @param child - The child node
+     */
+    static addChild<N extends Node.BaseWithChildren<NT>, NT extends NodeType>(node: N, path: Node.PathSegment | Node.PathSegment[], child: Node.Node): N;
 }
-declare type TransformRegistry = Registry<TransformFunctions>;
 
 interface BindingTracker {
     /** Get the bindings currently being tracked for validation */
     getBindings(): Set<BindingInstance>;
 }
-interface Options {
+interface Options$1 {
     /** Parse a binding from a view */
     parseBinding: BindingFactory;
     /** Callbacks when events happen */
@@ -71,7 +1054,7 @@ interface Options {
 declare class ValidationBindingTrackerViewPlugin implements ViewPlugin, BindingTracker {
     private options;
     private trackedBindings;
-    constructor(options: Options);
+    constructor(options: Options$1);
     /** Fetch the tracked bindings in the current view */
     getBindings(): Set<BindingInstance>;
     /** Attach hooks to the given resolver */
@@ -176,7 +1159,7 @@ declare class ValidationController implements BindingTracker {
     private updateValidationsForView;
     private setCompare;
     private get activeBindings();
-    getValidator(type: string): _player_ui_validator.ValidatorFunction<unknown> | undefined;
+    getValidator(type: string): ValidatorFunction<unknown> | undefined;
     getBindings(): Set<BindingInstance>;
     /** Executes all known validations for the tracked bindings using the given model */
     validateView(trigger?: Validation.Trigger): {
@@ -189,6 +1172,37 @@ declare class ValidationController implements BindingTracker {
     forView(parser: BindingFactory): Resolve.Validation;
 }
 
+interface Store {
+    useLocalState<T>(initialState: T): readonly [T, (value: T) => void];
+    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (value: T) => void];
+}
+interface SharedStore {
+    getLocalStateFunction<T>(key: string | symbol, countKey: symbol): (initialState: T) => readonly [T, (value: T) => void];
+    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (value: T) => void];
+}
+/** A store that holds on to state for a transform */
+declare class LocalStateStore implements SharedStore {
+    private state;
+    private updateCallback?;
+    constructor(onUpdate?: () => void);
+    removeKey(key: symbol | string): void;
+    reset(): void;
+    useSharedState<T>(key: string | symbol): (initialState: T) => readonly [T, (newState: T) => void];
+    getLocalStateFunction<T>(key: symbol, countKey: symbol): (initialState: T) => readonly [T, (newState: T) => void];
+}
+
+/** Transform function that is ran on the Asset before it's resolved */
+declare type BeforeTransformFunction<AuthoredAsset extends Asset = Asset> = (asset: Node.Asset<AuthoredAsset> | Node.View<AuthoredAsset>, options: Resolve.NodeResolveOptions, store: Store) => Node.Node;
+/** Transform function that is ran on the Asset after it's resolved */
+declare type TransformFunction<AuthoredAsset extends Asset = Asset, TransformedAsset extends Asset = AuthoredAsset> = (asset: AuthoredAsset, options: Resolve.NodeResolveOptions, store: Store) => TransformedAsset;
+interface TransformFunctions {
+    /** A function that is executed as an AST -> AST transform before resolving the node to a value */
+    beforeResolve?: BeforeTransformFunction<any>;
+    /** A function to resolve an AST to a value */
+    resolve?: TransformFunction<any>;
+}
+declare type TransformRegistry = Registry<TransformFunctions>;
+
 /** The status for a flow's execution state */
 declare type PlayerFlowStatus = 'not-started' | 'in-progress' | 'completed' | 'error';
 /** Common interface for the state of Player's flow execution */
@@ -314,7 +1328,7 @@ declare class ViewController {
     currentView?: ViewInstance;
     transformRegistry: TransformRegistry;
     optimizeUpdates: boolean;
-    constructor(initialViews: View[], options: Resolve.ResolverOptions & ViewControllerOptions);
+    constructor(initialViews: View$1[], options: Resolve.ResolverOptions & ViewControllerOptions);
     private queueUpdate;
     private getViewForRef;
     onView(state: NavigationFlowViewState): void;
@@ -335,6 +1349,169 @@ declare class AssetTransformCorePlugin {
     apply(viewController: ViewController): void;
 }
 
+interface ConstantsProvider {
+    /**
+     * Function to add constants to the providers store
+     * - @param data values to add to the constants store
+     */
+    addConstants(data: Record<string, any>, namespace: string): void;
+    /**
+     * Function to retreive constants from the providers store
+     *  - @param key Key used for the store access
+     *  - @param namespace namespace values were loaded under (defined in the plugin)
+     *  - @param fallback Optional - if key doesn't exist in namespace what to return (will return unknown if not provided)
+     */
+    getConstants(key: any, namespace: string, fallback?: any): any;
+    /**
+     * Function to set values to temporarily override certain keys in the perminant store
+     * - @param data values to override store with
+     * - @param namespace namespace to override
+     */
+    setTemporaryValues(data: any, namespace: string): void;
+    /**
+     * Clears any temporary values that were previously set
+     */
+    clearTemporaryValues(): void;
+}
+/**
+ * Key/Value store for constants and context for Player
+ */
+declare class ConstantsController implements ConstantsProvider {
+    /**
+     * Data store is basically a map of namespaces to DataModels to provide some data isolation
+     */
+    private store;
+    /**
+     * Separate store for temporary flow specific overrides.
+     * They are kept in a separate data model to make clearing it easier between flows
+     * and so there is no confusion on what is static and what is temporary
+     */
+    private tempStore;
+    constructor();
+    addConstants(data: any, namespace: string): void;
+    getConstants(key: string, namespace: string, fallback?: any): any;
+    setTemporaryValues(data: any, namespace: string): void;
+    clearTemporaryValues(): void;
+}
+
+interface BaseValidationResponse<T = Validation.Severity> {
+    /** The validation message to show to the user */
+    message: string;
+    /** List of parameters associated with a validation. These can be replaced into a templatized message string. */
+    parameters?: Record<string, any>;
+    /** How serious is this violation */
+    severity: T;
+    /** Where this validation should be displayed */
+    displayTarget?: Validation.DisplayTarget;
+    /** The blocking state of this validation */
+    blocking?: boolean | 'once';
+}
+interface WarningValidationResponse extends BaseValidationResponse<'warning'> {
+    /** Warning validations can be dismissed without correcting the error */
+    dismiss?: () => void;
+}
+declare type ErrorValidationResponse = BaseValidationResponse<'error'>;
+declare type ValidationResponse = ErrorValidationResponse | WarningValidationResponse;
+declare type RequiredValidationKeys = 'severity' | 'trigger';
+declare type ValidationObject = Validation.Reference & Required<Pick<Validation.Reference, RequiredValidationKeys>>;
+interface ValidationProvider {
+    getValidationsForBinding?(binding: BindingInstance): Array<ValidationObject> | undefined;
+    getValidationsForView?(): Array<ValidationObject> | undefined;
+}
+interface ValidatorContext {
+    /** The data to set or get data from */
+    model: DataModelWithParser;
+    /** A means of parsing a binding */
+    parseBinding: BindingFactory;
+    /** Execute the expression and return it's result */
+    evaluate: ExpressionEvaluatorFunction;
+    /** Logger instance to use */
+    logger: Logger;
+    /** The validation object that triggered this function */
+    validation: ValidationObject;
+    /** The constants for messages */
+    constants: ConstantsProvider;
+}
+declare type ValidatorFunction<Options = unknown> = (context: ValidatorContext, value: any, options?: Options) => Omit<BaseValidationResponse, 'severity'> | undefined;
+
+/**
+ * Returns a validation object if the data is invalid or an set of BindingsInstances if the binding itself is a weak ref of another invalid validation
+ */
+declare type MiddlewareChecker = (binding: BindingInstance, model: DataModelImpl) => ValidationResponse | Set<BindingInstance> | undefined;
+/**
+ * Middleware for the data-model that caches the results of invalid data
+ */
+declare class ValidationMiddleware implements DataModelMiddleware {
+    validator: MiddlewareChecker;
+    shadowModelPaths: Map<BindingInstance, any>;
+    private logger?;
+    constructor(validator: MiddlewareChecker, options?: {
+        /** A logger instance */
+        logger?: Logger;
+    });
+    set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl): Updates;
+    get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): any;
+}
+
+/** A registry that tracks validators  */
+declare class ValidatorRegistry {
+    private registry;
+    constructor();
+    /** Use the given validator name to fetch the handler */
+    get(name: string): ValidatorFunction | undefined;
+    /** Register a new validator */
+    register<T>(name: string, handler: ValidatorFunction<T>): void;
+}
+
+/** Expand the authored schema into a set of paths -> DataTypes */
+declare function parse(schema: Schema.Schema): Map<string, Schema.DataType>;
+/**
+ * The Schema is the central hub for all data invariants, and metaData associated with the data-model itself
+ * Outside of the types defined in the JSON payload, it doesn't manage or keep any state.
+ * It simply servers as an orchestrator for other modules to interface w/ the schema.
+ */
+declare class SchemaController implements ValidationProvider {
+    private formatters;
+    private types;
+    readonly schema: Map<string, Schema.DataType>;
+    private bindingSchemaNormalizedCache;
+    readonly hooks: {
+        resolveTypeForBinding: SyncWaterfallHook<[Schema.DataType<unknown> | undefined, BindingInstance], Record<string, any>>;
+    };
+    constructor(schema?: Schema.Schema);
+    addFormatters(fns: Array<FormatType<any, any, FormatOptions>>): void;
+    addDataTypes(types: Array<Schema.DataType<any>>): void;
+    getValidationsForBinding(binding: BindingInstance): Array<ValidationObject> | undefined;
+    private normalizeBinding;
+    getType(binding: BindingInstance): Schema.DataType | undefined;
+    getApparentType(binding: BindingInstance): Schema.DataType | undefined;
+    getTypeDefinition(dataType: string): Schema.DataType<any> | undefined;
+    getFormatterForType(formatReference: Formatting.Reference): FormatDefinition<unknown, unknown> | undefined;
+    /**
+     * Given a binding, fetch a function that's responsible for formatting, and/or de-formatting the data
+     * If no formatter is registered, it will return undefined
+     */
+    getFormatter(binding: BindingInstance): FormatDefinition<unknown, unknown> | undefined;
+}
+
+interface Options {
+    /** The model to use when resolving refs */
+    model: DataModelWithParser;
+    /** A function to evaluate an expression */
+    evaluate: (exp: Expression) => any;
+}
+/** Search the given string for the coordinates of the next expression to resolve */
+declare function findNextExp(str: string): {
+    start: number;
+    end: number;
+} | undefined;
+/** Finds any subset of the string wrapped in @[]@ and evaluates it as an expression */
+declare function resolveExpressionsInString(val: string, { evaluate }: Options): string;
+/** Return a string with all data model references resolved */
+declare function resolveDataRefsInString(val: string, options: Options): string;
+/** Recursively resolve all model refs in whatever you pass in */
+declare function resolveDataRefs<T>(val: T, options: Options): T;
+
 interface PlayerPlugin {
     /**
      * Unique identifier of the plugin.
@@ -434,4 +1611,4 @@ declare class FlowExpPlugin implements PlayerPlugin {
     apply(player: Player): void;
 }
 
-export { AssetTransformCorePlugin, BaseFlowState, BeforeTransformFunction, BindingTracker, CompletedState, ControllerState, DataController, ErrorState, FlowExpPlugin, InProgressState, LocalStateStore, NOT_STARTED_STATE, NotStartedState, Player, PlayerConfigOptions, PlayerFlowExecutionData, PlayerFlowState, PlayerFlowStatus, PlayerInfo, PlayerPlugin, RawSetTransaction, RawSetType, StatefulValidationObject, Store, TransformFunction, TransformFunctions, TransformRegistry, ValidationBindingTrackerViewPlugin, ValidationController, ViewController, ViewControllerOptions };
+export { AnyAssetType, ApplicabilityPlugin, ArrayExpressionNode, AssetTransformCorePlugin, AssignmentNode, BaseFlowState, BaseNode, BatchSetTransaction, BeforeTransformFunction, BinaryNode, BinaryOperator, BinaryOperatorAdvanced, BinaryOperatorBasic, BindingFactory, BindingInstance, BindingLike, BindingParser, BindingParserOptions, BindingTracker, Builder, CallExpressionNode, CompletedState, CompoundNode, ConditionalExpressionNode, ConsoleLogger, ConstantsController, ConstantsProvider, ControllerState, DataController, DataModelImpl, DataModelMiddleware, DataModelOptions, DataModelWithParser, DataPipeline, DependencyMiddleware, DependencyModel, DependencySets, DependencyTracker, DirectionalNode, EMPTY_NODE, ErrorState, ErrorValidationResponse, ExpNodeOpaqueIdentifier, ExpressionContext, ExpressionEvaluator, ExpressionEvaluatorFunction, ExpressionEvaluatorOptions, ExpressionHandler, ExpressionLiteralType, ExpressionNode, ExpressionNodeType, ExpressionType, FlowController, FlowExpPlugin, FlowInstance, FormatDefinition, FormatFunction, FormatHandler, FormatOptions, FormatType, Getter, HookOptions, IdentifierNode, InProgressState, LiteralNode, LocalModel, LocalStateStore, LogFn, Logger, LoggerProvider, LogicalNode, MemberExpressionNode, MiddlewareChecker, ModelRefNode, ModificationNode, NOOPDataModel, NOOP_MODEL, NOT_STARTED_STATE, NamedState, Node, NodeType, NoopLogger, NotStartedState, ObjectNode, OperatorProcessingOptions, Options, ParseObjectOptions, Parser, PipelinedDataModel, Player, PlayerConfigOptions, PlayerFlowExecutionData, PlayerFlowState, PlayerFlowStatus, PlayerInfo, PlayerPlugin, ProxyLogger, ROOT_BINDING, RawBinding, RawBindingSegment, RawSetTransaction, RawSetType, Resolve, Resolver, SIMPLE_BINDING_REGEX, SchemaController, Severity, StatefulValidationObject, Store, StringResolverPlugin, SwitchPlugin, TapableLogger, TemplatePlugin, ThisNode, TransformFunction, TransformFunctions, TransformRegistry, TransitionFunction, TransitionOptions, UnaryNode, UnaryOperator, Updates, ValidationBindingTrackerViewPlugin, ValidationController, ValidationMiddleware, ValidationObject, ValidationProvider, ValidationResponse, ValidatorContext, ValidatorFunction, ValidatorRegistry, ViewController, ViewControllerOptions, ViewInstance, ViewPlugin, WarningValidationResponse, caresAboutDataChanges, constructModelForPipeline, findInArray, findNextExp, getBindingSegments, isBinding, isExpressionNode, maybeConvertToNum, parse, resolveDataRefs, resolveDataRefsInString, resolveExpressionsInString, severities, toModel, toNodeResolveOptions, withParser, withoutContext };