@microsoft/fast-element 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/fast-element.untrimmed.d.ts

@@ -24,7 +24,7 @@ export declare interface Accessor {
  * Used to add behaviors when constructing styles.
  * @public
  */
-export declare type AddBehavior = (behavior: Behavior<HTMLElement>) => void;
+export declare type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
 
 /**
  * Used to add behavior factories when constructing templates.
@@ -32,20 +32,6 @@ export declare type AddBehavior = (behavior: Behavior<HTMLElement>) => void;
  */
 export declare type AddViewBehaviorFactory = (factory: ViewBehaviorFactory) => string;
 
-/**
- * https://wicg.github.io/construct-stylesheets/
- * https://developers.google.com/web/updates/2019/02/constructable-stylesheets
- *
- * @internal
- */
-export declare class AdoptedStyleSheetsStrategy implements StyleStrategy {
-    /** @internal */
-    readonly sheets: CSSStyleSheet[];
-    constructor(styles: (string | CSSStyleSheet)[]);
-    addStylesTo(target: StyleTarget): void;
-    removeStylesFrom(target: StyleTarget): void;
-}
-
 /**
  * An observer for arrays.
  * @public
@@ -90,53 +76,6 @@ export declare const ArrayObserver: Readonly<{
     readonly enable: () => void;
 }>;
 
-/**
- * The type of HTML aspect to target.
- * @public
- */
-export declare const Aspect: Readonly<{
-    /**
-     * Not aspected.
-     */
-    readonly none: 0;
-    /**
-     * An attribute.
-     */
-    readonly attribute: 1;
-    /**
-     * A boolean attribute.
-     */
-    readonly booleanAttribute: 2;
-    /**
-     * A property.
-     */
-    readonly property: 3;
-    /**
-     * Content
-     */
-    readonly content: 4;
-    /**
-     * A token list.
-     */
-    readonly tokenList: 5;
-    /**
-     * An event.
-     */
-    readonly event: 6;
-    /**
-     *
-     * @param directive - The directive to assign the aspect to.
-     * @param value - The value to base the aspect determination on.
-     */
-    readonly assign: (directive: Aspected, value: string) => void;
-}>;
-
-/**
- * The type of HTML aspect to target.
- * @public
- */
-export declare type Aspect = typeof Aspect[Exclude<keyof typeof Aspect, "assign" | "none">];
-
 /**
  * Represents something that applies to a specific aspect of the DOM.
  * @public
@@ -153,11 +92,11 @@ export declare interface Aspected {
     /**
      * The type of aspect to target.
      */
-    aspectType: Aspect;
+    aspectType: DOMAspect;
     /**
      * A binding if one is associated with the aspect.
      */
-    binding?: Binding;
+    dataBinding?: Binding;
 }
 
 /**
@@ -186,6 +125,17 @@ export declare type AttributeConfiguration = {
     converter?: ValueConverter;
 };
 
+/**
+ * Metadata used to configure a custom attribute's behavior.
+ * @public
+ */
+export declare const AttributeConfiguration: Readonly<{
+    /**
+     * Locates all attribute configurations associated with a type.
+     */
+    locate: (target: {}) => AttributeConfiguration[];
+}>;
+
 /**
  * An implementation of {@link Accessor} that supports reactivity,
  * change callbacks, attribute reflection, and type conversion for
@@ -265,121 +215,41 @@ export declare class AttributeDefinition implements Accessor {
 export declare type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
 
 /**
- * Represents an object that can contribute behavior to a view or
- * element's bind/unbind operations.
- * @public
- */
-export declare interface Behavior<TSource = any, TParent = any> {
-    /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     */
-    bind(source: TSource, context: ExecutionContext<TParent>): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     */
-    unbind(source: TSource, context: ExecutionContext<TParent>): void;
-}
-
-/**
- * Creates a binding directive with the specified configuration.
- * @param binding - The binding expression.
- * @param config - The binding configuration.
- * @returns A binding directive.
- * @public
- */
-export declare function bind<T = any>(binding: Binding<T>, config?: BindingConfig | DefaultBindingOptions): CaptureType<T>;
-
-/**
- * The signature of an arrow function capable of being evaluated
- * as part of a template binding update.
- * @public
- */
-export declare type Binding<TSource = any, TReturn = any, TParent = any> = (source: TSource, context: ExecutionContext<TParent>) => TReturn;
-
-/**
- * Describes the configuration for a binding expression.
- * @public
- */
-export declare interface BindingConfig<T = any> {
-    /**
-     * The binding mode to configure the binding with.
-     */
-    mode: BindingMode;
-    /**
-     * Options to be supplied to the binding behaviors.
-     */
-    options: T;
-}
-
-/**
- * Describes the configuration for a binding expression.
+ * Creates an standard binding.
+ * @param expression - The binding to refresh when changed.
+ * @param policy - The security policy to associate with th binding.
+ * @param isVolatile - Indicates whether the binding is volatile or not.
+ * @returns A binding configuration.
  * @public
  */
-export declare const BindingConfig: Readonly<{
-    /**
-     * Creates a binding configuration based on the provided mode and options.
-     * @param mode - The mode to use for the configuration.
-     * @param defaultOptions - The default options to use for the configuration.
-     * @returns A new binding configuration.
-     */
-    define<T>(mode: BindingMode, defaultOptions: T): BindingConfig<T> & BindingConfigResolver<T>;
-}>;
+export declare function bind<T = any>(expression: Expression<T>, policy?: DOMPolicy, isVolatile?: boolean): Binding<T>;
 
 /**
- * Creates a new binding configuration based on the supplied options.
- * @public
- */
-export declare type BindingConfigResolver<T> = (options: T) => BindingConfig<T>;
-
-/**
- * Describes how aspects of an HTML element will be affected by bindings.
- * @public
- */
-export declare type BindingMode = Record<Aspect, (directive: HTMLBindingDirective) => Pick<ViewBehaviorFactory, "createBehavior">>;
-
-/**
- * Describes how aspects of an HTML element will be affected by bindings.
- * @public
- */
-export declare const BindingMode: Readonly<{
-    /**
-     * Creates a binding mode based on the supplied behavior types.
-     * @param UpdateType - The base behavior type used to update aspects.
-     * @param EventType - The base behavior type used to respond to events.
-     * @returns A new binding mode.
-     */
-    define(UpdateType: typeof UpdateBinding, EventType?: typeof EventBinding): BindingMode;
-}>;
-
-/**
- * Enables evaluation of and subscription to a binding.
+ * Captures a binding expression along with related information and capabilities.
+ *
  * @public
  */
-export declare interface BindingObserver<TSource = any, TReturn = any, TParent = any> extends Notifier, Disposable {
+export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
+    evaluate: Expression<TSource, TReturn, TParent>;
+    policy?: DOMPolicy | undefined;
+    isVolatile: boolean;
     /**
-     * Begins observing the binding for the source and returns the current value.
-     * @param source - The source that the binding is based on.
-     * @param context - The execution context to execute the binding within.
-     * @returns The value of the binding.
+     * Options associated with the binding.
      */
-    observe(source: TSource, context?: ExecutionContext<TParent>): TReturn;
+    options?: any;
     /**
-     * Gets {@link ObservationRecord|ObservationRecords} that the {@link BindingObserver}
-     * is observing.
+     * Creates a binding.
+     * @param evaluate - Evaluates the binding.
+     * @param policy - The security policy to associate with this binding.
+     * @param isVolatile - Indicates whether the binding is volatile.
      */
-    records(): IterableIterator<ObservationRecord>;
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy | undefined, isVolatile?: boolean);
     /**
-     * Sets the update mode used by the observer.
-     * @param isAsync - Indicates whether updates should be asynchronous.
-     * @remarks
-     * By default, the update mode is asynchronous, since that provides the best
-     * performance for template rendering scenarios. Passing false to setMode will
-     * instead cause the observer to notify subscribers immediately when changes occur.
+     * Creates an observer capable of notifying a subscriber when the output of a binding changes.
+     * @param directive - The HTML Directive to create the observer for.
+     * @param subscriber - The subscriber to changes in the binding.
      */
-    setMode(isAsync: boolean): void;
+    abstract createObserver(directive: HTMLDirective, subscriber: Subscriber): ExpressionObserver<TSource, TReturn, TParent>;
 }
 
 /**
@@ -405,44 +275,7 @@ export declare type Callable = typeof Function.prototype.call | {
  * into templates.
  * @public
  */
