@microsoft/fast-element 2.0.0-beta.8 → 2.0.0

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

@@ -32,20 +32,6 @@ export declare type AddBehavior = (behavior: HostBehavior<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,55 +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.
-     * @remarks
-     * If a falsy value is provided, then the content aspect will be assigned.
-     */
-    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
@@ -155,7 +92,7 @@ export declare interface Aspected {
     /**
      * The type of aspect to target.
      */
-    aspectType: Aspect;
+    aspectType: DOMAspect;
     /**
      * A binding if one is associated with the aspect.
      */
@@ -277,15 +214,6 @@ export declare class AttributeDefinition implements Accessor {
  */
 export declare type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
 
-/**
- * Creates an standard binding.
- * @param binding - The binding to refresh when changed.
- * @param isVolatile - Indicates whether the binding is volatile or not.
- * @returns A binding configuration.
- * @public
- */
-export declare function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
-
 /**
  * Captures a binding expression along with related information and capabilities.
  *
@@ -293,6 +221,7 @@ export declare function bind<T = any>(binding: Expression<T>, isVolatile?: boole
  */
 export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
     evaluate: Expression<TSource, TReturn, TParent>;
+    policy?: DOMPolicy | undefined;
     isVolatile: boolean;
     /**
      * Options associated with the binding.
@@ -301,15 +230,36 @@ export declare abstract class Binding<TSource = any, TReturn = any, TParent = an
     /**
      * 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.
      */
-    constructor(evaluate: Expression<TSource, TReturn, TParent>, isVolatile?: boolean);
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy | undefined, isVolatile?: boolean);
     /**
      * 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.
+     * @param directive - The Binding directive to create the observer for.
+     */
+    abstract createObserver(subscriber: Subscriber, directive: BindingDirective): ExpressionObserver<TSource, TReturn, TParent>;
+}
+
+/**
+ * The directive from which a binding originates.
+ *
+ * @public
+ */
+export declare interface BindingDirective {
+    /**
+     * The binding.
+     */
+    readonly dataBinding: Binding;
+    /**
+     * The evaluated target aspect.
      */
-    abstract createObserver(directive: HTMLDirective, subscriber: Subscriber): ExpressionObserver<TSource, TReturn, TParent>;
+    readonly targetAspect?: string;
+    /**
+     * The type of aspect to target.
+     */
+    readonly aspectType?: DOMAspect;
 }
 
 /**
@@ -388,6 +338,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.
@@ -401,33 +362,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.
@@ -438,9 +402,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;
 };
 
 /**
@@ -454,7 +419,7 @@ declare function compose<TType extends Constructable<HTMLElement> = Constructabl
 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
  */
@@ -496,7 +461,7 @@ export declare interface ContentView {
      * @param source - The binding source for the view's binding behaviors.
      * @param context - The execution context to run the view within.
      */
-    bind(source: any): void;
+    bind(source: any, context?: ExecutionContext): void;
     /**
      * Unbinds a view's behaviors from its binding source and context.
      */
@@ -513,19 +478,6 @@ export declare interface ContentView {
     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
- */
-export declare function createTypeRegistry<TDefinition extends TypeDefinition>(): TypeRegistry<TDefinition>;
-
 /**
  * Transforms a template literal string into styles.
  * @param strings - The string fragments that are interpolated with the values.
@@ -536,6 +488,61 @@ export declare function createTypeRegistry<TDefinition extends TypeDefinition>()
  */
 export declare const css: CSSTemplateTag;
 
+/**
+ * Enables bindings in CSS.
+ *
+ * @public
+ */
+export declare class CSSBindingDirective implements HostBehavior, Subscriber, CSSDirective, BindingDirective {
+    readonly dataBinding: Binding;
+    readonly targetAspect: string;
+    /**
+     * Creates an instance of CSSBindingDirective.
+     * @param dataBinding - The binding to use in CSS.
+     * @param targetAspect - The CSS property to target.
+     */
+    constructor(dataBinding: Binding, targetAspect: string);
+    /**
+     * Creates a CSS fragment to interpolate into the CSS document.
+     * @returns - the string to interpolate into CSS
+     */
+    createCSS(add: AddBehavior): ComposableStyles;
+    /**
+     * Executed when this behavior is attached to a controller.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    addedCallback(controller: HostController<HTMLElement & {
+        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
+    }>): void;
+    /**
+     * Executed when this behavior's host is connected.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    connectedCallback(controller: HostController<HTMLElement & {
+        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
+    }>): void;
+    /**
+     * Executed when this behavior is detached from a controller.
+     * @param controller - Controls the behavior lifecycle.
+     */
+    removedCallback(controller: HostController<HTMLElement & {
+        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
+    }>): void;
+    /**
+     * Called when a subject this instance has subscribed to changes.
+     * @param subject - The subject of the change.
+     * @param args - The event args detailing the change that occurred.
+     *
+     * @internal
+     */
+    handleChange(_: any, observer: ExpressionObserver): void;
+}
+
+declare type CSSBindingEntry = {
+    observer: ExpressionObserver;
+    controller: HostController;
+};
+
 /**
  * Directive for use in {@link css}.
  *
@@ -589,12 +596,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.
@@ -604,16 +605,22 @@ export declare const cssPartial: (strings: TemplateStringsArray, ...values: (Com
  * Use the .partial method to create partial CSS fragments.
  * @public
  */
-export declare type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => ElementStyles) & {
+export declare type CSSTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]) => ElementStyles) & {
     /**
      * Transforms a template literal string into partial CSS.
      * @param strings - The string fragments that are interpolated with the values.
      * @param values - The values that are interpolated with the string fragments.
      * @public
      */
-    partial(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): CSSDirective;
+    partial<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]): CSSDirective;
 };
 
