@player-ui/player 0.3.1-next.1 → 0.3.1

package/dist/index.d.ts

@@ -58,6 +58,13 @@ interface BindingParserOptions {
      * Get the result of evaluating an expression
      */
     evaluate: (exp: string) => any;
+    /**
+     * Without readOnly, if a binding such as this is used: arr[key='does not exist'],
+     * then an object with that key will be created.
+     * This is done to make assignment such as arr[key='abc'].val = 'foo' work smoothly.
+     * Setting readOnly to true will prevent this behavior, avoiding unintended data changes.
+     */
+    readOnly?: boolean;
 }
 declare type Getter = (path: BindingInstance) => any;
 declare type RawBindingSegment = number | string;
@@ -116,6 +123,8 @@ declare function getBindingSegments(binding: BindingLike): Array<string | number
 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;
+declare const BINDING_BRACKETS_REGEX: RegExp;
+declare type BeforeResolveNodeContext = Required<NormalizedResult> & ResolveBindingASTOptions;
 /** A parser for creating bindings from a string */
 declare class BindingParser {
     private cache;
@@ -123,7 +132,7 @@ declare class BindingParser {
     private parserOptions;
     hooks: {
         skipOptimization: SyncBailHook<[string], boolean, Record<string, any>>;
-        beforeResolveNode: SyncWaterfallHook<[AnyNode, Required<NormalizedResult> & ResolveBindingASTOptions], Record<string, any>>;
+        beforeResolveNode: SyncWaterfallHook<[AnyNode, BeforeResolveNodeContext], Record<string, any>>;
     };
     constructor(options?: Partial<BindingParserOptions>);
     /**
@@ -165,6 +174,10 @@ interface DataModelOptions {
      * A flag to set to ignore any default value in the schema, and just use the raw value
      */
     ignoreDefaultValue?: boolean;
+    /**
+     * A flag to indicate that this update should happen silently
+     */
+    silent?: boolean;
     /** Other context associated with this request */
     context?: {
         /** The data model to use when getting other data from the context of this request */
@@ -174,16 +187,19 @@ interface DataModelOptions {
 interface DataModelWithParser<Options = DataModelOptions> {
     get(binding: BindingLike, options?: Options): any;
     set(transaction: [BindingLike, any][], options?: Options): Updates;
+    delete(binding: BindingLike, options?: Options): void;
 }
 interface DataModelImpl<Options = DataModelOptions> {
     get(binding: BindingInstance, options?: Options): any;
     set(transaction: BatchSetTransaction, options?: Options): Updates;
+    delete(binding: BindingInstance, options?: Options): void;
 }
 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;
+    delete?(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): void;
     reset?(): void;
 }
 /** Wrap the inputs of the DataModel with calls to parse raw binding inputs */
@@ -208,6 +224,7 @@ declare class PipelinedDataModel implements DataModelImpl {
     reset(model?: {}): void;
     set(transaction: BatchSetTransaction, options?: DataModelOptions): Updates;
     get(binding: BindingInstance, options?: DataModelOptions): any;
+    delete(binding: BindingInstance, options?: DataModelOptions): void;
 }
 
 declare type DependencySets = 'core' | 'children';
@@ -246,6 +263,7 @@ declare class DependencyMiddleware extends DependencyTracker implements DataMode
     constructor();
     set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl | undefined): Updates;
     get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl | undefined): any;
+    delete(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl | undefined): void | undefined;
 }
 /** A data-model that tracks dependencies of read/written data */
 declare class DependencyModel<Options = DataModelOptions> extends DependencyTracker implements DataModelImpl<Options> {
@@ -253,6 +271,7 @@ declare class DependencyModel<Options = DataModelOptions> extends DependencyTrac
     constructor(rootModel: DataModelImpl<Options>);
     set(transaction: BatchSetTransaction, options?: Options): Updates;
     get(binding: BindingInstance, options?: Options): any;
+    delete(binding: BindingInstance, options?: Options): void;
 }
 
 /**
@@ -262,6 +281,7 @@ declare class DependencyModel<Options = DataModelOptions> extends DependencyTrac
 declare class NOOPDataModel implements DataModelImpl {
     get(): undefined;
     set(): never[];
+    delete(): void;
 }
 /** You only really need 1 instance of the NOOP model */
 declare const NOOP_MODEL: NOOPDataModel;