-export declare interface CaptureType<TSource> {
-}
-
-/**
- * A binding behavior for bindings that change.
- * @public
- */
-export declare class ChangeBinding extends UpdateBinding {
-    private isBindingVolatile;
-    private observerProperty;
-    /**
-     * Creates an instance of ChangeBinding.
-     * @param directive - The directive that has the configuration for this behavior.
-     * @param updateTarget - The function used to update the target with the latest value.
-     */
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
-    /**
-     * Returns the binding observer used to update the node.
-     * @param target - The target node.
-     * @returns A BindingObserver.
-     */
-    protected getObserver(target: Node): BindingObserver;
-    /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    /** @internal */
-    handleChange(binding: Binding, observer: BindingObserver): void;
+export declare interface CaptureType<TSource, TParent> {
 }
 
 /**
@@ -458,7 +291,7 @@ export declare interface ChildListDirectiveOptions<T = any> extends NodeBehavior
  * @param propertyOrOptions - The options used to configure child node observation.
  * @public
  */
-export declare function children<T = any>(propertyOrOptions: (keyof T & string) | ChildrenDirectiveOptions<keyof T & string>): CaptureType<T>;
+export declare function children<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
 
 /**
  * The runtime behavior for child node observation.
@@ -495,6 +328,17 @@ export declare class ChildrenDirective extends NodeObservationDirective<Children
  */
 export declare type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 
+/**
+ * Represents a constructable class with a prototype.
+ * @public
+ */
+export declare type Class<T, C = {}> = C & Constructable<T> & {
+    /**
+     * The class's prototype;
+     */
+    readonly prototype: T;
+};
+
 /**
  * A function capable of compiling a template from the preprocessed form produced
  * by the html template function into a result that can instantiate views.
@@ -508,33 +352,36 @@ html: string | HTMLTemplateElement,
 /**
  * The behavior factories used within the html that is being compiled.
  */
-factories: Record<string, ViewBehaviorFactory>) => HTMLTemplateCompilationResult;
+factories: Record<string, ViewBehaviorFactory>, 
+/**
+ * The security policy to compile the html with.
+ */
+policy: DOMPolicy) => HTMLTemplateCompilationResult;
+
+/**
+ * Represents a ViewBehaviorFactory after the compilation process has completed.
+ * @public
+ */
+export declare type CompiledViewBehaviorFactory = Required<ViewBehaviorFactory>;
 
 /**
  * Common APIs related to compilation.
  * @public
  */
 export declare const Compiler: {
-    /**
-     * Sets the HTML trusted types policy used by the compiler.
-     * @param policy - The policy to set for HTML.
-     * @remarks
-     * This API can only be called once, for security reasons. It should be
-     * called by the application developer at the start of their program.
-     */
-    setHTMLPolicy(policy: TrustedTypesPolicy): void;
     /**
      * Compiles a template and associated directives into a compilation
      * result which can be used to create views.
      * @param html - The html string or template element to compile.
-     * @param directives - The directives referenced by the template.
+     * @param factories - The behavior factories referenced by the template.
+     * @param policy - The security policy to compile the html with.
      * @remarks
      * The template that is provided for compilation is altered in-place
      * and cannot be compiled again. If the original template must be preserved,
      * it is recommended that you clone the original and pass the clone to this API.
      * @public
      */
-    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent>;
+    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy): HTMLTemplateCompilationResult<TSource, TParent>;
     /**
      * Sets the default compilation strategy that will be used by the ViewTemplate whenever
      * it needs to compile a view preprocessed with the html template function.
@@ -545,9 +392,10 @@ export declare const Compiler: {
      * Aggregates an array of strings and directives into a single directive.
      * @param parts - A heterogeneous array of static strings interspersed with
      * directives.
+     * @param policy - The security policy to use with the aggregated bindings.
      * @returns A single inline directive that aggregates the behavior of all the parts.
      */
-    aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
+    aggregate(parts: (string | ViewBehaviorFactory)[], policy?: DOMPolicy): ViewBehaviorFactory;
 };
 
 /**
@@ -556,8 +404,12 @@ export declare const Compiler: {
  */
 export declare type ComposableStyles = string | ElementStyles | CSSStyleSheet;
 
+declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+
+declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+
 /**
- * Allows for the creation of Constructable mixin classes.
+ * Represents a type which can be constructed with the new operator.
  *
  * @public
  */
@@ -578,127 +430,51 @@ export declare type ConstructibleStyleStrategy = {
 };
 
 /**
- * Controls the lifecycle and rendering of a `FASTElement`.
+ * A simple template that can create ContentView instances.
  * @public
  */
-export declare class Controller<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier {
-    private boundObservables;
-    private behaviors;
-    private needsInitialization;
-    private hasExistingShadowRoot;
-    private _template;
-    private _styles;
-    private _isConnected;
-    /**
-     * This allows Observable.getNotifier(...) to return the Controller
-     * when the notifier for the Controller itself is being requested. The
-     * result is that the Observable system does not need to create a separate
-     * instance of Notifier for observables on the Controller. The component and
-     * the controller will now share the same notifier, removing one-object construct
-     * per web component instance.
-     */
-    private readonly $fastController;
-    /**
-     * The element being controlled by this controller.
-     */
-    readonly element: TElement;
-    /**
-     * The element definition that instructs this controller
-     * in how to handle rendering and other platform integrations.
-     */
-    readonly definition: FASTElementDefinition;
-    /**
-     * The view associated with the custom element.
-     * @remarks
-     * If `null` then the element is managing its own rendering.
-     */
-    readonly view: ElementView<TElement> | null;
-    /**
-     * Indicates whether or not the custom element has been
-     * connected to the document.
-     */
-    get isConnected(): boolean;
-    private setIsConnected;
-    /**
-     * Gets/sets the template used to render the component.
-     * @remarks
-     * This value can only be accurately read after connect but can be set at any time.
-     */
-    get template(): ElementViewTemplate<TElement> | null;
-    set template(value: ElementViewTemplate<TElement> | null);
-    /**
-     * Gets/sets the primary styles used for the component.
-     * @remarks
-     * This value can only be accurately read after connect but can be set at any time.
-     */
-    get styles(): ElementStyles | null;
-    set styles(value: ElementStyles | null);
-    /**
-     * Creates a Controller to control the specified element.
-     * @param element - The element to be controlled by this controller.
-     * @param definition - The element definition metadata that instructs this
-     * controller in how to handle rendering and other platform integrations.
-     * @internal
-     */
-    constructor(element: TElement, definition: FASTElementDefinition);
+export declare interface ContentTemplate {
     /**
-     * Adds styles to this element. Providing an HTMLStyleElement will attach the element instance to the shadowRoot.
-     * @param styles - The styles to add.
+     * Creates a simple content view instance.
      */
-    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-    /**
-     * Removes styles from this element. Providing an HTMLStyleElement will detach the element instance from the shadowRoot.
-     * @param styles - the styles to remove.
-     */
-    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-    /**
-     * Adds behaviors to this element.
-     * @param behaviors - The behaviors to add.
-     */
-    addBehaviors(behaviors: ReadonlyArray<Behavior<TElement>>): void;
-    /**
-     * Removes behaviors from this element.
-     * @param behaviors - The behaviors to remove.
-     * @param force - Forces unbinding of behaviors.
-     */
-    removeBehaviors(behaviors: ReadonlyArray<Behavior<TElement>>, force?: boolean): void;
-    /**
-     * Runs connected lifecycle behavior on the associated element.
-     */
-    onConnectedCallback(): void;
+    create(): ContentView;
+}
+
+/**
+ * A simple View that can be interpolated into HTML content.
+ * @public
+ */
+export declare interface ContentView {
+    readonly context: ExecutionContext;
     /**
-     * Runs disconnected lifecycle behavior on the associated element.
+     * Binds a view's behaviors to its binding source.
+     * @param source - The binding source for the view's binding behaviors.
+     * @param context - The execution context to run the view within.
      */
-    onDisconnectedCallback(): void;
+    bind(source: any, context?: ExecutionContext): void;
     /**
-     * Runs the attribute changed callback for the associated element.
-     * @param name - The name of the attribute that changed.
-     * @param oldValue - The previous value of the attribute.
-     * @param newValue - The new value of the attribute.
+     * Unbinds a view's behaviors from its binding source and context.
      */
-    onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    unbind(): void;
     /**
-     * Emits a custom HTML event.
-     * @param type - The type name of the event.
-     * @param detail - The event detail object to send with the event.
-     * @param options - The event options. By default bubbles and composed.
-     * @remarks
-     * Only emits events if connected.
+     * Inserts the view's DOM nodes before the referenced node.
+     * @param node - The node to insert the view's DOM before.
      */
-    emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
-    private finishInitialization;
-    private renderTemplate;
+    insertBefore(node: Node): void;
     /**
-     * Locates or creates a controller for the specified element.
-     * @param element - The element to return the controller for.
-     * @remarks
-     * The specified element must have a {@link FASTElementDefinition}
-     * registered either through the use of the {@link customElement}
-     * decorator or a call to `FASTElement.define`.
+     * Removes the view's DOM nodes.
+     * The nodes are not disposed and the view can later be re-inserted.
      */
-    static forCustomElement(element: HTMLElement): Controller;
+    remove(): void;
 }
 
+/**
+ * Creates a function capable of locating metadata associated with a type.
+ * @returns A metadata locator function.
+ * @internal
+ */
+export declare function createMetadataLocator<TMetadata>(): (target: {}) => TMetadata[];
+
 /**
  * Do not change. Part of shared kernel contract.
  * @internal
@@ -768,12 +544,6 @@ export declare interface CSSDirectiveDefinition<TType extends Constructable<CSSD
     readonly type: TType;
 }
 
-/**
- * @deprecated Use css.partial instead.
- * @public
- */
-export declare const cssPartial: (strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => CSSDirective;
-
 /**
  * Transforms a template literal string into styles.
  * @param strings - The string fragments that are interpolated with the values.
@@ -807,63 +577,269 @@ export declare function customElement(nameOrDef: string | PartialFASTElementDefi
  */
 export declare type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
 
+declare function define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition): TType;
+
+declare function define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): TType;
+
 /**
- * The default binding options.
+ * Provides a mechanism for releasing resources.
  * @public
  */
