@microsoft/fast-element 2.0.0-beta.6 → 2.0.0-beta.7

package/dist/dts/styles/element-styles.d.ts

@@ -1,5 +1,5 @@
-import type { Behavior } from "../observation/behavior.js";
 import { StyleStrategy, StyleTarget } from "../interfaces.js";
+import type { HostBehavior } from "./host.js";
 /**
  * Represents styles that can be composed into the ShadowDOM of a custom element.
  * @public
@@ -27,7 +27,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.
      */
@@ -47,7 +47,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.

package/dist/dts/styles/host.d.ts

@@ -0,0 +1,68 @@
+import type { ElementStyles } from "./element-styles.js";
+/**
+ * Controls the lifecycle and context of behaviors and styles
+ * associated with a component host.
+ * @public
+ */
+export 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;
+}
+/**
+ * Represents an object that can contribute behavior to a host.
+ * @public
+ */
+export 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;
+}

package/dist/dts/templating/binding-signal.d.ts

@@ -13,9 +13,9 @@ export declare const Signal: Readonly<{
 }>;
 /**
  * Creates a signal binding configuration with the supplied options.
- * @param binding - The binding to refresh when signaled.
+ * @param expression - The binding to refresh when signaled.
  * @param options - The signal name or a binding to use to retrieve the signal name.
  * @returns A binding configuration.
  * @public
  */
-export declare function signal<T = any>(binding: Expression<T>, options: string | Expression<T>): Binding<T>;
+export declare function signal<T = any>(expression: Expression<T>, options: string | Expression<T>): Binding<T>;

package/dist/dts/templating/binding-two-way.d.ts

@@ -21,11 +21,19 @@ export interface TwoWaySettings {
      */
     determineChangeEvent(directive: HTMLBindingDirective, target: HTMLElement): string;
 }
+export declare const TwoWaySettings: Readonly<{
+    /**
+     * Configures two-way binding.
+     * @param settings - The settings to use for the two-way binding system.
+     */
+    configure(settings: TwoWaySettings): void;
+}>;
 /**
  * Creates a default binding.
- * @param binding - The binding to refresh when changed.
+ * @param expression - The binding to refresh when changed.
+ * @param optionsOrChangeEvent - The binding options or the name of the change event to use.
  * @param isBindingVolatile - Indicates whether the binding is volatile or not.
- * @returns A binding configuration.
+ * @returns A binding.
  * @public
  */
-export declare function twoWay<T = any>(binding: Expression<T>, optionsOrChangeEvent?: TwoWayBindingOptions | string, isBindingVolatile?: boolean): Binding<T>;
+export declare function twoWay<T = any>(expression: Expression<T>, optionsOrChangeEvent?: TwoWayBindingOptions | string, isBindingVolatile?: boolean): Binding<T>;

package/dist/dts/templating/binding.d.ts