@@ -277,6 +297,7 @@ declare class LocalModel implements DataModelImpl {
     reset(model?: {}): void;
     get(binding?: BindingInstance): any;
     set(transaction: BatchSetTransaction): Updates;
+    delete(binding: BindingInstance): void;
 }
 
 declare type LogFn = (...args: Array<any>) => void;
@@ -345,8 +366,13 @@ declare class ProxyLogger implements Logger {
     readonly error: (...args: any[]) => void;
 }
 
+declare type ExpressionObjectType = {
+    /** The expression to eval */
+    value: BasicExpressionTypes;
+};
 declare type ExpressionLiteralType = string | number | boolean | undefined | null;
-declare type ExpressionType = object | ExpressionLiteralType | Array<ExpressionLiteralType> | ExpressionNode;
+declare type BasicExpressionTypes = ExpressionLiteralType | ExpressionObjectType | Array<ExpressionLiteralType | ExpressionObjectType>;
+declare type ExpressionType = BasicExpressionTypes | ExpressionNode;
 interface OperatorProcessingOptions {
     /**
      * When set to a falsy value, the arguments passed to the handler will be raw AST Nodes
@@ -370,11 +396,28 @@ declare type ExpressionHandler<T extends readonly unknown[] = unknown[], R = voi
 declare const ExpNodeOpaqueIdentifier: unique symbol;
 /** Checks if the input is an already processed Expression node */
 declare function isExpressionNode(x: any): x is ExpressionNode;
+interface NodePosition {
+    /** The character location */
+    character: number;
+}
+interface NodeLocation {
+    /** The start of the node */
+    start: NodePosition;
+    /** The end of the node */
+    end: NodePosition;
+}
 interface BaseNode<T> {
     /** The thing to discriminate the AST type on */
     type: T;
     /** How to tell this apart from other objects */
     __id: typeof ExpNodeOpaqueIdentifier;
+    /** The location of the node in the source expression string */
+    location?: NodeLocation;
+    /**
+     * The error that occurred while parsing this node
+     * This is only set if the parsing mode is set to non-strict
+     */
+    error?: Error;
 }
 /** A helper interface for nodes that container left and right children */
 interface DirectionalNode {
@@ -393,11 +436,7 @@ 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;
+interface LogicalNode extends BaseNode<'LogicalExpression'>, DirectionalNode {
     /** The logical operation to perform on the nodes */
     operator: string;
 }
@@ -405,7 +444,7 @@ 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;
+    argument: ExpressionNode;
 }
 declare type ThisNode = BaseNode<'ThisExpression'>;
 interface ModelRefNode extends BaseNode<'ModelRef'> {
@@ -416,9 +455,9 @@ interface ObjectNode extends BaseNode<'Object'> {
     /**  */
     attributes: Array<{
         /** The property name of the object */
-        key: any;
+        key: ExpressionNode;
         /** the associated value */
-        value: any;
+        value: ExpressionNode;
     }>;
 }
 interface MemberExpressionNode extends BaseNode<'MemberExpression'> {
@@ -443,13 +482,13 @@ interface CompoundNode extends BaseNode<'Compound'> {
 }
 interface CallExpressionNode extends BaseNode<'CallExpression'> {
     /** The arguments to the function */
-    args: any[];
+    args: ExpressionNode[];
     /** The function name */
     callTarget: IdentifierNode;
 }
 interface ArrayExpressionNode extends BaseNode<'ArrayExpression'> {
     /** The items in an array */
-    elements: any[];
+    elements: ExpressionNode[];
 }
 interface IdentifierNode extends BaseNode<'Identifier'> {
     /** The variable name */
@@ -466,6 +505,10 @@ declare type ExpressionNodeType = ExpressionNode['type'];
 interface HookOptions extends ExpressionContext {
     /** Given an expression node  */
     resolveNode: (node: ExpressionNode) => any;
+    /** Enabling this flag skips calling the onError hook, and just throws errors back to the caller.
+     * The caller is responsible for handling the error.
+     */
+    throwErrors?: boolean;
 }
 declare type ExpressionEvaluatorOptions = Omit<HookOptions, 'resolveNode' | 'evaluate'>;
 declare type ExpressionEvaluatorFunction = (exp: ExpressionType, options?: ExpressionEvaluatorOptions) => any;
@@ -477,6 +520,10 @@ declare class ExpressionEvaluator {
     readonly hooks: {
         /** Resolve an AST node for an expression to a value */
         resolve: SyncWaterfallHook<[any, ExpressionNode, HookOptions], Record<string, any>>;
+        /** Gets the options that will be passed in calls to the resolve hook */
+        resolveOptions: SyncWaterfallHook<[HookOptions], Record<string, any>>;
+        /** Allows users to change the expression to be evaluated before processing */
+        beforeEvaluate: SyncWaterfallHook<[ExpressionType, 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
@@ -492,7 +539,7 @@ declare class ExpressionEvaluator {
     };
     reset(): void;
     constructor(defaultOptions: ExpressionEvaluatorOptions);
-    evaluate(expression: ExpressionType, options?: ExpressionEvaluatorOptions): any;
+    evaluate(expr: 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;
@@ -505,6 +552,20 @@ declare class ExpressionEvaluator {
 
 /** Generates a function by removing the first context argument */
 declare function withoutContext<T extends unknown[], Return>(fn: (...args: T) => Return): ExpressionHandler<T, Return>;
+/** Get the node in the expression that's closest to the desired position */
+declare function findClosestNodeAtPosition(node: ExpressionNode, position: NodePosition): ExpressionNode | undefined;
+/** Checks if the expression is a simple type */
+declare function isObjectExpression(expr: ExpressionType): expr is ExpressionObjectType;
+
+/**
+ * An expression to AST parser based on JSEP: http://jsep.from.so/
+ */
+
+/** Parse out an expression from the string */
+declare function parseExpression(expr: string, options?: {
+    /** If true (the default), will throw on invalid expressions */
+    strict?: boolean;
+}): ExpressionNode;
 
 declare type FormatOptions = Omit<Formatting.Reference, 'type'>;
 /**
@@ -576,6 +637,8 @@ declare class FlowInstance {
         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>>;
+        /** A callback to run actions after a transition occurs */
+        afterTransition: SyncHook<[FlowInstance], Record<string, any>>;
     };
     constructor(id: string, flow: NavigationFlow, options?: {
         /** Logger instance to use */
@@ -743,24 +806,95 @@ declare class Parser {
     };
     parseView(value: AnyAssetType): Node.View;
     createASTNode(node: Node.Node | null, value: any): Node.Node | null;
+    /**
+     * Checks if there are templated values in the object
+     *
+     * @param obj - The Parsed Object to check to see if we have a template array type for
+     * @param localKey - The key being checked
+     */
+    private hasTemplateValues;
     parseObject(obj: object, type?: Node.ChildrenTypes, options?: ParseObjectOptions): Node.Node | null;
 }
 
+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 retrieve 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(namespace?: string): void;
+}
+
+interface ValidationGetResolveOptions {
+    /**
+     * If we should ignore any non-blocking validations in the return
+     * @default true
+     */
+    ignoreNonBlocking?: boolean;
+}
+interface PlayerUtils {
+    findPlugin<Plugin = unknown>(symbol: symbol): Plugin | undefined;
+}
 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;
+        getAll(options?: ValidationGetResolveOptions): Map<BindingInstance, ValidationResponse> | undefined;
         /** Internal Method to lookup if there is a validation for the given binding */
-        _getValidationForBinding(binding: BindingLike): ValidationResponse | undefined;
+        _getValidationForBinding(binding: BindingLike): {
+            /** Get the validation for the given binding */
+            get: (options?: ValidationGetResolveOptions) => ValidationResponse | undefined;
+            /** Get all validations for the given binding */
+            getAll: (options?: ValidationGetResolveOptions) => Array<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;
+            track?: boolean;
+        } & ValidationGetResolveOptions): ValidationResponse | undefined;
+        getValidationsForBinding(binding: BindingLike, options?: {
+            /** If this binding should also be tracked for validations */
+            track?: boolean;
+        } & ValidationGetResolveOptions): Array<ValidationResponse>;
         /** Get errors for all children regardless of section */
-        getChildren(type: Validation.DisplayTarget): Array<ValidationResponse>;
+        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 */
@@ -774,6 +908,8 @@ declare namespace Resolve {
     interface BaseOptions {
         /** A logger to use */
         logger?: Logger;
+        /** Utils for various useful operations */
+        utils?: PlayerUtils;
         /** An optional set of validation features */
         validation?: Validation;
         /** Parse a raw valy into an AST node */
@@ -782,6 +918,8 @@ declare namespace Resolve {
         transition?: TransitionFunction;
         /** The hub for data invariants and metaData associated with the data model */
         schema: SchemaController;
+        /** The constants for messages */
+        constants?: ConstantsProvider;
     }
     interface NodeDataOptions {
         /** The data to set or get data from */
@@ -908,8 +1046,10 @@ declare class Resolver {
     constructor(root: Node.Node, options: Resolve.ResolverOptions);
     getSourceNode(convertedAST: Node.Node): Node.Node | undefined;
     update(changes?: Set<BindingInstance>): any;
+    getResolveCache(): Map<Node.Node, Resolve.ResolvedNode>;
     private getNodeID;
     private getPreviousResult;
+    private cloneNode;
     private computeTree;
 }
 
@@ -961,6 +1101,8 @@ declare class TemplatePlugin implements ViewPlugin {
 
 /** A plugin that resolves all string references for each node */
 declare class StringResolverPlugin implements ViewPlugin {
+    private propertiesToSkipCache;
+    constructor();
     applyResolver(resolver: Resolver): void;
     apply(view: View): void;
 }
@@ -1040,6 +1182,8 @@ declare class Builder {
 interface BindingTracker {
     /** Get the bindings currently being tracked for validation */
     getBindings(): Set<BindingInstance>;
+    /** Add a binding to the tracked set */
+    trackBinding(binding: BindingInstance): void;
 }
 interface Options$1 {
     /** Parse a binding from a view */
@@ -1057,12 +1201,21 @@ declare class ValidationBindingTrackerViewPlugin implements ViewPlugin, BindingT
     constructor(options: Options$1);
     /** Fetch the tracked bindings in the current view */
     getBindings(): Set<BindingInstance>;
+    /** Add a binding to the tracked set */
+    trackBinding(binding: BindingInstance): void;
     /** Attach hooks to the given resolver */
     applyResolver(resolver: Resolver): void;
     apply(view: ViewInstance): void;
 }
 
-declare type SimpleValidatorContext = Omit<ValidatorContext, 'validation'>;
+declare const SCHEMA_VALIDATION_PROVIDER_NAME = "schema";
+declare const VIEW_VALIDATION_PROVIDER_NAME = "view";
+declare const VALIDATION_PROVIDER_NAME_SYMBOL: unique symbol;
+declare type ValidationObjectWithSource = ValidationObjectWithHandler & {
+    /** The name of the validation */
+    [VALIDATION_PROVIDER_NAME_SYMBOL]: string;
+};
+declare type SimpleValidatorContext = Omit<ValidatorContext, 'validation' | 'schemaType'>;
 interface BaseActiveValidation<T> {
     /** The validation is being actively shown */
     state: 'active';
@@ -1081,7 +1234,9 @@ declare type StatefulWarning = {
     /** A common key to differentiate between errors and warnings */
     type: 'warning';
     /** The underlying validation this tracks */
-    value: ValidationObject;
+    value: ValidationObjectWithSource;
+    /** If this is currently preventing navigation from continuing */
+    isBlockingNavigation: boolean;
 } & ({
     /** warnings start with no state, but can active or dismissed */
     state: 'none' | 'dismissed';
@@ -1091,24 +1246,29 @@ declare type StatefulError = {
     /** A common key to differentiate between errors and warnings */
     type: 'error';
     /** The underlying validation this tracks */
-    value: ValidationObject;
+    value: ValidationObjectWithSource;
+    /** If this is currently preventing navigation from continuing */
+    isBlockingNavigation: boolean;
 } & ({
     /** Errors start with no state an can be activated */
     state: 'none';
 } | ActiveError);
 declare type StatefulValidationObject = StatefulWarning | StatefulError;
-declare type ValidationRunner = (obj: ValidationObject) => {
+declare type ValidationRunner = (obj: ValidationObjectWithHandler) => {
     /** A validation message */
     message: string;
 } | undefined;
 /** A class that manages validating bindings across phases */
 declare class ValidatedBinding {
-    private currentPhase?;
+    currentPhase?: Validation.Trigger;
     private applicableValidations;
     private validationsByState;
+    get allValidations(): Array<StatefulValidationObject>;
     weakBindings: Set<BindingInstance>;
     private onDismiss?;
-    constructor(possibleValidations: Array<ValidationObject>, onDismiss?: () => void, log?: Logger, weakBindings?: Set<BindingInstance>);
+    constructor(possibleValidations: Array<ValidationObjectWithSource>, onDismiss?: () => void, log?: Logger, weakBindings?: Set<BindingInstance>);
+    private checkIfBlocking;
+    getAll(): Array<ValidationResponse>;
     get(): ValidationResponse | undefined;
     private runApplicableValidations;
     update(phase: Validation.Trigger, canDismiss: boolean, runner: ValidationRunner): void;
@@ -1140,27 +1300,42 @@ declare class ValidationController implements BindingTracker {
         onAddValidation: SyncWaterfallHook<[ValidationResponse, BindingInstance], Record<string, any>>;
         /** The inverse of onAddValidation, this is called when a validation is removed from the list */
         onRemoveValidation: SyncWaterfallHook<[ValidationResponse, BindingInstance], Record<string, any>>;
+        resolveValidationProviders: SyncWaterfallHook<[{
+            /** The name of the provider */
+            source: string;
+            /** The provider itself */
+            provider: ValidationProvider;
+        }[]], {
+            /** The view this is triggered for  */
+            view?: ViewInstance | undefined;
+        }>;
+        /** A hook called when a binding is added to the tracker */
+        onTrackBinding: SyncHook<[BindingInstance], Record<string, any>>;
     };
     private tracker;
     private validations;
     private validatorRegistry?;
     private schema;
     private providers;
+    private viewValidationProvider?;
     private options?;
     private weakBindingTracker;
-    private lastActiveBindings;
     constructor(schema: SchemaController, options?: SimpleValidatorContext);
     setOptions(options: SimpleValidatorContext): void;
     /** Return the middleware for the data-model to stop propagation of invalid data */
     getDataMiddleware(): Array<DataModelMiddleware>;
+    private getValidationProviders;
+    reset(): void;
     onView(view: ViewInstance): void;
-    private updateValidationsForBinding;
-    private validationRunner;
+    updateValidationsForBinding(binding: BindingInstance, trigger: Validation.Trigger, validationContext?: SimpleValidatorContext, onDismiss?: () => void): void;
+    validationRunner(validationObj: ValidationObjectWithHandler, binding: BindingInstance, context?: SimpleValidatorContext | undefined): {
+        message: string;
+    } | undefined;
     private updateValidationsForView;
-    private setCompare;
     private get activeBindings();
     getValidator(type: string): ValidatorFunction<unknown> | undefined;
     getBindings(): Set<BindingInstance>;
+    trackBinding(binding: BindingInstance): void;
     /** Executes all known validations for the tracked bindings using the given model */
     validateView(trigger?: Validation.Trigger): {
         /** Indicating if the view can proceed without error */
@@ -1168,6 +1343,7 @@ declare class ValidationController implements BindingTracker {
         /** the validations that are preventing the view from continuing */
         validations?: Map<BindingInstance, ValidationResponse>;
     };
+    /** Get the current tracked validation for the given binding */
     getValidationForBinding(binding: BindingInstance): ValidatedBinding | undefined;
     forView(parser: BindingFactory): Resolve.Validation;
 }
@@ -1203,6 +1379,16 @@ interface TransformFunctions {
 }
 declare type TransformRegistry = Registry<TransformFunctions>;
 
+/** Wrapper for the Data Controller Class that prevents writes */
+declare class ReadOnlyDataController implements DataModelWithParser<DataModelOptions> {
+    private controller;
+    private logger?;
+    constructor(controller: DataController, logger?: Logger);
+    get(binding: BindingLike, options?: DataModelOptions | undefined): any;
+    set(transaction: [BindingLike, any][], options?: DataModelOptions | undefined): Updates;
+    delete(binding: BindingLike, options?: DataModelOptions | undefined): void;
+}
+
 /** 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 */
@@ -1251,8 +1437,11 @@ declare type InProgressState = BaseFlowState<'in-progress'> & PlayerFlowExecutio
 };
 /** The flow completed properly */
 declare type CompletedState = BaseFlowState<'completed'> & PlayerFlowExecutionData & FlowResult & {
-    /** The top-level data-model for the flow */
-    dataModel: DataModelWithParser;
+    /** Readonly Player controllers to provide Player functionality after the flow has ended */
+    controllers: {
+        /** A read only instance of the Data Controller */
+        data: ReadOnlyDataController;
+    };
 };
 /** The flow finished but not successfully */
 declare type ErrorState = BaseFlowState<'error'> & {
@@ -1275,7 +1464,7 @@ declare class DataController implements DataModelWithParser<DataModelOptions> {
         onDelete: SyncHook<[any], Record<string, any>>;
         onSet: SyncHook<[BatchSetTransaction], Record<string, any>>;
         onGet: SyncHook<[any, any], Record<string, any>>;
-        onUpdate: SyncHook<[Updates], Record<string, any>>;
+        onUpdate: SyncHook<[Updates, DataModelOptions | undefined], Record<string, any>>;
         format: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
         deformat: SyncWaterfallHook<[any, BindingInstance], Record<string, any>>;
         serialize: SyncWaterfallHook<[any], Record<string, any>>;
@@ -1298,11 +1487,9 @@ declare class DataController implements DataModelWithParser<DataModelOptions> {
     set(transaction: RawSetTransaction, options?: DataModelOptions): Updates;
     private resolve;
     get(binding: BindingLike, options?: DataModelOptions): any;
-    delete(binding: BindingLike): void;
-    getTrash(): Set<BindingInstance>;
-    private addToTrash;
-    private deleteData;
+    delete(binding: BindingLike, options?: DataModelOptions): void;
     serialize(): object;
+    makeReadOnly(): ReadOnlyDataController;
 }
 
 interface ViewControllerOptions {
@@ -1349,51 +1536,6 @@ 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;
@@ -1414,9 +1556,13 @@ 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>>;
+declare type ValidationObjectWithHandler = ValidationObject & {
+    /** A predefined handler for this validation object */
+    handler?: ValidatorFunction;
+};
 interface ValidationProvider {
-    getValidationsForBinding?(binding: BindingInstance): Array<ValidationObject> | undefined;
-    getValidationsForView?(): Array<ValidationObject> | undefined;
+    getValidationsForBinding?(binding: BindingInstance): Array<ValidationObjectWithHandler> | undefined;
+    getValidationsForView?(): Array<ValidationObjectWithHandler> | undefined;
 }
 interface ValidatorContext {
     /** The data to set or get data from */
@@ -1431,13 +1577,24 @@ interface ValidatorContext {
     validation: ValidationObject;
     /** The constants for messages */
     constants: ConstantsProvider;
+    /** The type in the schema that triggered the validation if there is one */
+    schemaType: Schema.DataType | undefined;
 }
 declare type ValidatorFunction<Options = unknown> = (context: ValidatorContext, value: any, options?: Options) => Omit<BaseValidationResponse, 'severity'> | undefined;
 
+/**
+ * A BindingInstance with an indicator of whether or not it's a strong binding
+ */
+declare type StrongOrWeakBinding = {
+    /** BindingInstance in question */
+    binding: BindingInstance;
+    /** Boolean indicating whether the relevant BindingInstance is a strong binding */
+    isStrong: boolean;
+};
 /**
  * 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;
+declare type MiddlewareChecker = (binding: BindingInstance, model: DataModelImpl) => ValidationResponse | Set<StrongOrWeakBinding> | undefined;
 /**
  * Middleware for the data-model that caches the results of invalid data
  */
@@ -1445,12 +1602,16 @@ declare class ValidationMiddleware implements DataModelMiddleware {
     validator: MiddlewareChecker;
     shadowModelPaths: Map<BindingInstance, any>;
     private logger?;
+    private shouldIncludeInvalid?;
     constructor(validator: MiddlewareChecker, options?: {
         /** A logger instance */
         logger?: Logger;
+        /** Optional function to include data staged in shadowModel */
+        shouldIncludeInvalid?: (options?: DataModelOptions) => boolean;
     });
     set(transaction: BatchSetTransaction, options?: DataModelOptions, next?: DataModelImpl): Updates;
     get(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): any;
+    delete(binding: BindingInstance, options?: DataModelOptions, next?: DataModelImpl): void | undefined;
 }
 
 /** A registry that tracks validators  */
@@ -1463,8 +1624,17 @@ declare class ValidatorRegistry {
     register<T>(name: string, handler: ValidatorFunction<T>): void;
 }
 
+/**
+ * Remove a binding, and any children from from the map
+ * If the binding is an array-item, then it will be spliced from the array and the others will be shifted down
+ *
+ * @param sourceMap - A map of bindings to values
+ * @param binding - The binding to remove from the map
+ */
+declare function removeBindingAndChildrenFromMap<T>(sourceMap: Map<BindingInstance, T>, binding: BindingInstance): Map<BindingInstance, T>;
+
 /** Expand the authored schema into a set of paths -> DataTypes */
-declare function parse(schema: Schema.Schema): Map<string, Schema.DataType>;
+declare function parse(schema: Schema.Schema): Map<string, Schema.DataTypes>;
 /**
  * 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.
@@ -1473,18 +1643,18 @@ declare function parse(schema: Schema.Schema): Map<string, Schema.DataType>;
 declare class SchemaController implements ValidationProvider {
     private formatters;
     private types;
-    readonly schema: Map<string, Schema.DataType>;
+    readonly schema: Map<string, Schema.DataTypes>;
     private bindingSchemaNormalizedCache;
     readonly hooks: {
-        resolveTypeForBinding: SyncWaterfallHook<[Schema.DataType<unknown> | undefined, BindingInstance], Record<string, any>>;
+        resolveTypeForBinding: SyncWaterfallHook<[Schema.DataTypes | 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;
+    getType(binding: BindingInstance): Schema.DataTypes | undefined;
+    getApparentType(binding: BindingInstance): Schema.DataTypes | undefined;
     getTypeDefinition(dataType: string): Schema.DataType<any> | undefined;
     getFormatterForType(formatReference: Formatting.Reference): FormatDefinition<unknown, unknown> | undefined;
     /**
@@ -1495,10 +1665,20 @@ declare class SchemaController implements ValidationProvider {
 }
 
 interface Options {
-    /** The model to use when resolving refs */
-    model: DataModelWithParser;
-    /** A function to evaluate an expression */
-    evaluate: (exp: Expression) => any;
+    /**
+     * The model to use when resolving refs
+     * Passing `false` will skip trying to resolve any direct model refs ({{foo}})
+     */
+    model: false | DataModelWithParser;
+    /**
+     * A function to evaluate an expression
+     * Passing `false` will skip trying to evaluate any expressions (@[ foo() ]@)
+     */
+    evaluate: false | ((exp: Expression) => any);
+    /**
+     * Optionaly resolve binding without formatting in case Type format applies
+     */
+    formatted?: boolean;
 }
 /** Search the given string for the coordinates of the next expression to resolve */
 declare function findNextExp(str: string): {
@@ -1525,6 +1705,8 @@ interface PlayerPlugin {
      */
     apply: (player: Player) => void;
 }
+interface ExtendedPlayerPlugin<Assets = void, Views = void, Expressions = void, DataTypes = void> {
+}
 interface PlayerConfigOptions {
     /** A set of plugins to load  */
     plugins?: PlayerPlugin[];
@@ -1611,4 +1793,4 @@ declare class FlowExpPlugin implements PlayerPlugin {
     apply(player: Player): void;
 }
 
-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 };
+export { AnyAssetType, ApplicabilityPlugin, ArrayExpressionNode, AssetTransformCorePlugin, AssignmentNode, BINDING_BRACKETS_REGEX, BaseFlowState, BaseNode, BasicExpressionTypes, 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, ExpressionObjectType, ExpressionType, ExtendedPlayerPlugin, 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, NodeLocation, NodePosition, NodeType, NoopLogger, NotStartedState, ObjectNode, OperatorProcessingOptions, Options, ParseObjectOptions, Parser, PipelinedDataModel, Player, PlayerConfigOptions, PlayerFlowExecutionData, PlayerFlowState, PlayerFlowStatus, PlayerInfo, PlayerPlugin, PlayerUtils, ProxyLogger, ROOT_BINDING, RawBinding, RawBindingSegment, RawSetTransaction, RawSetType, Resolve, Resolver, SCHEMA_VALIDATION_PROVIDER_NAME, SIMPLE_BINDING_REGEX, SchemaController, Severity, StatefulValidationObject, Store, StringResolverPlugin, StrongOrWeakBinding, SwitchPlugin, TapableLogger, TemplatePlugin, ThisNode, TransformFunction, TransformFunctions, TransformRegistry, TransitionFunction, TransitionOptions, UnaryNode, UnaryOperator, Updates, VALIDATION_PROVIDER_NAME_SYMBOL, VIEW_VALIDATION_PROVIDER_NAME, ValidationBindingTrackerViewPlugin, ValidationController, ValidationGetResolveOptions, ValidationMiddleware, ValidationObject, ValidationObjectWithHandler, ValidationObjectWithSource, ValidationProvider, ValidationResponse, ValidatorContext, ValidatorFunction, ValidatorRegistry, ViewController, ViewControllerOptions, ViewInstance, ViewPlugin, WarningValidationResponse, caresAboutDataChanges, constructModelForPipeline, findClosestNodeAtPosition, findInArray, findNextExp, getBindingSegments, isBinding, isExpressionNode, isObjectExpression, maybeConvertToNum, parse, parseExpression, removeBindingAndChildrenFromMap, resolveDataRefs, resolveDataRefsInString, resolveExpressionsInString, severities, toModel, toNodeResolveOptions, withParser, withoutContext };