-export declare type DefaultBindingOptions = AddEventListenerOptions;
+export declare interface Disposable {
+    /**
+     * Disposes the resources.
+     */
+    dispose(): void;
+}
 
 /**
- * Provides a mechanism for releasing resources.
+ * Common DOM APIs.
  * @public
  */
-export declare interface Disposable {
+export declare const DOM: Readonly<{
+    /**
+     * Gets the dom policy used by the templating system.
+     */
+    readonly policy: DOMPolicy;
+    /**
+     * Sets the dom policy used by the templating system.
+     * @param policy - The policy to set.
+     * @remarks
+     * This API can only be called once, for security reasons. It should be
+     * called by the application developer at the start of their program.
+     */
+    setPolicy(value: DOMPolicy): void;
+    /**
+     * Sets an attribute value on an element.
+     * @param element - The element to set the attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is `null` or `undefined`, the attribute is removed, otherwise
+     * it is set to the provided value using the standard `setAttribute` API.
+     */
+    setAttribute(element: HTMLElement, attributeName: string, value: any): void;
+    /**
+     * Sets a boolean attribute value.
+     * @param element - The element to set the boolean attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is true, the attribute is added; otherwise it is removed.
+     */
+    setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
+}>;
+
+/**
+ * The type of HTML aspect to target.
+ * @public
+ */
+export declare const DOMAspect: Readonly<{
+    /**
+     * Not aspected.
+     */
+    readonly none: 0;
+    /**
+     * An attribute.
+     */
+    readonly attribute: 1;
+    /**
+     * A boolean attribute.
+     */
+    readonly booleanAttribute: 2;
+    /**
+     * A property.
+     */
+    readonly property: 3;
+    /**
+     * Content
+     */
+    readonly content: 4;
+    /**
+     * A token list.
+     */
+    readonly tokenList: 5;
+    /**
+     * An event.
+     */
+    readonly event: 6;
+}>;
+
+/**
+ * The type of HTML aspect to target.
+ * @public
+ */
+export declare type DOMAspect = typeof DOMAspect[Exclude<keyof typeof DOMAspect, "none">];
+
+/**
+ * A security policy that FAST can use to interact with the DOM.
+ * @public
+ */
+export declare interface DOMPolicy {
+    /**
+     * Creates safe HTML from the provided value.
+     * @param value - The source to convert to safe HTML.
+     */
+    createHTML(value: string): string;
+    /**
+     * Protects a DOM sink that intends to write to the DOM.
+     * @param tagName - The tag name for the element to write to.
+     * @param aspect - The aspect of the DOM to write to.
+     * @param aspectName - The name of the aspect to write to.
+     * @param sink - The sink that is used to write to the DOM.
+     */
+    protect(tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink): DOMSink;
+}
+
+/**
+ * A function used to send values to a DOM sink.
+ * @public
+ */
+export declare type DOMSink = (target: Node, aspectName: string, value: any, ...args: any[]) => void;
+
+/**
+ * Controls the lifecycle and rendering of a `FASTElement`.
+ * @public
+ */
+export declare class ElementController<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier implements HostController<TElement> {
+    private boundObservables;
+    private needsInitialization;
+    private hasExistingShadowRoot;
+    private _template;
+    private stage;
+    /**
+     * A guard against connecting behaviors multiple times
+     * during connect in scenarios where a behavior adds
+     * another behavior during it's connectedCallback
+     */
+    private guardBehaviorConnection;
+    private behaviors;
+    private _mainStyles;
+    /**
+     * This allows Observable.getNotifier(...) to return the Controller
+     * when the notifier for the Controller itself is being requested. The
+     * result is that the Observable system does not need to create a separate
+     * instance of Notifier for observables on the Controller. The component and
+     * the controller will now share the same notifier, removing one-object construct
+     * per web component instance.
+     */
+    private readonly $fastController;
+    /**
+     * The element being controlled by this controller.
+     */
+    readonly source: TElement;
+    /**
+     * The element definition that instructs this controller
+     * in how to handle rendering and other platform integrations.
+     */
+    readonly definition: FASTElementDefinition;
+    /**
+     * The view associated with the custom element.
+     * @remarks
+     * If `null` then the element is managing its own rendering.
+     */
+    readonly view: ElementView<TElement> | null;
+    /**
+     * Indicates whether or not the custom element has been
+     * connected to the document.
+     */
+    get isConnected(): boolean;
+    /**
+     * Gets/sets the template used to render the component.
+     * @remarks
+     * This value can only be accurately read after connect but can be set at any time.
+     */
+    get template(): ElementViewTemplate<TElement> | null;
+    set template(value: ElementViewTemplate<TElement> | null);
+    /**
+     * The main set of styles used for the component, independent
+     * of any dynamically added styles.
+     */
+    get mainStyles(): ElementStyles | null;
+    set mainStyles(value: ElementStyles | null);
     /**
-     * Disposes the resources.
+     * Creates a Controller to control the specified element.
+     * @param element - The element to be controlled by this controller.
+     * @param definition - The element definition metadata that instructs this
+     * controller in how to handle rendering and other platform integrations.
+     * @internal
      */
-    dispose(): void;
-}
-
-/**
- * Common DOM APIs.
- * @public
- */
-export declare const DOM: Readonly<{
+    constructor(element: TElement, definition: FASTElementDefinition);
+    /**
+     * Adds the behavior to the component.
+     * @param behavior - The behavior to add.
+     */
+    addBehavior(behavior: HostBehavior<TElement>): void;
     /**
-     * @deprecated
-     * Use Updates.enqueue().
+     * Removes the behavior from the component.
+     * @param behavior - The behavior to remove.
+     * @param force - Forces removal even if this behavior was added more than once.
      */
-    queueUpdate: (callable: Callable) => void;
+    removeBehavior(behavior: HostBehavior<TElement>, force?: boolean): void;
     /**
-     * @deprecated
-     * Use Updates.next()
+     * Adds styles to this element. Providing an HTMLStyleElement will attach the element instance to the shadowRoot.
+     * @param styles - The styles to add.
      */
-    nextUpdate: () => Promise<void>;
+    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
     /**
-     * @deprecated
-     * Use Updates.process()
+     * Removes styles from this element. Providing an HTMLStyleElement will detach the element instance from the shadowRoot.
+     * @param styles - the styles to remove.
      */
-    processUpdates: () => void;
+    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
     /**
-     * Sets an attribute value on an element.
-     * @param element - The element to set the attribute value on.
-     * @param attributeName - The attribute name to set.
-     * @param value - The value of the attribute to set.
+     * Runs connected lifecycle behavior on the associated element.
+     */
+    connect(): void;
+    /**
+     * Runs disconnected lifecycle behavior on the associated element.
+     */
+    disconnect(): void;
+    /**
+     * Runs the attribute changed callback for the associated element.
+     * @param name - The name of the attribute that changed.
+     * @param oldValue - The previous value of the attribute.
+     * @param newValue - The new value of the attribute.
+     */
+    onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * Emits a custom HTML event.
+     * @param type - The type name of the event.
+     * @param detail - The event detail object to send with the event.
+     * @param options - The event options. By default bubbles and composed.
      * @remarks
-     * If the value is `null` or `undefined`, the attribute is removed, otherwise
-     * it is set to the provided value using the standard `setAttribute` API.
+     * Only emits events if connected.
      */
-    setAttribute(element: HTMLElement, attributeName: string, value: any): void;
+    emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
     /**
-     * Sets a boolean attribute value.
-     * @param element - The element to set the boolean attribute value on.
-     * @param attributeName - The attribute name to set.
-     * @param value - The value of the attribute to set.
+     * Opts out of JSON stringification.
+     * @internal
+     */
+    toJSON: () => undefined;
+    private renderTemplate;
+    /**
+     * Locates or creates a controller for the specified element.
+     * @param element - The element to return the controller for.
      * @remarks
-     * If the value is true, the attribute is added; otherwise it is removed.
+     * The specified element must have a {@link FASTElementDefinition}
+     * registered either through the use of the {@link customElement}
+     * decorator or a call to `FASTElement.define`.
      */
-    setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
-}>;
+    static forCustomElement(element: HTMLElement): ElementController;
+    /**
+     * Sets the strategy that ElementController.forCustomElement uses to construct
+     * ElementController instances for an element.
+     * @param strategy - The strategy to use.
+     */
+    static setStrategy(strategy: ElementControllerStrategy): void;
+}
+
+/**
+ * A type that instantiates an ElementController
+ * @public
+ */
+export declare interface ElementControllerStrategy {
+    new (element: HTMLElement, definition: FASTElementDefinition): ElementController;
+}
 
 /**
  * Creates a function that can be used to filter a Node array, selecting only elements.
@@ -877,7 +853,7 @@ export declare const elements: (selector?: string) => ElementsFilter;
  *
  * @public
  */