+/**
+ * Represents the types of values that can be interpolated into a template.
+ * @public
+ */
+export declare type CSSValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | ComposableStyles | CSSDirective;
+
 /**
  * Decorator: Defines a platform custom element based on `FASTElement`.
  * @param nameOrDef - The name of the element to define or a definition object
@@ -628,6 +635,62 @@ export declare function customElement(nameOrDef: string | PartialFASTElementDefi
  */
 export declare type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
 
+declare class DefaultExecutionContext<TParent> implements 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;
+}
+
 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;
@@ -649,20 +712,17 @@ export declare interface Disposable {
  */
 export declare const DOM: Readonly<{
     /**
-     * @deprecated
-     * Use Updates.enqueue().
+     * Gets the dom policy used by the templating system.
      */
-    queueUpdate: (callable: Callable) => void;
+    readonly policy: DOMPolicy;
     /**
-     * @deprecated
-     * Use Updates.next()
-     */
-    nextUpdate: () => Promise<void>;
-    /**
-     * @deprecated
-     * Use Updates.process()
+     * 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.
      */
-    processUpdates: () => void;
+    setPolicy(value: DOMPolicy): void;
     /**
      * Sets an attribute value on an element.
      * @param element - The element to set the attribute value on.
@@ -684,17 +744,95 @@ export declare const DOM: Readonly<{
     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;
+    protected needsInitialization: boolean;
     private hasExistingShadowRoot;
     private _template;
-    private _isConnected;
-    private behaviors;
+    protected stage: Stages;
+    /**
+     * A guard against connecting behaviors multiple times
+     * during connect in scenarios where a behavior adds
+     * another behavior during it's connectedCallback
+     */
+    private guardBehaviorConnection;
+    protected behaviors: Map<HostBehavior<TElement>, number> | null;
+    /**
+     * Tracks whether behaviors are connected so that
+     * behaviors cant be connected multiple times
+     */
+    private behaviorsConnected;
     private _mainStyles;
     /**
      * This allows Observable.getNotifier(...) to return the Controller
@@ -725,7 +863,18 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * connected to the document.
      */
     get isConnected(): boolean;
-    private setIsConnected;
+    /**
+     * The context the expression is evaluated against.
+     */
+    get context(): ExecutionContext;
+    /**
+     * Indicates whether the controller is bound.
+     */
+    get isBound(): boolean;
+    /**
+     * Indicates how the source's lifetime relates to the controller's lifetime.
+     */
+    get sourceLifetime(): SourceLifetime | undefined;
     /**
      * Gets/sets the template used to render the component.
      * @remarks
@@ -747,6 +896,13 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * @internal
      */
     constructor(element: TElement, definition: FASTElementDefinition);
+    /**
+     * Registers an unbind handler with the controller.
+     * @param behavior - An object to call when the controller unbinds.
+     */
+    onUnbind(behavior: {
+        unbind(controller: ExpressionController<TElement>): any;
+    }): void;
     /**
      * Adds the behavior to the component.
      * @param behavior - The behavior to add.
@@ -772,6 +928,9 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * Runs connected lifecycle behavior on the associated element.
      */
     connect(): void;
+    protected bindObservables(): void;
+    protected connectBehaviors(): void;
+    protected disconnectBehaviors(): void;
     /**
      * Runs disconnected lifecycle behavior on the associated element.
      */
@@ -792,8 +951,7 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * Only emits events if connected.
      */
     emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
-    private finishInitialization;
-    private renderTemplate;
+    protected renderTemplate(template: ElementViewTemplate | null | undefined): void;
     /**
      * Locates or creates a controller for the specified element.
      * @param element - The element to return the controller for.
@@ -803,6 +961,20 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * decorator or a call to `FASTElement.define`.
      */
     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;
 }
 
 /**
@@ -878,6 +1050,17 @@ export declare class ElementStyles {
  * @public
  */
 export declare interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
+    /**
+     * Indicates how the source's lifetime relates to the controller's lifetime.
+     */
+    readonly sourceLifetime?: SourceLifetime;
+    /**
+     * Registers an unbind handler with the controller.
+     * @param behavior - An object to call when the controller unbinds.
+     */
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): any;
+    }): void;
     /**
      * Appends the view's DOM nodes to the referenced node.
      * @param node - The parent node to append the view's DOM nodes to.
@@ -1074,7 +1257,7 @@ export declare interface ExpressionObserver<TSource = any, TReturn = any, TParen
 
 /**
  * The FAST global.
- * @internal
+ * @public
  */
 export declare const FAST: FASTGlobal;
 