@@ -1,37 +1,17 @@
 import { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
-import { AddViewBehaviorFactory, Aspect, Aspected, Binding, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
-/**
- * The "this" context for an update target function.
- * @public
- */
-export interface UpdateTargetThis {
-    /**
-     * The directive configuration for the update.
-     */
-    directive: HTMLBindingDirective;
-}
-/**
- * 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;
+import { AddViewBehaviorFactory, Aspect, Aspected, Binding, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController } from "./html-directive.js";
 /**
  * A simple View that can be interpolated into HTML content.
  * @public
  */
 export interface ContentView {
+    readonly context: ExecutionContext;
     /**
      * 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: any, context: ExecutionContext): void;
+    bind(source: any): void;
     /**
      * Unbinds a view's behaviors from its binding source and context.
      */
@@ -57,105 +37,14 @@ export interface ContentTemplate {
      */
     create(): ContentView;
 }
-/**
- * A binding behavior for bindings that change.
- * @public
- */
-export declare class BindingBehavior implements ViewBehavior {
-    readonly directive: HTMLBindingDirective;
-    protected updateTarget: UpdateTarget;
-    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);
-    /**
-     * 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: Expression, observer: ExpressionObserver): void;
-    /**
-     * Returns the binding observer used to update the node.
-     * @param target - The target node.
-     * @returns A BindingObserver.
-     */
-    protected getObserver(target: Node): ExpressionObserver;
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
-}
-/**
- * A special binding behavior that can bind node content.
- * @public
- */
-export declare class ContentBehavior extends BindingBehavior {
-    /**
-     * 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;
-}
-/**
- * A binding behavior for handling events.
- * @public
- */
-export declare class EventBehavior {
-    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;
-}
 /**
  * A directive that applies bindings.
  * @public
  */
-export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
+export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected {
     dataBinding: Binding;
-    private factory;
+    private data;
+    private updateTarget;
     /**
      * The unique id of the factory.
      */
@@ -188,9 +77,22 @@ 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 */
+    bindDefault(controller: ViewController): void;
+    /** @internal */
+    bind: (controller: ViewController) => void;
+    /** @internal */
+    bindContent(controller: ViewController): void;
+    /** @internal */
+    bindEvent(controller: ViewController): void;
+    /** @internal */
+    unbind(controller: ViewController): void;
+    /** @internal */
+    handleEvent(event: Event): void;
+    /** @internal */
+    handleChange(binding: Expression, observer: ExpressionObserver): void;
 }
 /**
  * Creates an standard binding.

package/dist/dts/templating/children.d.ts

@@ -60,4 +60,4 @@ export declare class ChildrenDirective extends NodeObservationDirective<Children
  * @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>;

package/dist/dts/templating/html-directive.d.ts

@@ -1,7 +1,7 @@
+import type { HostBehavior } from "../index.js";
 import type { Constructable } from "../interfaces.js";
-import type { Behavior } from "../observation/behavior.js";
 import type { Subscriber } from "../observation/notifier.js";
-import type { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
+import { Expression, ExpressionController, ExpressionObserver } from "../observation/observable.js";
 /**
  * The target nodes available to a behavior.
  * @public
@@ -10,27 +10,65 @@ export declare type ViewBehaviorTargets = {
     [id: string]: Node;
 };
 /**
- * Represents an object that can contribute behavior to a view.
+ * Controls the lifecycle of a view and provides relevant context.
  * @public
  */
-export interface ViewBehavior<TSource = any, TParent = any> {
+export interface ViewController<TSource = any, TParent = any> extends ExpressionController<TSource, TParent> {
+    /**
+     * The parts of the view that are targeted by view behaviors.
+     */
+    readonly targets: ViewBehaviorTargets;
+}
+/**
+ * Bridges between ViewBehaviors and HostBehaviors, enabling a host to
+ * control ViewBehaviors.
+ * @public
+ */
+export interface ViewBehaviorOrchestrator<TSource = any, TParent = any> extends ViewController<TSource, TParent>, HostBehavior<TSource> {
+    /**
+     *
+     * @param nodeId - The structural id of the DOM node to which a behavior will apply.
+     * @param target - The DOM node associated with the id.
+     */
+    addTarget(nodeId: string, target: Node): void;
+    /**
+     * Adds a behavior.
+     * @param behavior - The behavior to add.
+     */
+    addBehavior(behavior: ViewBehavior): void;
+    /**
+     * Adds a behavior factory.
+     * @param factory - The behavior factory to add.
+     * @param target - The target the factory will create behaviors for.
+     */
+    addBehaviorFactory(factory: ViewBehaviorFactory, target: Node): void;
+}
+/**
+ * Bridges between ViewBehaviors and HostBehaviors, enabling a host to
+ * control ViewBehaviors.
+ * @public
+ */
+export declare const ViewBehaviorOrchestrator: Readonly<{
     /**
-     * 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 ViewBehaviorOrchestrator.
+     * @param source - The source to to associate behaviors with.
+     * @returns A ViewBehaviorOrchestrator.
      */
-    bind(source: TSource, context: ExecutionContext<TParent>, targets: ViewBehaviorTargets): void;
+    create<TSource = any, TParent = any>(source: TSource): ViewBehaviorOrchestrator<TSource, TParent>;
+}>;
+/**
+ * Represents an object that can contribute behavior to a view.
+ * @public
+ */
+export interface ViewBehavior<TSource = any, TParent = any> {
     /**
-     * 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
  */
@@ -45,9 +83,8 @@ export interface ViewBehaviorFactory {
     nodeId: string;
     /**
      * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
      */
-    createBehavior(targets: ViewBehaviorTargets): Behavior | ViewBehavior;
+    createBehavior(): ViewBehavior;
 }
 /**
  * Used to add behavior factories when constructing templates.
@@ -120,18 +157,18 @@ export declare function htmlDirective(options?: PartialHTMLDirectiveDefinition):
  * @public
  */
 export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
+    evaluate: Expression<TSource, TReturn, TParent>;
+    isVolatile: boolean;
     /**
      * Options associated with the binding.
      */
     options?: any;
     /**
-     * Whether or not the binding is volatile.
+     * Creates a binding.
+     * @param evaluate - Evaluates the binding.
+     * @param isVolatile - Indicates whether the binding is volatile.
      */
-    isVolatile?: boolean;
-    /**
-     * Evaluates the binding expression.
-     */
-    evaluate: Expression<TSource, TReturn, TParent>;
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, 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.
@@ -212,8 +249,8 @@ export interface Aspected {
  * 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.
      */
@@ -226,12 +263,7 @@ export declare abstract class StatelessAttachedAttributeDirective<T> implements
      * 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.
@@ -240,15 +272,13 @@ 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;
 }

package/dist/dts/templating/node-observation.d.ts

@@ -1,5 +1,4 @@
-import type { ExecutionContext } from "../observation/observable.js";
-import { StatelessAttachedAttributeDirective, ViewBehaviorTargets } from "./html-directive.js";
+import { StatelessAttachedAttributeDirective, ViewController } from "./html-directive.js";
 /**
  * Options for configuring node observation behavior.
  * @public
@@ -23,7 +22,7 @@ export interface NodeBehaviorOptions<T = any> {
  *
  * @public
  */
-export declare type ElementsFilter = (value: Node, index: number, array: Node[]) => boolean;
+export declare type ElementsFilter = (value: Node, index?: number, array?: Node[]) => boolean;
 /**
  * Creates a function that can be used to filter a Node array, selecting only elements.
  * @param selector - An optional selector to restrict the filter to.
@@ -44,14 +43,14 @@ export declare abstract class NodeObservationDirective<T extends NodeBehaviorOpt
      * @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.

package/dist/dts/templating/ref.d.ts

@@ -1,5 +1,4 @@
-import type { ExecutionContext } from "../observation/observable.js";
-import { StatelessAttachedAttributeDirective, ViewBehaviorTargets } from "./html-directive.js";
+import { StatelessAttachedAttributeDirective, ViewController } from "./html-directive.js";
 import type { CaptureType } from "./template.js";
 /**
  * The runtime behavior for template references.
@@ -7,21 +6,14 @@ import type { CaptureType } from "./template.js";
  */
 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.
+     * Bind this behavior.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
      */
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     */
-    unbind(): void;
+    bind(controller: ViewController): void;
 }
 /**
  * A directive that observes the updates a property with a reference to the element.
  * @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>;

package/dist/dts/templating/render.d.ts

@@ -1,44 +1,38 @@
 import type { FASTElement } from "../components/fast-element.js";
 import { Constructable } from "../interfaces.js";
-import type { Behavior } from "../observation/behavior.js";
 import type { Subscriber } from "../observation/notifier.js";
 import type { ExecutionContext, Expression, ExpressionObserver } from "../observation/observable.js";
 import { ContentTemplate, ContentView } from "./binding.js";
-import { AddViewBehaviorFactory, Binding, HTMLDirective, ViewBehaviorFactory, ViewBehaviorTargets } from "./html-directive.js";
+import { AddViewBehaviorFactory, Binding, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController } from "./html-directive.js";
 import { CaptureType, SyntheticViewTemplate, TemplateValue, ViewTemplate } from "./template.js";
 /**
  * A Behavior that enables advanced rendering.
  * @public
  */
-export declare class RenderBehavior<TSource = any, TParent = any> implements Behavior, Subscriber {
+export declare class RenderBehavior<TSource = any> implements ViewBehavior, Subscriber {
     private directive;
     private location;
-    private source;
+    private controller;
     private view;
     private template;
     private templateBindingObserver;
     private data;
     private dataBindingObserver;
-    private originalContext;
-    private childContext;
     /**
      * Creates an instance of RenderBehavior.
-     * @param location - A Node representing the location where this behavior will render.
-     * @param dataBinding - A binding expression that returns the data to render.
-     * @param templateBinding - A binding expression that returns the template to use with the data.
+     * @param directive - The render directive that created this behavior.
      */
-    constructor(directive: RenderDirective, location: Node);
+    constructor(directive: RenderDirective);
     /**
-     * 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.
+     * @param controller - The view controller that manages the lifecycle of this behavior.
      */
-    unbind(source: TSource, context: ExecutionContext<TParent>): void;
+    unbind(controller: ViewController): void;
     /** @internal */
     handleChange(source: any, observer: ExpressionObserver): void;
     private refreshView;
@@ -74,7 +68,7 @@ export declare class RenderDirective<TSource = any> implements HTMLDirective, Vi
      * Creates a behavior.
      * @param targets - The targets available for behaviors to be attached to.
      */
-    createBehavior(targets: ViewBehaviorTargets): RenderBehavior<TSource>;
+    createBehavior(): RenderBehavior<TSource>;
 }
 /**
  * Provides instructions for how to render a type.
@@ -251,7 +245,8 @@ export declare function renderWith(template: ContentTemplate, name?: string): Cl
 export declare class NodeTemplate implements ContentTemplate, ContentView {
     readonly node: Node;
     constructor(node: Node);
-    bind(source: any, context: ExecutionContext<any>): void;
+    get context(): ExecutionContext<any>;
+    bind(source: any): void;
     unbind(): void;
     insertBefore(refNode: Node): void;
     remove(): void;
@@ -273,5 +268,5 @@ export declare class NodeTemplate implements ContentTemplate, ContentView {
  * RenderInstruction to determine the view.
  * @public
  */
-export declare function render<TSource = any, TItem = any>(value?: Expression<TSource, TItem> | Binding<TSource, TItem> | {}, template?: ContentTemplate | string | Expression<TSource, ContentTemplate | string | Node> | Binding<TSource, ContentTemplate | string | Node>): CaptureType<TSource>;
+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>;
 export {};