-export declare type ElementsFilter = (value: Node, index: number, array: Node[]) => boolean;
+export declare type ElementsFilter = (value: Node, index?: number, array?: Node[]) => boolean;
 
 /**
  * Represents styles that can be applied to a custom element.
@@ -890,7 +866,7 @@ export declare class ElementStyles {
     /**
      * The behaviors associated with this set of styles.
      */
-    readonly behaviors: ReadonlyArray<Behavior<HTMLElement>> | null;
+    readonly behaviors: ReadonlyArray<HostBehavior<HTMLElement>> | null;
     /**
      * Gets the StyleStrategy associated with these element styles.
      */
@@ -910,7 +886,7 @@ export declare class ElementStyles {
      * Associates behaviors with this set of styles.
      * @param behaviors - The behaviors to associate.
      */
-    withBehaviors(...behaviors: Behavior<HTMLElement>[]): this;
+    withBehaviors(...behaviors: HostBehavior<HTMLElement>[]): this;
     /**
      * Sets the strategy that handles adding/removing these styles for an element.
      * @param strategy - The strategy to use.
@@ -921,6 +897,12 @@ export declare class ElementStyles {
      * @param Strategy - The strategy type to construct.
      */
     static setDefaultStrategy(Strategy: ConstructibleStyleStrategy): void;
+    /**
+     * Normalizes a set of composable style options.
+     * @param styles - The style options to normalize.
+     * @returns A singular ElementStyles instance or undefined.
+     */
+    static normalize(styles: ComposableStyles | ComposableStyles[] | undefined): ElementStyles | undefined;
     /**
      * Indicates whether the DOM supports the adoptedStyleSheets feature.
      */
@@ -968,53 +950,11 @@ export declare interface ElementViewTemplate<TSource = any, TParent = any> {
  */
 export declare const emptyArray: readonly never[];
 
-/**
- * A binding behavior for handling events.
- * @public
- */
-export declare class EventBinding {
-    readonly directive: HTMLBindingDirective;
-    private contextProperty;
-    private sourceProperty;
-    /**
-     * Creates an instance of EventBinding.
-     * @param directive - The directive that has the configuration for this behavior.
-     */
-    constructor(directive: HTMLBindingDirective);
-    /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
-    /**
-     * @internal
-     */
-    handleEvent(event: Event): void;
-}
-
 /**
  * Provides additional contextual information available to behaviors and expressions.
  * @public
  */
-export declare class ExecutionContext<TParentSource = any> {
-    /**
-     * The default execution context.
-     */
-    static readonly default: ExecutionContext<any>;
+export declare interface ExecutionContext<TParent = any> {
     /**
      * The index of the current item within a repeat context.
      */
@@ -1026,41 +966,40 @@ export declare class ExecutionContext<TParentSource = any> {
     /**
      * The parent data source within a nested context.
      */
-    readonly parent: TParentSource;
+    parent: TParent;
     /**
      * The parent execution context when in nested context scenarios.
      */
-    readonly parentContext: ExecutionContext<TParentSource>;
-    private constructor();
+    parentContext: ExecutionContext<TParent>;
     /**
      * The current event within an event handler.
      */
-    get event(): Event;
+    readonly event: Event;
     /**
      * Indicates whether the current item within a repeat context
      * has an even index.
      */
-    get isEven(): boolean;
+    readonly isEven: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * has an odd index.
      */
-    get isOdd(): boolean;
+    readonly isOdd: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * is the first item in the collection.
      */
-    get isFirst(): boolean;
+    readonly isFirst: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * is somewhere in the middle of the collection.
      */
-    get isInMiddle(): boolean;
+    readonly isInMiddle: boolean;
     /**
      * Indicates whether the current item within a repeat context
      * is the last item in the collection.
      */
-    get isLast(): boolean;
+    readonly isLast: boolean;
     /**
      * Returns the typed event detail of a custom event.
      */
@@ -1069,36 +1008,104 @@ export declare class ExecutionContext<TParentSource = any> {
      * Returns the typed event target of the event.
      */
     eventTarget<TTarget extends EventTarget>(): TTarget;
+}
+
+/**
+ * Provides additional contextual information available to behaviors and expressions.
+ * @public
+ */
+export declare const ExecutionContext: Readonly<{
+    /**
+     * A default execution context.
+     */
+    default: ExecutionContext<any>;
+    /**
+     * Gets the current event.
+     * @returns An event object.
+     */
+    getEvent(): Event | null;
+    /**
+     * Sets the current event.
+     * @param event - An event object.
+     */
+    setEvent(event: Event | null): void;
+}>;
+
+/**
+ * The signature of an arrow function capable of being evaluated
+ * against source data and within an execution context.
+ * @public
+ */
+export declare type Expression<TSource = any, TReturn = any, TParent = any> = (source: TSource, context: ExecutionContext<TParent>) => TReturn;
+
+/**
+ * Controls the lifecycle of an expression and provides relevant context.
+ * @public
+ */
+export declare interface ExpressionController<TSource = any, TParent = any> {
     /**
-     * Updates the position/size on a context associated with a list item.
-     * @param index - The new index of the item.
-     * @param length - The new length of the list.
+     * The source the expression is evaluated against.
      */
-    updatePosition(index: number, length: number): void;
+    readonly source: TSource;
     /**
-     * Creates a new execution context descendent from the current context.
-     * @param source - The source for the context if different than the parent.
-     * @returns A child execution context.
+     * Indicates how the source's lifetime relates to the controller's lifetime.
      */
-    createChildContext<TParentSource>(parentSource: TParentSource): ExecutionContext<TParentSource>;
+    readonly sourceLifetime?: SourceLifetime;
     /**
-     * Creates a new execution context descent suitable for use in list rendering.
-     * @param item - The list item to serve as the source.
-     * @param index - The index of the item in the list.
-     * @param length - The length of the list.
+     * The context the expression is evaluated against.
      */
-    createItemContext(index: number, length: number): ExecutionContext<TParentSource>;
+    readonly context: ExecutionContext<TParent>;
     /**
-     * Sets the event for the current execution context.
-     * @param event - The event to set.
-     * @internal
+     * Indicates whether the controller is bound.
+     */
+    readonly isBound: boolean;
+    /**
+     * Registers an unbind handler with the controller.
+     * @param behavior - An object to call when the controller unbinds.
+     */
+    onUnbind(behavior: {
+        unbind(controller: ExpressionController<TSource, TParent>): any;
+    }): void;
+}
+
+/**
+ * Enables evaluation of and subscription to a binding.
+ * @public
+ */
+export declare interface ExpressionNotifier<TSource = any, TReturn = any, TParent = any> extends Notifier, ExpressionObserver<TSource, TReturn, TParent>, Disposable {
+    /**
+     * Observes the expression.
+     * @param source - The source for the expression.
+     * @param context - The context for the expression.
+     */
+    observe(source: TSource, context?: ExecutionContext): TReturn;
+    /**
+     * Gets {@link ObservationRecord|ObservationRecords} that the {@link ExpressionNotifier}
+     * is observing.
+     */
+    records(): IterableIterator<ObservationRecord>;
+    /**
+     * Sets the update mode used by the observer.
+     * @param isAsync - Indicates whether updates should be asynchronous.
+     * @remarks
+     * By default, the update mode is asynchronous, since that provides the best
+     * performance for template rendering scenarios. Passing false to setMode will
+     * instead cause the observer to notify subscribers immediately when changes occur.
      */
-    static setEvent(event: Event | null): void;
+    setMode(isAsync: boolean): void;
+}
+
+/**
+ * Observes an expression for changes.
+ * @public
+ */
+export declare interface ExpressionObserver<TSource = any, TReturn = any, TParent = any> {
     /**
-     * Creates a new root execution context.
-     * @returns A new execution context.
+     * Binds the expression to the source.
+     * @param controller - The controller that manages the lifecycle and related
+     * context for the expression.
      */
-    static create(): ExecutionContext;
+    bind(controller: ExpressionController<TSource, TParent>): TReturn;
 }
 
 /**
@@ -1116,7 +1123,7 @@ export declare interface FASTElement extends HTMLElement {
      * The underlying controller that handles the lifecycle and rendering of
      * this FASTElement.
      */
-    readonly $fastController: Controller;
+    readonly $fastController: ElementController;
     /**
      * Emits a custom HTML event.
      * @param type - The type name of the event.
@@ -1157,29 +1164,11 @@ export declare interface FASTElement extends HTMLElement {
  * static helpers for working with FASTElements.
  * @public
  */
-export declare const FASTElement: (new () => HTMLElement & FASTElement) & {
-    /**
-     * Creates a new FASTElement base class inherited from the
-     * provided base type.
-     * @param BaseType - The base element type to inherit from.
-     */
-    from<TBase extends {
-        new (): HTMLElement;
-        prototype: HTMLElement;
-    }>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
-    /**
-     * Defines a platform custom element based on the provided type and definition.
-     * @param type - The custom element type to define.
-     * @param nameOrDef - The name of the element to define or a definition object
-     * that describes the element to define.
-     */
-    define<TType extends Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): TType;
-    /**
-     * Defines metadata for a FASTElement which can be used to later define the element.
-     * IMPORTANT: This API will be renamed to "compose" in a future beta.
-     * @public
-     */
-    metadata<TType_1 extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType_1, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType_1>;
+export declare const FASTElement: {
+    new (): FASTElement;
+    define: typeof define;
+    compose: typeof compose;
+    from: typeof from;
 };
 
 /**
@@ -1187,7 +1176,7 @@ export declare const FASTElement: (new () => HTMLElement & FASTElement) & {
  * @public
  */
 export declare class FASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
-    private observedAttributes;
+    private platformDefined;
     /**
      * The type this element definition describes.
      */
@@ -1223,18 +1212,16 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
     /**
      * Options controlling the creation of the custom element's shadow DOM.
      */
-    readonly shadowOptions?: ShadowRootInit;
+    readonly shadowOptions?: ShadowRootOptions;
     /**
      * Options controlling how the custom element is defined with the platform.
      */
-    readonly elementOptions?: ElementDefinitionOptions;
+    readonly elementOptions: ElementDefinitionOptions;
     /**
-     * Creates an instance of FASTElementDefinition.
-     * @param type - The type this definition is being created for.
-     * @param nameOrConfig - The name of the element to define or a config object
-     * that describes the element to define.
+     * The registry to register this component in by default.
      */
-    constructor(type: TType, nameOrConfig?: PartialFASTElementDefinition | string);
+    readonly registry: CustomElementRegistry;
+    private constructor();
     /**
      * Defines a custom element based on this definition.
      * @param registry - The element registry to define the element in.
@@ -1242,6 +1229,19 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
      * This operation is idempotent per registry.
      */
     define(registry?: CustomElementRegistry): this;
+    /**
+     * Creates an instance of FASTElementDefinition.
+     * @param type - The type this definition is being created for.
+     * @param nameOrDef - The name of the element to define or a config object
+     * that describes the element to define.
+     */
+    static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+    /**
+     * Registers a FASTElement base type.
+     * @param type - The type to register as a base type.
+     * @internal
+     */
+    static registerBaseType(type: Function): void;
     /**
      * Gets the element definition associated with the specified type.
      * @param type - The custom element type to retrieve the definition for.
@@ -1273,22 +1273,96 @@ export declare interface FASTGlobal {
     /**
      * Sends a warning to the developer.
      * @param code - The warning code to send.
-     * @param args - Args relevant for the warning.
+     * @param values - Values relevant for the warning message.
      */
-    warn(code: number, ...args: any[]): void;
+    warn(code: number, values?: Record<string, any>): void;
     /**
      * Creates an error.
      * @param code - The error code to send.
-     * @param args - Args relevant for the error.
+     * @param values - Values relevant for the error message.
      */
-    error(code: number, ...args: any[]): Error;
+    error(code: number, values?: Record<string, any>): Error;
     /**
      * Adds debug messages for errors and warnings.
      * @param messages - The message dictionary to add.
+     * @remarks
+     * Message can include placeholders like $\{name\} which can be
+     * replaced by values passed at runtime.
      */
     addMessages(messages: Record<number, string>): void;
 }
 
+declare function from<TBase extends typeof HTMLElement>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
+
+/**
+ * Represents an object that can contribute behavior to a host.
+ * @public
+ */
+export declare interface HostBehavior<TSource = any> {
+    /**
+     * Executed when this behavior is attached to a controller.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    addedCallback?(controller: HostController<TSource>): void;
+    /**
+     * Executed when this behavior is detached from a controller.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    removedCallback?(controller: HostController<TSource>): void;
+    /**
+     * Executed when this behavior's host is connected.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    connectedCallback?(controller: HostController<TSource>): void;
+    /**
+     * Executed when this behavior's host is disconnected.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    disconnectedCallback?(controller: HostController<TSource>): void;
+}
+
+/**
+ * Controls the lifecycle and context of behaviors and styles
+ * associated with a component host.
+ * @public
+ */
+export declare interface HostController<TSource = any> {
+    /**
+     * The component source.
+     */
+    readonly source: TSource;
+    /**
+     * Indicates whether the host is connected or not.
+     */
+    readonly isConnected: boolean;
+    /**
+     * The main set of styles used for the component, independent
+     * of any behavior-specific styles.
+     */
+    mainStyles: ElementStyles | null;
+    /**
+     * Adds the behavior to the component.
+     * @param behavior - The behavior to add.
+     */
+    addBehavior(behavior: HostBehavior<TSource>): void;
+    /**
+     * Removes the behavior from the component.
+     * @param behavior - The behavior to remove.
+     * @param force - Forces removal even if this behavior was added more than once.
+     */
+    removeBehavior(behavior: HostBehavior<TSource>, force?: boolean): void;
+    /**
+     * Adds styles to this element. Providing an HTMLStyleElement will attach the element instance to the shadowRoot.
+     * @param styles - The styles to add.
+     */
+    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    /**
+     * Removes styles from this element. Providing an HTMLStyleElement will detach the element instance from the shadowRoot.
+     * @param styles - the styles to remove.
+     */
+    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+}
+
 /**
  * Transforms a template literal string into a ViewTemplate.
  * @param strings - The string fragments that are interpolated with the values.
@@ -1298,17 +1372,16 @@ export declare interface FASTGlobal {
  * other template instances, and Directive instances.
  * @public
  */
-export declare function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
+export declare const html: HTMLTemplateTag;
 
 /**
  * A directive that applies bindings.
  * @public
  */
-export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
-    binding: Binding;
-    mode: BindingMode;
-    options: any;
-    private factory;
+export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected {
+    dataBinding: Binding;
+    private data;
+    private updateTarget;
     /**
      * The unique id of the factory.
      */
@@ -1316,7 +1389,15 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
     /**
      * The structural id of the DOM node to which the created behavior will apply.
      */
-    nodeId: string;
+    targetNodeId: string;
+    /**
+     * The tagname associated with the target node.
+     */
+    targetTagName: string | null;
+    /**
+     * The policy that the created behavior must run under.
+     */
+    policy: DOMPolicy;
     /**
      * The original source aspect exactly as represented in markup.
      */
@@ -1328,14 +1409,12 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
     /**
      * The type of aspect to target.
      */
-    aspectType: Aspect;
+    aspectType: DOMAspect;
     /**
      * Creates an instance of HTMLBindingDirective.
-     * @param binding - The binding to apply.
-     * @param mode - The binding mode to use when applying the binding.
-     * @param options - The options to configure the binding with.
+     * @param dataBinding - The binding configuration to apply.
      */
-    constructor(binding: Binding, mode: BindingMode, options: any);
+    constructor(dataBinding: Binding);
     /**
      * Creates HTML to be used within a template.
      * @param add - Can be used to add  behavior factories to a template.
@@ -1343,9 +1422,16 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
     createHTML(add: AddViewBehaviorFactory): string;
     /**
      * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
      */
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+    createBehavior(): ViewBehavior;
+    /** @internal */
+    bind(controller: ViewController): void;
+    /** @internal */
+    unbind(controller: ViewController): void;
+    /** @internal */
+    handleEvent(event: Event): void;
+    /** @internal */
+    handleChange(binding: Expression, observer: ExpressionObserver): void;
 }
 
 /**
@@ -1381,6 +1467,14 @@ export declare const HTMLDirective: Readonly<{
      * @param options - Options that specify the directive's application.
      */
     define<TType extends Constructable<HTMLDirective>>(type: TType, options?: PartialHTMLDirectiveDefinition): TType;
+    /**
+     *
+     * @param directive - The directive to assign the aspect to.
+     * @param value - The value to base the aspect determination on.
+     * @remarks
+     * If a falsy value is provided, then the content aspect will be assigned.
+     */
+    assignAspect(directive: Aspected, value?: string): void;
 }>;
 
 /**
@@ -1407,29 +1501,109 @@ export declare interface HTMLDirectiveDefinition<TType extends Constructable<HTM
  */
 export declare interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
     /**
-     * Creates a view instance.
-     * @param hostBindingTarget - The host binding target for the view.
+     * Creates a view instance.
+     * @param hostBindingTarget - The host binding target for the view.
+     */
+    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+}
+
+/**
+ * Transforms a template literal string into a ViewTemplate.
+ * @param strings - The string fragments that are interpolated with the values.
+ * @param values - The values that are interpolated with the string fragments.
+ * @remarks
+ * The html helper supports interpolation of strings, numbers, binding expressions,
+ * other template instances, and Directive instances.
+ * @public
+ */
+export declare type HTMLTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]) => ViewTemplate<TSource, TParent>) & {
+    /**
+     * Transforms a template literal string into partial HTML.
+     * @param html - The HTML string fragment to interpolate.
+     * @public
      */
-    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
-}
+    partial(html: string): InlineTemplateDirective;
+};
 
 /**
  * The standard View implementation, which also implements ElementView and SyntheticView.
  * @public
  */