@@ -1200,6 +1383,12 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
      * 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.
@@ -1214,7 +1403,7 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
 
 /**
  * The FAST global.
- * @internal
+ * @public
  */
 export declare interface FASTGlobal {
     /**
@@ -1284,11 +1473,7 @@ export declare interface HostBehavior<TSource = any> {
  * associated with a component host.
  * @public
  */
-export declare interface HostController<TSource = any> {
-    /**
-     * The component source.
-     */
-    readonly source: TSource;
+export declare interface HostController<TSource = any> extends ExpressionController<TSource> {
     /**
      * Indicates whether the host is connected or not.
      */
@@ -1330,13 +1515,13 @@ export declare interface HostController<TSource = any> {
  * 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, ViewBehavior, Aspected {
+export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected, BindingDirective {
     dataBinding: Binding;
     private data;
     private updateTarget;
@@ -1347,7 +1532,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.
      */
@@ -1359,7 +1552,7 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
     /**
      * The type of aspect to target.
      */
-    aspectType: Aspect;
+    aspectType: DOMAspect;
     /**
      * Creates an instance of HTMLBindingDirective.
      * @param dataBinding - The binding configuration to apply.
@@ -1375,13 +1568,7 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
      */
     createBehavior(): ViewBehavior;
     /** @internal */
-    bindDefault(controller: ViewController): void;
-    /** @internal */
-    bind: (controller: ViewController) => void;
-    /** @internal */
-    bindContent(controller: ViewController): void;
-    /** @internal */
-    bindEvent(controller: ViewController): void;
+    bind(controller: ViewController): void;
     /** @internal */
     unbind(controller: ViewController): void;
     /** @internal */
@@ -1423,6 +1610,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;
 }>;
 
 /**
@@ -1449,17 +1644,36 @@ 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>;
+    readonly factories: CompiledViewBehaviorFactory[];
+}
+
+/**
+ * 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>, ExecutionContext<TParent> {
+export declare class HTMLView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
     private fragment;
     private factories;
     readonly targets: ViewBehaviorTargets;
@@ -1469,65 +1683,18 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      * The data that the view is bound to.
      */
     source: TSource | null;
-    isBound: boolean;
-    selfContained: boolean;
-    /**
-     * The execution context the view is running within.
-     */
-    get 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.
+     * Indicates whether the controller is bound.
      */
-    get isLast(): boolean;
+    isBound: boolean;
     /**
-     * Returns the typed event detail of a custom event.
+     * Indicates how the source's lifetime relates to the controller's lifetime.
      */
-    eventDetail<TDetail>(): TDetail;
+    readonly sourceLifetime: SourceLifetime;
     /**
-     * Returns the typed event target of the event.
+     * The execution context the view is running within.
      */
-    eventTarget<TTarget extends EventTarget>(): TTarget;
+    context: ExecutionContext<TParent>;
     /**
      * The first DOM node in the range of nodes that make up the view.
      */
@@ -1541,7 +1708,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.
@@ -1563,14 +1730,14 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
      */
     dispose(): void;
     onUnbind(behavior: {
-        unbind(controller: ViewController<TSource, TParent>): any;
+        unbind(controller: ViewController<TSource, TParent>): void;
     }): 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): void;
+    bind(source: TSource, context?: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source.
      */
@@ -1583,6 +1750,104 @@ export declare class HTMLView<TSource = any, TParent = any> implements ElementVi
     static disposeContiguousBatch(views: SyntheticView[]): void;
 }
 
+/**
+ * @internal
+ */
+declare const Hydratable: unique symbol;
+
+/**
+ * An ElementController capable of hydrating FAST elements from
+ * Declarative Shadow DOM.
+ *
+ * @beta
+ */
+export declare class HydratableElementController<TElement extends HTMLElement = HTMLElement> extends ElementController<TElement> {
+    /**
+     * Controls whether the controller will hydrate during the connect() method.
+     * Initialized during the first connect() call to true when the `needs-hydration`
+     * attribute is present on the element.
+     */
+    protected needsHydration?: boolean;
+    private static hydrationObserver;
+    private static hydrationObserverHandler;
+    connect(): void;
+    disconnect(): void;
+    static install(): void;
+}
+
+/** @public */
+export declare interface HydratableView<TSource = any, TParent = any> extends ElementView, SyntheticView, DefaultExecutionContext<TParent> {
+    [Hydratable]: symbol;
+    readonly bindingViewBoundaries: Record<string, ViewNodes>;
+    readonly hydrationStage: keyof typeof HydrationStage;
+}
+
+/** @public */
+export declare class HydrationBindingError extends Error {
+    /**
+     * The factory that was unable to be bound
+     */
+    readonly factory: ViewBehaviorFactory;
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    readonly fragment: DocumentFragment;
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    readonly templateString: string;
+    constructor(
+    /**
+     * The error message
+     */
+    message: string | undefined, 
+    /**
+     * The factory that was unable to be bound
+     */
+    factory: ViewBehaviorFactory, 
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    fragment: DocumentFragment, 
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    templateString: string);
+}
+
+declare const HydrationStage: {
+    readonly unhydrated: "unhydrated";
+    readonly hydrating: "hydrating";
+    readonly hydrated: "hydrated";
+};
+
+/**
+ * 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
@@ -1604,12 +1869,12 @@ export declare function lengthOf<T>(array: readonly T[]): number;
 
 /**
  * Creates an event listener binding.
- * @param binding - The binding to invoke when the event is raised.
+ * @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>(binding: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
+export declare function listener<T = any>(expression: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
 
 /**
  * Common APIs related to markup generation.
@@ -1642,14 +1907,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
@@ -1676,7 +1933,17 @@ 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.
@@ -1771,6 +2038,13 @@ 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
@@ -1828,17 +2102,17 @@ export declare const Observable: Readonly<{
     /**
      * Creates a {@link ExpressionNotifier} that can watch the
      * provided {@link Expression} for changes.
-     * @param binding - The binding to observe.
+     * @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: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<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: Expression<TSource_1, TReturn_1, any>): boolean;
+    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(expression: Expression<TSource_1, TReturn_1, any>): boolean;
 }>;
 
 /**
@@ -1866,11 +2140,22 @@ export declare interface ObservationRecord {
 
 /**
  * Creates a one time binding
- * @param binding - The binding to refresh when signaled.
+ * @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 function oneTime<T = any>(expression: Expression<T>, policy?: DOMPolicy): Binding<T>;
+
+/**
+ * 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 function oneTime<T = any>(binding: Expression<T>): Binding<T>;
+export declare function oneWay<T = any>(expression: Expression<T>, policy?: DOMPolicy, isVolatile?: boolean): Binding<T>;
 
 /**
  * Common APIs related to content parsing.
@@ -1988,6 +2273,10 @@ export declare const ref: <TSource = any, TParent = any>(propertyName: keyof TSo
  * @public
  */
 export declare class RefDirective extends StatelessAttachedAttributeDirective<string> {
+    /**
+     * The structural id of the DOM node to which the created behavior will apply.
+     */
+    targetNodeId: string;
     /**
      * Bind this behavior.
      * @param controller - The view controller that manages the lifecycle of this behavior.
@@ -1997,6 +2286,88 @@ export declare class RefDirective extends StatelessAttachedAttributeDirective<st
 
 declare const reflectMode = "reflect";
 
+/**
+ * Creates a RenderDirective for use in advanced rendering scenarios.
+ * @param value - The binding expression that returns the data to be rendered. The expression
+ * can also return a Node to render directly.
+ * @param template - A template to render the data with
+ * or a string to indicate which RenderInstruction to use when looking up a RenderInstruction.
+ * Expressions can also be provided to dynamically determine either the template or the name.
+ * @returns A RenderDirective suitable for use in a template.
+ * @remarks
+ * If no binding is provided, then a default binding that returns the source is created.
+ * If no template is provided, then a binding is created that will use registered
+ * RenderInstructions to determine the view.
+ * If the template binding returns a string, then it will be used to look up a
+ * RenderInstruction to determine the view.
+ * @public
+ */
+export declare function render<TSource = any, TItem = any, TParent = any>(value?: Expression<TSource, TItem> | Binding<TSource, TItem> | {}, template?: ContentTemplate | string | Expression<TSource, ContentTemplate | string | Node, TParent> | Binding<TSource, ContentTemplate | string | Node, TParent>): CaptureType<TSource, TParent>;
+
+/**
+ * A Behavior that enables advanced rendering.
+ * @public
+ */
+export declare class RenderBehavior<TSource = any> implements ViewBehavior, Subscriber {
+    private directive;
+    private location;
+    private controller;
+    private view;
+    private template;
+    private templateBindingObserver;
+    private data;
+    private dataBindingObserver;
+    /**
+     * Creates an instance of RenderBehavior.
+     * @param directive - The render directive that created this behavior.
+     */
+    constructor(directive: RenderDirective);
+    /**
+     * Bind this behavior.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
+     */
+    bind(controller: ViewController): void;
+    /**
+     * Unbinds this behavior.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
+     */
+    unbind(controller: ViewController): void;
+    /** @internal */
+    handleChange(source: any, observer: ExpressionObserver): void;
+    private bindView;
+    private refreshView;
+}
+
+/**
+ * A Directive that enables use of the RenderBehavior.
+ * @public
+ */
+export declare class RenderDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory, BindingDirective {
+    readonly dataBinding: Binding<TSource>;
+    readonly templateBinding: Binding<TSource, ContentTemplate>;
+    readonly templateBindingDependsOnData: boolean;
+    /**
+     * The structural id of the DOM node to which the created behavior will apply.
+     */
+    targetNodeId: string;
+    /**
+     * Creates an instance of RenderDirective.
+     * @param dataBinding - A binding expression that returns the data to render.
+     * @param templateBinding - A binding expression that returns the template to use to render the data.
+     */
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, ContentTemplate>, templateBindingDependsOnData: boolean);
+    /**
+     * Creates HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
+     */
+    createHTML(add: AddViewBehaviorFactory): string;
+    /**
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
+     */
+    createBehavior(): RenderBehavior<TSource>;
+}
+
 /**
  * A directive that enables list rendering.
  * @param items - The array to render.
@@ -2015,13 +2386,14 @@ export declare class RepeatBehavior<TSource = any> implements ViewBehavior, Subs
     private directive;
     private location;
     private controller;
-    private views;
     private template;
     private templateBindingObserver;
     private items;
     private itemsObserver;
     private itemsBindingObserver;
     private bindView;
+    /** @internal */
+    views: SyntheticView[];
     /**
      * Creates an instance of RepeatBehavior.
      * @param location - The location in the DOM to render the repeat.
@@ -2051,24 +2423,21 @@ export declare class RepeatBehavior<TSource = any> implements ViewBehavior, Subs
     private updateViews;
     private refreshAllViews;
     private unbindAllViews;
+    private hydrateViews;
 }
 
 /**
  * A directive that configures list rendering.
  * @public
  */
-export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
+export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory, BindingDirective {
     readonly dataBinding: Binding<TSource>;
     readonly templateBinding: Binding<TSource, SyntheticViewTemplate>;
     readonly options: RepeatOptions;
-    /**
-     * 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.
@@ -2175,7 +2544,7 @@ export declare const SourceLifetime: Readonly<{
  * Describes how the source's lifetime relates to its controller's lifetime.
  * @public
  */
-export declare type SourceLifetime = typeof SourceLifetime[keyof typeof SourceLifetime];
+export declare type SourceLifetime = (typeof SourceLifetime)[keyof typeof SourceLifetime];
 
 /**
  * A splice map is a representation of how a previous array of items
@@ -2327,7 +2696,14 @@ export declare const SpliceStrategySupport: Readonly<{
  * The available values for SpliceStrategySupport.
  * @public
  */
-export declare type SpliceStrategySupport = typeof SpliceStrategySupport[keyof typeof SpliceStrategySupport];
+export declare type SpliceStrategySupport = (typeof SpliceStrategySupport)[keyof typeof SpliceStrategySupport];
+
+declare const enum Stages {
+    connecting = 0,
+    connected = 1,
+    disconnecting = 2,
+    disconnected = 3
+}
 
 /**
  * A base class used for attribute directives that don't need internal state.
@@ -2335,14 +2711,6 @@ export declare type SpliceStrategySupport = typeof SpliceStrategySupport[keyof 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.
-     */
-    nodeId: string;
     /**
      * Creates an instance of RefDirective.
      * @param options - The options to use in configuring the directive.
@@ -2389,7 +2757,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.
      */
@@ -2521,6 +2889,10 @@ 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>;
 }
 
 /**
@@ -2529,19 +2901,6 @@ export declare interface SyntheticViewTemplate<TSource = any, TParent = any> {
  */
 export declare type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
 
-/**
- * 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;
-};
-
 /**
  * A policy for use with the standard trustedTypes platform API.
  * @public
@@ -2554,24 +2913,6 @@ export declare type TrustedTypesPolicy = {
     createHTML(html: string): string;
 };
 
-/**
- * Do not change. Part of shared kernel contract.
- * @internal
- */
-export declare interface TypeDefinition {
-    type: Function;
-}
-
-/**
- * Do not change. Part of shared kernel contract.
- * @internal
- */
-export declare interface TypeRegistry<TDefinition extends TypeDefinition> {
-    register(definition: TDefinition): boolean;
-    getByType(key: Function): TDefinition | undefined;
-    getForInstance(object: any): TDefinition | undefined;
-}
-
 /**
  * A work queue used to synchronize writes to the DOM.
  * @public
@@ -2644,11 +2985,15 @@ export declare interface View<TSource = any, TParent = any> extends Disposable {
      * The data that the view is bound to.
      */
     readonly source: TSource | null;
+    /**
+     * Indicates whether the controller is bound.
+     */
+    readonly isBound: boolean;
     /**
      * Binds a view's behaviors to its binding source.
      * @param source - The binding source for the view's binding behaviors.
      */
-    bind(source: TSource): void;
+    bind(source: TSource, context?: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source and context.
      */
@@ -2676,56 +3021,25 @@ 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;
-    /**
-     * Creates a behavior.
-     */
-    createBehavior(): ViewBehavior;
-}
-
-/**
- * Bridges between ViewBehaviors and HostBehaviors, enabling a host to
- * control ViewBehaviors.
- * @public
- */
-export declare interface ViewBehaviorOrchestrator<TSource = any, TParent = any> extends ViewController<TSource, TParent>, HostBehavior<TSource> {
+    targetNodeId?: string;
     /**
-     *
-     * @param nodeId - The structural id of the DOM node to which a behavior will apply.
-     * @param target - The DOM node associated with the id.
+     * The tag name of the DOM node to which the created behavior will apply.
      */
-    addTarget(nodeId: string, target: Node): void;
+    targetTagName?: string | null;
     /**
-     * Adds a behavior.
-     * @param behavior - The behavior to add.
+     * The policy that the created behavior must run under.
      */
-    addBehavior(behavior: ViewBehavior): void;
+    policy?: DOMPolicy;
     /**
-     * Adds a behavior factory.
-     * @param factory - The behavior factory to add.
-     * @param target - The target the factory will create behaviors for.
+     * Creates a behavior.
      */
-    addBehaviorFactory(factory: ViewBehaviorFactory, target: Node): void;
+    createBehavior(): ViewBehavior;
 }
 
-/**
- * Bridges between ViewBehaviors and HostBehaviors, enabling a host to
- * control ViewBehaviors.
- * @public
- */
-export declare const ViewBehaviorOrchestrator: Readonly<{
-    /**
-     * Creates a ViewBehaviorOrchestrator.
-     * @param source - The source to to associate behaviors with.
-     * @returns A ViewBehaviorOrchestrator.
-     */
-    create<TSource = any, TParent = any>(source: TSource): ViewBehaviorOrchestrator<TSource, TParent>;
-}>;
-
 /**
  * The target nodes available to a behavior.
  * @public
@@ -2745,11 +3059,17 @@ export declare interface ViewController<TSource = any, TParent = any> extends Ex
     readonly targets: ViewBehaviorTargets;
 }
 
+declare interface ViewNodes {
+    first: Node;
+    last: Node;
+}
+
 /**
  * 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
@@ -2764,13 +3084,31 @@ 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>, policy?: DOMPolicy | undefined);
+    /**
+     * @internal
      */
-    constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
+    compile(): HTMLTemplateCompilationResult<TSource, TParent>;
     /**
      * 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.
@@ -2779,6 +3117,20 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * host that the template is being attached to.
      */
     render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    /**
+     * 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>;
 }
 
 /**
@@ -2795,8 +3147,10 @@ export declare function volatile(target: {}, name: string | Accessor, descriptor
  * @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.
+ * @param elseTemplateOrTemplateBinding - Optional template or binding that that
+ * gets the template to render when the conditional is false.
  * @public
  */
-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 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>, elseTemplateOrTemplateBinding?: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>): CaptureType<TSource, TParent>;
 
 export { }