-export declare class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent> {
+export declare class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
     private fragment;
     private factories;
-    private targets;
+    readonly targets: ViewBehaviorTargets;
     private behaviors;
+    private unbindables;
     /**
      * The data that the view is bound to.
      */
     source: TSource | null;
+    /**
+     * Indicates whether the controller is bound.
+     */
+    isBound: boolean;
+    /**
+     * Indicates how the source's lifetime relates to the controller's lifetime.
+     */
+    readonly sourceLifetime: SourceLifetime;
     /**
      * The execution context the view is running within.
      */
-    context: ExecutionContext<TParent> | null;
+    context: ExecutionContext<TParent>;
+    /**
+     * The index of the current item within a repeat context.
+     */
+    index: number;
+    /**
+     * The length of the current collection within a repeat context.
+     */
+    length: number;
+    /**
+     * The parent data source within a nested context.
+     */
+    readonly parent: TParent;
+    /**
+     * The parent execution context when in nested context scenarios.
+     */
+    readonly parentContext: ExecutionContext<TParent>;
+    /**
+     * The current event within an event handler.
+     */
+    get event(): Event;
+    /**
+     * Indicates whether the current item within a repeat context
+     * has an even index.
+     */
+    get isEven(): boolean;
+    /**
+     * Indicates whether the current item within a repeat context
+     * has an odd index.
+     */
+    get isOdd(): boolean;
+    /**
+     * Indicates whether the current item within a repeat context
+     * is the first item in the collection.
+     */
+    get isFirst(): boolean;
+    /**
+     * Indicates whether the current item within a repeat context
+     * is somewhere in the middle of the collection.
+     */
+    get isInMiddle(): boolean;
+    /**
+     * Indicates whether the current item within a repeat context
+     * is the last item in the collection.
+     */
+    get isLast(): boolean;
+    /**
+     * Returns the typed event detail of a custom event.
+     */
+    eventDetail<TDetail>(): TDetail;
+    /**
+     * Returns the typed event target of the event.
+     */
+    eventTarget<TTarget extends EventTarget>(): TTarget;
     /**
      * The first DOM node in the range of nodes that make up the view.
      */
@@ -1443,7 +1617,7 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      * @param fragment - The html fragment that contains the nodes for this view.
      * @param behaviors - The behaviors to be applied to this view.
      */
-    constructor(fragment: DocumentFragment, factories: ReadonlyArray<ViewBehaviorFactory>, targets: ViewBehaviorTargets);
+    constructor(fragment: DocumentFragment, factories: ReadonlyArray<CompiledViewBehaviorFactory>, targets: ViewBehaviorTargets);
     /**
      * Appends the view's DOM nodes to the referenced node.
      * @param node - The parent node to append the view's DOM nodes to.
@@ -1464,16 +1638,25 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      * Once a view has been disposed, it cannot be inserted or bound again.
      */
     dispose(): void;
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): any;
+    }): void;
     /**
      * Binds a view's behaviors to its binding source.
      * @param source - The binding source for the view's binding behaviors.
      * @param context - The execution context to run the behaviors within.
      */
-    bind(source: TSource, context: ExecutionContext<TParent>): void;
+    bind(source: TSource, context?: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source.
      */
     unbind(): void;
+    /**
+     * Opts out of JSON stringification.
+     * @internal
+     */
+    toJSON: () => undefined;
+    private evaluateUnbindables;
     /**
      * Efficiently disposes of a contiguous range of synthetic view instances.
      * @param views - A contiguous range of views to be disposed.
@@ -1481,6 +1664,29 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
     static disposeContiguousBatch(views: SyntheticView[]): void;
 }
 
+/**
+ * Inlines a template into another template.
+ * @public
+ */
+export declare class InlineTemplateDirective implements HTMLDirective {
+    private html;
+    private factories;
+    /**
+     * An empty template partial.
+     */
+    static readonly empty: InlineTemplateDirective;
+    /**
+     * Creates an instance of InlineTemplateDirective.
+     * @param template - The template to inline.
+     */
+    constructor(html: string, factories?: Record<string, ViewBehaviorFactory>);
+    /**
+     * Creates HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
+     */
+    createHTML(add: AddViewBehaviorFactory): string;
+}
+
 /**
  * Observes array lengths.
  * @public
@@ -1500,6 +1706,15 @@ export declare interface LengthObserver extends Subscriber {
  */
 export declare function lengthOf<T>(array: readonly T[]): number;
 
+/**
+ * Creates an event listener binding.
+ * @param expression - The binding to invoke when the event is raised.
+ * @param options - Event listener options.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function listener<T = any>(expression: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
+
 /**
  * Common APIs related to markup generation.
  * @public
@@ -1531,14 +1746,6 @@ export declare const Markup: Readonly<{
     comment: (id: string) => string;
 }>;
 
-/**
- * Reverses all readonly members, making them mutable.
- * @internal
- */
-export declare type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-
 /**
  * Options for configuring node observation behavior.
  * @public
@@ -1565,21 +1772,31 @@ export declare interface NodeBehaviorOptions<T = any> {
  * Internally used by the SlottedDirective and the ChildrenDirective.
  */
 export declare abstract class NodeObservationDirective<T extends NodeBehaviorOptions> extends StatelessAttachedAttributeDirective<T> {
-    private sourceProperty;
+    private _id;
+    private _controllerProperty;
+    /**
+     * The unique id of the factory.
+     */
+    get id(): string;
+    set id(value: string);
+    /**
+     * The structural id of the DOM node to which the created behavior will apply.
+     */
+    targetNodeId: string;
     /**
      * Bind this behavior to the source.
      * @param source - The source to bind to.
      * @param context - The execution context that the binding is operating within.
      * @param targets - The targets that behaviors in a view can attach to.
      */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    bind(controller: ViewController): void;
     /**
      * Unbinds this behavior from the source.
      * @param source - The source to unbind from.
      * @param context - The execution context that the binding is operating within.
      * @param targets - The targets that behaviors in a view can attach to.
      */
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    unbind(controller: ViewController): void;
     /**
      * Gets the data source for the target.
      * @param target - The target to get the source for.
@@ -1617,6 +1834,14 @@ export declare abstract class NodeObservationDirective<T extends NodeBehaviorOpt
     protected abstract getNodes(target: any): Node[];
 }
 
+/**
+ * Normalizes the input value into a binding.
+ * @param value - The value to create the default binding for.
+ * @returns A binding configuration for the provided value.
+ * @public
+ */
+export declare function normalizeBinding<TSource = any, TReturn = any, TParent = any>(value: Expression<TSource, TReturn, TParent> | Binding<TSource, TReturn, TParent> | {}): Binding<TSource, TReturn, TParent>;
+
 /**
  * Provides change notifications for an observed subject.
  * @public
@@ -1652,6 +1877,12 @@ export declare interface Notifier {
     unsubscribe(subscriber: Subscriber, propertyToUnwatch?: any): void;
 }
 
+/**
+ * A {@link ValueConverter} that converts to and from `boolean` values. `null`, `undefined`, `""`, and `void` values are converted to `null`.
+ * @public
+ */
+export declare const nullableBooleanConverter: ValueConverter;
+
 /**
  * A {@link ValueConverter} that converts to and from `number` values.
  * @remarks
@@ -1707,19 +1938,19 @@ export declare const Observable: Readonly<{
      */
     getAccessors: (target: {}) => Accessor[];
     /**
-     * Creates a {@link BindingObserver} that can watch the
-     * provided {@link Binding} for changes.
-     * @param binding - The binding to observe.
+     * Creates a {@link ExpressionNotifier} that can watch the
+     * provided {@link Expression} for changes.
+     * @param expression - The binding to observe.
      * @param initialSubscriber - An initial subscriber to changes in the binding value.
      * @param isVolatileBinding - Indicates whether the binding's dependency list must be re-evaluated on every value evaluation.
      */
-    binding<TSource = any, TReturn = any>(binding: Binding<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): BindingObserver<TSource, TReturn, any>;
+    binding<TSource = any, TReturn = any>(expression: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn, any>;
     /**
      * Determines whether a binding expression is volatile and needs to have its dependency list re-evaluated
      * on every evaluation of the value.
-     * @param binding - The binding to inspect.
+     * @param expression - The binding to inspect.
      */
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(binding: Binding<TSource_1, TReturn_1, any>): boolean;
+    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(expression: Expression<TSource_1, TReturn_1, any>): boolean;
 }>;
 
 /**
@@ -1746,30 +1977,13 @@ export declare interface ObservationRecord {
 }
 
 /**
- * The default onChange binding configuration.
- * @public
- */
-export declare const onChange: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
-
-/**
- * The default onTime binding configuration.
- * @public
- */
-export declare const oneTime: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
-
-/**
- * A binding behavior for one-time bindings.
+ * Creates a one time binding
+ * @param expression - The binding to refresh when signaled.
+ * @param policy - The security policy to associate with th binding.
+ * @returns A binding configuration.
  * @public
  */
-export declare class OneTimeBinding extends UpdateBinding {
-    /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
+export declare function oneTime<T = any>(expression: Expression<T>, policy?: DOMPolicy): Binding<T>;
 
 /**
  * Common APIs related to content parsing.
@@ -1810,12 +2024,21 @@ export declare interface PartialFASTElementDefinition {
     readonly attributes?: (AttributeConfiguration | string)[];
     /**
      * Options controlling the creation of the custom element's shadow DOM.
+     * @remarks
+     * If not provided, defaults to an open shadow root. Provide null
+     * to render to the associated template to the light DOM instead.
      */
-    readonly shadowOptions?: Partial<ShadowRootInit> | null;
+    readonly shadowOptions?: Partial<ShadowRootOptions> | null;
     /**
      * Options controlling how the custom element is defined with the platform.
      */
     readonly elementOptions?: ElementDefinitionOptions;
+    /**
+     * The registry to register this component in by default.
+     * @remarks
+     * If not provided, defaults to the global registry.
+     */
+    readonly registry?: CustomElementRegistry;
 }
 
 /**
@@ -1871,7 +2094,7 @@ export declare class PropertyChangeNotifier implements Notifier {
  * @param propertyName - The name of the property to assign the reference to.
  * @public
  */
-export declare const ref: <T = any>(propertyName: keyof T & string) => CaptureType<T>;
+export declare const ref: <TSource = any, TParent = any>(propertyName: keyof TSource & string) => CaptureType<TSource, TParent>;
 
 /**
  * The runtime behavior for template references.
@@ -1879,69 +2102,61 @@ export declare const ref: <T = any>(propertyName: keyof T & string) => CaptureTy
  */
 export declare class RefDirective extends StatelessAttachedAttributeDirective<string> {
     /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
+     * The structural id of the DOM node to which the created behavior will apply.
      */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    targetNodeId: string;
     /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
+     * Bind this behavior.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
      */
-    unbind(): void;
+    bind(controller: ViewController): void;
 }
 
 declare const reflectMode = "reflect";
 
 /**
  * A directive that enables list rendering.
- * @param itemsBinding - The array to render.
- * @param templateOrTemplateBinding - The template or a template binding used obtain a template
+ * @param items - The array to render.
+ * @param template - The template or a template binding used obtain a template
  * to render for each item in the array.
  * @param options - Options used to turn on special repeat features.
  * @public
  */
-export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ViewTemplate | Binding<TSource, ViewTemplate>, options?: RepeatOptions): CaptureType<TSource>;
+export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>, TParent = any>(items: Expression<TSource, TArray, TParent> | Binding<TSource, TArray, TParent> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate<any, TSource>> | Binding<TSource, ViewTemplate<any, TSource>> | ViewTemplate<any, TSource>, options?: RepeatOptions): CaptureType<TSource, TParent>;
 
 /**
  * A behavior that renders a template for each item in an array.
  * @public
  */
-export declare class RepeatBehavior<TSource = any> implements Behavior, Subscriber {
+export declare class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
+    private directive;
     private location;
-    private itemsBinding;
-    private templateBinding;
-    private options;
-    private source;
-    private views;
+    private controller;
     private template;
     private templateBindingObserver;
     private items;
     private itemsObserver;
     private itemsBindingObserver;
-    private context;
-    private childContext;
     private bindView;
+    /** @internal */
+    views: SyntheticView[];
     /**
      * Creates an instance of RepeatBehavior.
      * @param location - The location in the DOM to render the repeat.
-     * @param itemsBinding - The array to render.
+     * @param dataBinding - The array to render.
      * @param isItemsBindingVolatile - Indicates whether the items binding has volatile dependencies.
      * @param templateBinding - The template to render for each item.
      * @param isTemplateBindingVolatile - Indicates whether the template binding has volatile dependencies.
      * @param options - Options used to turn on special repeat features.
      */
-    constructor(location: Node, itemsBinding: Binding<TSource, any[]>, isItemsBindingVolatile: boolean, templateBinding: Binding<TSource, SyntheticViewTemplate>, isTemplateBindingVolatile: boolean, options: RepeatOptions);
+    constructor(directive: RepeatDirective);
     /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
+     * Bind this behavior.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
      */
-    bind(source: TSource, context: ExecutionContext): void;
+    bind(controller: ViewController): void;
     /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
+     * Unbinds this behavior.
      */
     unbind(): void;
     /**
@@ -1949,7 +2164,7 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
      * @param source - The source of the change.
      * @param args - The details about what was changed.
      */
-    handleChange(source: any, args: Splice[]): void;
+    handleChange(source: any, args: Splice[] | ExpressionObserver): void;
     private observeItems;
     private updateViews;
     private refreshAllViews;
@@ -1961,19 +2176,13 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
  * @public
  */
 export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
-    readonly itemsBinding: Binding;
+    readonly dataBinding: Binding<TSource>;
     readonly templateBinding: Binding<TSource, SyntheticViewTemplate>;
     readonly options: RepeatOptions;
-    private isItemsBindingVolatile;
-    private isTemplateBindingVolatile;
-    /**
-     * The unique id of the factory.
-     */
-    id: string;
     /**
      * The structural id of the DOM node to which the created behavior will apply.
      */
-    nodeId: string;
+    targetNodeId: string;
     /**
      * Creates a placeholder string based on the directive's index within the template.
      * @param index - The index of the directive within the template.
@@ -1981,16 +2190,16 @@ export declare class RepeatDirective<TSource = any> implements HTMLDirective, Vi
     createHTML(add: AddViewBehaviorFactory): string;
     /**
      * Creates an instance of RepeatDirective.
-     * @param itemsBinding - The binding that provides the array to render.
+     * @param dataBinding - The binding that provides the array to render.
      * @param templateBinding - The template binding used to obtain a template to render for each item in the array.
      * @param options - Options used to turn on special repeat features.
      */
-    constructor(itemsBinding: Binding, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
     /**
      * Creates a behavior for the provided target node.
      * @param target - The node instance to create the behavior for.
      */
-    createBehavior(targets: ViewBehaviorTargets): RepeatBehavior<TSource>;
+    createBehavior(): RepeatBehavior<TSource>;
 }
 
 /**
@@ -2008,13 +2217,26 @@ export declare interface RepeatOptions {
     recycle?: boolean;
 }
 
+/**
+ * Shadow root initialization options.
+ * @public
+ */
+export declare interface ShadowRootOptions extends ShadowRootInit {
+    /**
+     * A registry that provides the custom elements visible
+     * from within this shadow root.
+     * @beta
+     */
+    registry?: CustomElementRegistry;
+}
+
 /**
  * A directive that observes the `assignedNodes()` of a slot and updates a property
  * whenever they change.
  * @param propertyOrOptions - The options used to configure slotted node observation.
  * @public
  */
-export declare function slotted<T = any>(propertyOrOptions: (keyof T & string) | SlottedDirectiveOptions<keyof T & string>): CaptureType<T>;
+export declare function slotted<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | SlottedDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
 
 /**
  * The runtime behavior for slotted node observation.
@@ -2047,6 +2269,28 @@ export declare class SlottedDirective extends NodeObservationDirective<SlottedDi
 export declare interface SlottedDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, AssignedNodesOptions {
 }
 
+/**
+ * Describes how the source's lifetime relates to its controller's lifetime.
+ * @public
+ */
+export declare const SourceLifetime: Readonly<{
+    /**
+     * The source to controller lifetime relationship is unknown.
+     */
+    readonly unknown: undefined;
+    /**
+     * The source and controller lifetimes are coupled to one another.
+     * They can/will be GC'd together.
+     */
+    readonly coupled: 1;
+}>;
+
+/**
+ * Describes how the source's lifetime relates to its controller's lifetime.
+ * @public
+ */
+export declare type SourceLifetime = typeof SourceLifetime[keyof typeof SourceLifetime];
+
 /**
  * A splice map is a representation of how a previous array of items
  * was transformed into a new array of items. Conceptually it is a list of
@@ -2203,26 +2447,18 @@ export declare type SpliceStrategySupport = typeof SpliceStrategySupport[keyof t
  * A base class used for attribute directives that don't need internal state.
  * @public
  */
-export declare abstract class StatelessAttachedAttributeDirective<T> implements HTMLDirective, ViewBehaviorFactory, ViewBehavior {
-    protected options: T;
+export declare abstract class StatelessAttachedAttributeDirective<TOptions> implements HTMLDirective, ViewBehaviorFactory, ViewBehavior {
+    protected options: TOptions;
     /**
-     * The unique id of the factory.
-     */
-    id: string;
-    /**
-     * The structural id of the DOM node to which the created behavior will apply.
+     * Opts out of JSON stringification.
+     * @internal
      */
-    nodeId: string;
+    toJSON: () => undefined;
     /**
      * Creates an instance of RefDirective.
      * @param options - The options to use in configuring the directive.
      */
-    constructor(options: T);
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+    constructor(options: TOptions);
     /**
      * Creates a placeholder string based on the directive's index within the template.
      * @param index - The index of the directive within the template.
@@ -2231,17 +2467,15 @@ export declare abstract class StatelessAttachedAttributeDirective<T> implements
      */
     createHTML(add: AddViewBehaviorFactory): string;
     /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
      */
-    abstract bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    createBehavior(): ViewBehavior;
     /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
+     * Bind this behavior.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
      */
-    abstract unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    abstract bind(controller: ViewController): void;
 }
 
 /**
@@ -2266,7 +2500,7 @@ export declare interface StyleStrategy {
  * A node that can be targeted by styles.
  * @public
  */
-export declare interface StyleTarget {
+export declare interface StyleTarget extends Pick<Node, "getRootNode"> {
     /**
      * Stylesheets to be adopted by the node.
      */
@@ -2398,26 +2632,17 @@ export declare interface SyntheticViewTemplate<TSource = any, TParent = any> {
      * Creates a SyntheticView instance based on this template definition.
      */
     create(): SyntheticView<TSource, TParent>;
+    /**
+     * Returns a directive that can inline the template.
+     */
+    inline(): CaptureType<TSource, TParent>;
 }
 
 /**
  * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export declare type TemplateValue<TSource, TParent = any> = Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource>;
-
-/**
- * Enables working with trusted types.
- * @public
- */
-export declare type TrustedTypes = {
-    /**
-     * Creates a trusted types policy.
-     * @param name - The policy name.
-     * @param rules - The policy rules implementation.
-     */
-    createPolicy(name: string, rules: TrustedTypesPolicy): TrustedTypesPolicy;
-};
+export declare type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
 
 /**
  * A policy for use with the standard trustedTypes platform API.
@@ -2449,40 +2674,6 @@ export declare interface TypeRegistry<TDefinition extends TypeDefinition> {
     getForInstance(object: any): TDefinition | undefined;
 }
 
-/**
- * A base binding behavior for DOM updates.
- * @public
- */
-export declare class UpdateBinding implements ViewBehavior {
-    readonly directive: HTMLBindingDirective;
-    protected updateTarget: UpdateTarget;
-    /**
-     * Creates an instance of UpdateBinding.
-     * @param directive - The directive that has the configuration for this behavior.
-     * @param updateTarget - The function used to update the target with the latest value.
-     */
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
-    /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
-}
-
 /**
  * A work queue used to synchronize writes to the DOM.
  * @public
@@ -2524,29 +2715,6 @@ export declare interface UpdateQueue {
  */
 export declare const Updates: UpdateQueue;
 
-/**
- * A target update function.
- * @param this - The "this" context for the update.
- * @param target - The node that is targeted by the update.
- * @param aspect - The aspect of the node that is being targeted.
- * @param value - The value to assign to the aspect.
- * @param source - The source object that the value was derived from.
- * @param context - The execution context that the binding is being run under.
- * @public
- */
-export declare type UpdateTarget = (this: UpdateTargetThis, target: Node, aspect: string, value: any, source: any, context: ExecutionContext) => void;
-
-/**
- * The "this" context for an update target function.
- * @public
- */
-export declare interface UpdateTargetThis {
-    /**
-     * The directive configuration for the update.
-     */
-    directive: HTMLBindingDirective;
-}
-
 /**
  * Represents objects that can convert values to and from
  * view or model representations.
@@ -2573,7 +2741,7 @@ export declare interface View<TSource = any, TParent = any> extends Disposable {
     /**
      * The execution context the view is running within.
      */
-    readonly context: ExecutionContext<TParent> | null;
+    readonly context: ExecutionContext<TParent>;
     /**
      * The data that the view is bound to.
      */
@@ -2581,9 +2749,8 @@ export declare interface View<TSource = any, TParent = any> extends Disposable {
     /**
      * Binds a view's behaviors to its binding source.
      * @param source - The binding source for the view's binding behaviors.
-     * @param context - The execution context to run the view within.
      */
-    bind(source: TSource, context: ExecutionContext<TParent>): void;
+    bind(source: TSource, context?: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source and context.
      */
@@ -2596,23 +2763,14 @@ export declare interface View<TSource = any, TParent = any> extends Disposable {
  */
 export declare interface ViewBehavior<TSource = any, TParent = any> {
     /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    bind(source: TSource, context: ExecutionContext<TParent>, targets: ViewBehaviorTargets): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
+     * Bind this behavior.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
      */
-    unbind(source: TSource, context: ExecutionContext<TParent>, targets: ViewBehaviorTargets): void;
+    bind(controller: ViewController<TSource, TParent>): void;
 }
 
 /**
- * A factory that can create a {@link Behavior} associated with a particular
+ * A factory that can create a {@link ViewBehavior} associated with a particular
  * location within a DOM fragment.
  * @public
  */
@@ -2620,16 +2778,23 @@ export declare interface ViewBehaviorFactory {
     /**
      * The unique id of the factory.
      */
-    id: string;
+    id?: string;
     /**
      * The structural id of the DOM node to which the created behavior will apply.
      */
-    nodeId: string;
+    targetNodeId?: string;
+    /**
+     * The tag name of the DOM node to which the created behavior will apply.
+     */
+    targetTagName?: string | null;
+    /**
+     * The policy that the created behavior must run under.
+     */
+    policy?: DOMPolicy;
     /**
      * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
      */
-    createBehavior(targets: ViewBehaviorTargets): Behavior | ViewBehavior;
+    createBehavior(): ViewBehavior;
 }
 
 /**
@@ -2640,11 +2805,23 @@ export declare type ViewBehaviorTargets = {
     [id: string]: Node;
 };
 
+/**
+ * Controls the lifecycle of a view and provides relevant context.
+ * @public
+ */
+export declare interface ViewController<TSource = any, TParent = any> extends ExpressionController<TSource, TParent> {
+    /**
+     * The parts of the view that are targeted by view behaviors.
+     */
+    readonly targets: ViewBehaviorTargets;
+}
+
 /**
  * A template capable of creating HTMLView instances or rendering directly to DOM.
  * @public
  */
 export declare class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
+    private policy?;
     private result;
     /**
      * The html representing what this template will
@@ -2659,13 +2836,27 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * Creates an instance of ViewTemplate.
      * @param html - The html representing what this template will instantiate, including placeholders for directives.
      * @param factories - The directives that will be connected to placeholders in the html.
+     * @param policy - The security policy to use when compiling this template.
      */
-    constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
+    constructor(html: string | HTMLTemplateElement, factories?: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy | undefined);
     /**
      * Creates an HTMLView instance based on this template definition.
      * @param hostBindingTarget - The element that host behaviors will be bound to.
      */
     create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    /**
+     * Returns a directive that can inline the template.
+     */
+    inline(): CaptureType<TSource, TParent>;
+    /**
+     * Sets the DOMPolicy for this template.
+     * @param policy - The policy to associated with this template.
+     * @returns The modified template instance.
+     * @remarks
+     * The DOMPolicy can only be set once for a template and cannot be
+     * set after the template is compiled.
+     */
+    withPolicy(policy: DOMPolicy): this;
     /**
      * Creates an HTMLView from this template, binds it to the source, and then appends it to the host.
      * @param source - The data source to bind the template to.
@@ -2673,7 +2864,26 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * @param hostBindingTarget - An HTML element to target the host bindings at if different from the
      * host that the template is being attached to.
      */
-    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: ExecutionContext): HTMLView<TSource, TParent>;
+    render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    /**
+     * Opts out of JSON stringification.
+     * @internal
+     */
+    toJSON: () => undefined;
+    /**
+     * Creates a template based on a set of static strings and dynamic values.
+     * @param strings - The static strings to create the template with.
+     * @param values - The dynamic values to create the template with.
+     * @param policy - The DOMPolicy to associated with the template.
+     * @returns A ViewTemplate.
+     * @remarks
+     * This API should not be used directly under normal circumstances because constructing
+     * a template in this way, if not done properly, can open up the application to XSS
+     * attacks. When using this API, provide a strong DOMPolicy that can properly sanitize
+     * and also be sure to manually sanitize all static strings particularly if they can
+     * come from user input.
+     */
+    static create<TSource = any, TParent = any>(strings: string[], values: TemplateValue<TSource, TParent>[], policy?: DOMPolicy): ViewTemplate<TSource, TParent>;
 }
 
 /**
@@ -2687,11 +2897,11 @@ export declare function volatile(target: {}, name: string | Accessor, descriptor
 
 /**
  * A directive that enables basic conditional rendering in a template.
- * @param binding - The condition to test for rendering.
+ * @param condition - The condition to test for rendering.
  * @param templateOrTemplateBinding - The template or a binding that gets
  * the template to render when the condition is true.
  * @public
  */
-export declare function when<TSource = any, TReturn = any>(binding: Binding<TSource, TReturn>, templateOrTemplateBinding: SyntheticViewTemplate | Binding<TSource, SyntheticViewTemplate>): CaptureType<TSource>;
+export declare function when<TSource = any, TReturn = any, TParent = any>(condition: Expression<TSource, TReturn, TParent> | boolean, templateOrTemplateBinding: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>): CaptureType<TSource, TParent>;
 
 export { }