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

package/dist/fast-element.d.ts

@@ -1,10 +1,3 @@
-/**
- * A reference to globalThis, with support
- * for browsers that don't yet support the spec.
- * @public
- */
-export declare const $global: Global;
-
 /**
  * Represents a getter/setter property accessor on an object.
  * @public
@@ -28,43 +21,132 @@ export declare interface Accessor {
 }
 
 /**
- * A directive that attaches special behavior to an element via a custom attribute.
+ * Used to add behaviors when constructing styles.
  * @public
  */
-export declare class AttachedBehaviorHTMLDirective<T = any> extends HTMLDirective {
-    private name;
-    private behavior;
-    private options;
+export declare type AddBehavior = (behavior: Behavior<HTMLElement>) => void;
+
+/**
+ * Used to add behavior factories when constructing templates.
+ * @public
+ */
+export declare type AddViewBehaviorFactory = (factory: ViewBehaviorFactory) => string;
+
+/* Excluded from this release type: AdoptedStyleSheetsStrategy */
+
+/**
+ * An observer for arrays.
+ * @public
+ */
+export declare interface ArrayObserver extends SubscriberSet {
     /**
-     *
-     * @param name - The name of the behavior; used as a custom attribute on the element.
-     * @param behavior - The behavior to instantiate and attach to the element.
-     * @param options - Options to pass to the behavior during creation.
+     * The strategy to use for tracking changes.
      */
-    constructor(name: string, behavior: AttachedBehaviorType<T>, options: T);
+    strategy: SpliceStrategy | null;
     /**
-     * Creates a placeholder string based on the directive's index within the template.
-     * @param index - The index of the directive within the template.
-     * @remarks
-     * Creates a custom attribute placeholder.
+     * The length observer for the array.
      */
-    createPlaceholder(index: number): string;
+    readonly lengthObserver: LengthObserver;
     /**
-     * Creates a behavior for the provided target node.
-     * @param target - The node instance to create the behavior for.
-     * @remarks
-     * Creates an instance of the `behavior` type this directive was constructed with
-     * and passes the target and options to that `behavior`'s constructor.
+     * Adds a splice to the list of changes.
+     * @param splice - The splice to add.
+     */
+    addSplice(splice: Splice): void;
+    /**
+     * Indicates that a reset change has occurred.
+     * @param oldCollection - The collection as it was before the reset.
+     */
+    reset(oldCollection: any[] | undefined): void;
+    /**
+     * Flushes the changes to subscribers.
      */
-    createBehavior(target: Node): Behavior;
+    flush(): void;
 }
 
 /**
- * Describes the shape of a behavior constructor that can be created by
- * an {@link AttachedBehaviorHTMLDirective}.
+ * An observer for arrays.
+ * @public
+ */
+export declare const ArrayObserver: Readonly<{
+    /**
+     * Enables the array observation mechanism.
+     * @remarks
+     * Array observation is enabled automatically when using the
+     * {@link RepeatDirective}, so calling this API manually is
+     * not typically necessary.
+     */
+    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 AttachedBehaviorType<T = any> = new (target: any, options: T) => Behavior;
+export declare type Aspect = typeof Aspect[Exclude<keyof typeof Aspect, "assign" | "none">];
+
+/**
+ * Represents something that applies to a specific aspect of the DOM.
+ * @public
+ */
+export declare interface Aspected {
+    /**
+     * The original source aspect exactly as represented in markup.
+     */
+    sourceAspect: string;
+    /**
+     * The evaluated target aspect, determined after processing the source.
+     */
+    targetAspect: string;
+    /**
+     * The type of aspect to target.
+     */
+    aspectType: Aspect;
+    /**
+     * A binding if one is associated with the aspect.
+     */
+    binding?: Binding;
+}
 
 /**
  * Decorator: Specifies an HTML attribute.
@@ -145,16 +227,9 @@ export declare class AttributeDefinition implements Accessor {
      * @param source - The source element to access.
      */
     getValue(source: HTMLElement): any;
-    /** @internal */
-    onAttributeChangedCallback(element: HTMLElement, value: any): void;
+    /* Excluded from this release type: onAttributeChangedCallback */
     private tryReflectToAttribute;
-    /**
-     * Collects all attribute definitions associated with the owner.
-     * @param Owner - The class constructor to collect attribute for.
-     * @param attributeLists - Any existing attributes to collect and merge with those associated with the owner.
-     * @internal
-     */
-    static collect(Owner: Function, ...attributeLists: (ReadonlyArray<string | AttributeConfiguration> | undefined)[]): ReadonlyArray<AttributeDefinition>;
+    /* Excluded from this release type: collect */
 }
 
 /**
@@ -168,27 +243,36 @@ export declare class AttributeDefinition implements Accessor {
  * changes in the DOM, but does not reflect property changes back.
  * @public
  */
-export declare type AttributeMode = "reflect" | "boolean" | "fromView";
+export declare type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
 
 /**
- * Represents and object that can contribute behavior to a view or
+ * Represents an object that can contribute behavior to a view or
  * element's bind/unbind operations.
  * @public
  */
-export declare interface Behavior {
+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: unknown, context: ExecutionContext): void;
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
     /**
      * Unbinds this behavior from the source.
      * @param source - The source to unbind from.
      */
-    unbind(source: unknown): void;
+    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.
@@ -197,80 +281,86 @@ export declare interface Behavior {
 export declare type Binding<TSource = any, TReturn = any, TParent = any> = (source: TSource, context: ExecutionContext<TParent>) => TReturn;
 
 /**
- * A behavior that updates content and attributes based on a configured
- * BindingDirective.
- * @public
- */
-export declare class BindingBehavior implements Behavior {
-    /** @internal */
-    source: unknown;
-    /** @internal */
-    context: ExecutionContext | null;
-    /** @internal */
-    bindingObserver: BindingObserver | null;
-    /** @internal */
-    classVersions: Record<string, number>;
-    /** @internal */
-    version: number;
-    /** @internal */
-    target: any;
-    /** @internal */
-    binding: Binding;
-    /** @internal */
-    isBindingVolatile: boolean;
-    /** @internal */
-    updateTarget: typeof updatePropertyTarget;
-    /** @internal */
-    targetName?: string;
+ * Describes the configuration for a binding expression.
+ * @public
+ */
+export declare interface BindingConfig<T = 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.
+     * The binding mode to configure the binding with.
      */
-    bind: typeof normalBind;
+    mode: BindingMode;
     /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
+     * Options to be supplied to the binding behaviors.
      */
-    unbind: typeof normalUnbind;
-    /**
-     * Creates an instance of BindingBehavior.
-     * @param target - The target of the data updates.
-     * @param binding - The binding that returns the latest value for an update.
-     * @param isBindingVolatile - Indicates whether the binding has volatile dependencies.
-     * @param bind - The operation to perform during binding.
-     * @param unbind - The operation to perform during unbinding.
-     * @param updateTarget - The operation to perform when updating.
-     * @param targetName - The name of the target attribute or property to update.
-     */
-    constructor(target: any, binding: Binding, isBindingVolatile: boolean, bind: typeof normalBind, unbind: typeof normalUnbind, updateTarget: typeof updatePropertyTarget, targetName?: string);
-    /** @internal */
-    handleChange(): void;
-    /** @internal */
-    handleEvent(event: Event): void;
+    options: T;
 }
 
+/**
+ * Describes the configuration for a binding expression.
+ * @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>;
+}>;
+
+/**
+ * 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.
  * @public
  */
-export declare interface BindingObserver<TSource = any, TReturn = any, TParent = any> extends Notifier {
+export declare interface BindingObserver<TSource = any, TReturn = any, TParent = any> extends Notifier, Disposable {
     /**
      * 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.
      */
-    observe(source: TSource, context: ExecutionContext<TParent>): TReturn;
-    /**
-     * Unsubscribe from all dependent observables of the binding.
-     */
-    disconnect(): void;
+    observe(source: TSource, context?: ExecutionContext<TParent>): TReturn;
     /**
      * Gets {@link ObservationRecord|ObservationRecords} that the {@link BindingObserver}
      * 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.
+     */
+    setMode(isAsync: boolean): void;
 }
 
 /**
@@ -281,6 +371,8 @@ export declare interface BindingObserver<TSource = any, TReturn = any, TParent =
  */
 export declare const booleanConverter: ValueConverter;
 
+declare const booleanMode = "boolean";
+
 /**
  * Represents a callable type such as a function or an object with a "call" method.
  * @public
@@ -297,11 +389,47 @@ export declare type Callable = typeof Function.prototype.call | {
 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;
+    /* Excluded from this release type: handleChange */
+}
+
 /**
  * The options used to configure child list observation.
  * @public
  */
-export declare interface ChildListBehaviorOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
+export declare interface ChildListDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
 }
 
 /**
@@ -310,78 +438,97 @@ export declare interface ChildListBehaviorOptions<T = any> extends NodeBehaviorO
  * @param propertyOrOptions - The options used to configure child node observation.
  * @public
  */
-export declare function children<T = any>(propertyOrOptions: (keyof T & string) | ChildrenBehaviorOptions<keyof T & string>): CaptureType<T>;
+export declare function children<T = any>(propertyOrOptions: (keyof T & string) | ChildrenDirectiveOptions<keyof T & string>): CaptureType<T>;
 
 /**
  * The runtime behavior for child node observation.
  * @public
  */
-export declare class ChildrenBehavior extends NodeObservationBehavior<ChildrenBehaviorOptions> {
-    private observer;
+export declare class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiveOptions> {
+    private observerProperty;
     /**
-     * Creates an instance of ChildrenBehavior.
-     * @param target - The element target to observe children on.
-     * @param options - The options to use when observing the element children.
+     * Creates an instance of ChildrenDirective.
+     * @param options - The options to use in configuring the child observation behavior.
      */
-    constructor(target: HTMLElement, options: ChildrenBehaviorOptions);
+    constructor(options: ChildrenDirectiveOptions);
     /**
      * Begins observation of the nodes.
+     * @param target - The target to observe.
      */
-    observe(): void;
+    observe(target: any): void;
     /**
      * Disconnects observation of the nodes.
+     * @param target - The target to unobserve.
      */
-    disconnect(): void;
+    disconnect(target: any): void;
     /**
-     * Retrieves the nodes that should be assigned to the target.
+     * Retrieves the raw nodes that should be assigned to the source property.
+     * @param target - The target to get the node to.
      */
-    protected getNodes(): ChildNode[];
+    getNodes(target: Element): Node[];
+    private handleEvent;
 }
 
 /**
  * The options used to configure child/subtree node observation.
  * @public
  */
-export declare type ChildrenBehaviorOptions<T = any> = ChildListBehaviorOptions<T> | SubtreeBehaviorOptions<T>;
+export declare type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 
 /**
- * The result of compiling a template and its directives.
- * @beta
+ * A function capable of compiling a template from the preprocessed form produced
+ * by the html template function into a result that can instantiate views.
+ * @public
+ */
+export declare type CompilationStrategy = (
+/**
+ * The preprocessed HTML string or template to compile.
  */
-export declare interface CompilationResult {
+html: string | HTMLTemplateElement, 
+/**
+ * The behavior factories used within the html that is being compiled.
+ */
+factories: Record<string, ViewBehaviorFactory>) => HTMLTemplateCompilationResult;
+
+/**
+ * Common APIs related to compilation.
+ * @public
+ */
+export declare const Compiler: {
     /**
-     * A cloneable DocumentFragment representing the compiled HTML.
+     * 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.
      */
-    fragment: DocumentFragment;
+    setHTMLPolicy(policy: TrustedTypesPolicy): void;
     /**
-     * The behaviors that should be applied to the template's HTML.
+     * 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.
+     * @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
      */
-    viewBehaviorFactories: NodeBehaviorFactory[];
+    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent>;
     /**
-     * The behaviors that should be applied to the host element that
-     * the template is rendered into.
+     * 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.
+     * @param strategy - The compilation strategy to use when compiling templates.
      */
-    hostBehaviorFactories: NodeBehaviorFactory[];
+    setDefaultStrategy(strategy: CompilationStrategy): void;
     /**
-     * An index offset to apply to BehaviorFactory target indexes when
-     * matching factories to targets.
+     * Aggregates an array of strings and directives into a single directive.
+     * @param parts - A heterogeneous array of static strings interspersed with
+     * directives.
+     * @returns A single inline directive that aggregates the behavior of all the parts.
      */
-    targetOffset: number;
-}
-
-/**
- * Compiles a template and associated directives into a raw compilation
- * result which include a cloneable DocumentFragment and factories capable
- * of attaching runtime behavior to nodes within the fragment.
- * @param template - The template to compile.
- * @param directives - The directives referenced by the template.
- * @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
- */
-export declare function compileTemplate(template: HTMLTemplateElement, directives: ReadonlyArray<HTMLDirective>): CompilationResult;
+    aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
+};
 
 /**
  * Represents styles that can be composed into the ShadowDOM of a custom element.
@@ -398,14 +545,27 @@ export declare type Constructable<T = {}> = {
     new (...args: any[]): T;
 };
 
+/**
+ * A type that instantiates a StyleStrategy.
+ * @public
+ */
+export declare type ConstructibleStyleStrategy = {
+    /**
+     * Creates an instance of the strategy.
+     * @param styles - The styles to initialize the strategy with.
+     */
+    new (styles: (string | CSSStyleSheet)[]): StyleStrategy;
+};
+
 /**
  * Controls the lifecycle and rendering of a `FASTElement`.
  * @public
  */
-export declare class Controller extends PropertyChangeNotifier {
+export declare class Controller<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier {
     private boundObservables;
     private behaviors;
     private needsInitialization;
+    private hasExistingShadowRoot;
     private _template;
     private _styles;
     private _isConnected;
@@ -421,7 +581,7 @@ export declare class Controller extends PropertyChangeNotifier {
     /**
      * The element being controlled by this controller.
      */
-    readonly element: HTMLElement;
+    readonly element: TElement;
     /**
      * The element definition that instructs this controller
      * in how to handle rendering and other platform integrations.
@@ -432,7 +592,7 @@ export declare class Controller extends PropertyChangeNotifier {
      * @remarks
      * If `null` then the element is managing its own rendering.
      */
-    readonly view: ElementView | null;
+    readonly view: ElementView<TElement> | null;
     /**
      * Indicates whether or not the custom element has been
      * connected to the document.
@@ -444,8 +604,8 @@ export declare class Controller extends PropertyChangeNotifier {
      * @remarks
      * This value can only be accurately read after connect but can be set at any time.
      */
-    get template(): ElementViewTemplate | null;
-    set template(value: ElementViewTemplate | null);
+    get template(): ElementViewTemplate<TElement> | null;
+    set template(value: ElementViewTemplate<TElement> | null);
     /**
      * Gets/sets the primary styles used for the component.
      * @remarks
@@ -453,35 +613,28 @@ export declare class Controller extends PropertyChangeNotifier {
      */
     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: HTMLElement, definition: FASTElementDefinition);
+    /* Excluded from this release type: __constructor */
     /**
      * 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): void;
+    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): void;
+    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
     /**
      * Adds behaviors to this element.
      * @param behaviors - The behaviors to add.
      */
-    addBehaviors(behaviors: ReadonlyArray<Behavior>): void;
+    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>, force?: boolean): void;
+    removeBehaviors(behaviors: ReadonlyArray<Behavior<TElement>>, force?: boolean): void;
     /**
      * Runs connected lifecycle behavior on the associated element.
      */
@@ -496,7 +649,7 @@ export declare class Controller extends PropertyChangeNotifier {
      * @param oldValue - The previous value of the attribute.
      * @param newValue - The new value of the attribute.
      */
-    onAttributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     /**
      * Emits a custom HTML event.
      * @param type - The type name of the event.
@@ -519,6 +672,8 @@ export declare class Controller extends PropertyChangeNotifier {
     static forCustomElement(element: HTMLElement): Controller;
 }
 
+/* Excluded from this release type: createTypeRegistry */
+
 /**
  * Transforms a template literal string into styles.
  * @param strings - The string fragments that are interpolated with the values.
@@ -527,33 +682,85 @@ export declare class Controller extends PropertyChangeNotifier {
  * The css helper supports interpolation of strings and ElementStyle instances.
  * @public
  */
-export declare function css(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): ElementStyles;
+export declare const css: CSSTemplateTag;
 
 /**
  * Directive for use in {@link css}.
  *
  * @public
  */
-export declare class CSSDirective {
+export declare interface CSSDirective {
     /**
      * Creates a CSS fragment to interpolate into the CSS document.
      * @returns - the string to interpolate into CSS
      */
-    createCSS(): ComposableStyles;
+    createCSS(add: AddBehavior): ComposableStyles;
+}
+
+/**
+ * Instructs the css engine to provide dynamic styles or
+ * associate behaviors with styles.
+ * @public
+ */
+export declare const CSSDirective: Readonly<{
+    /**
+     * Gets the directive definition associated with the instance.
+     * @param instance - The directive instance to retrieve the definition for.
+     */
+    getForInstance: (object: any) => CSSDirectiveDefinition<Constructable<CSSDirective>> | undefined;
+    /**
+     * Gets the directive definition associated with the specified type.
+     * @param type - The directive type to retrieve the definition for.
+     */
+    getByType: (key: Function) => CSSDirectiveDefinition<Constructable<CSSDirective>> | undefined;
     /**
-     * Creates a behavior to bind to the host element.
-     * @returns - the behavior to bind to the host element, or undefined.
+     * Defines a CSSDirective.
+     * @param type - The type to define as a directive.
      */
-    createBehavior(): Behavior | undefined;
+    define<TType extends Constructable<CSSDirective>>(type: any): TType;
+}>;
+
+/**
+ * Decorator: Defines a CSSDirective.
+ * @public
+ */
+export declare function cssDirective(): (type: Constructable<CSSDirective>) => void;
+
+/**
+ * Defines metadata for a CSSDirective.
+ * @public
+ */
+export declare interface CSSDirectiveDefinition<TType extends Constructable<CSSDirective> = Constructable<CSSDirective>> {
+    /**
+     * The type that the definition provides metadata for.
+     */
+    readonly type: TType;
 }
 
 /**
- * Transforms a template literal string into partial CSS.
+ * @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.
  * @param values - The values that are interpolated with the string fragments.
+ * @remarks
+ * The css helper supports interpolation of strings and ElementStyle instances.
+ * Use the .partial method to create partial CSS fragments.
  * @public
  */
-export declare function cssPartial(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): CSSDirective;
+export declare type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => 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;
+};
 
 /**
  * Decorator: Defines a platform custom element based on `FASTElement`.
@@ -561,7 +768,7 @@ export declare function cssPartial(strings: TemplateStringsArray, ...values: (Co
  * that describes the element to define.
  * @public
  */
-export declare function customElement(nameOrDef: string | PartialFASTElementDefinition): (type: Function) => void;
+export declare function customElement(nameOrDef: string | PartialFASTElementDefinition): (type: Constructable<HTMLElement>) => void;
 
 /**
  * Metadata used to configure a custom attribute's behavior through a decorator.
@@ -570,87 +777,42 @@ export declare function customElement(nameOrDef: string | PartialFASTElementDefi
 export declare type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
 
 /**
- * The default execution context used in binding expressions.
+ * The default binding options.
  * @public
  */
-export declare const defaultExecutionContext: ExecutionContext<any, any>;
+export declare type DefaultBindingOptions = AddEventListenerOptions;
 
 /**
- * Common DOM APIs.
+ * Provides a mechanism for releasing resources.
  * @public
  */
-export declare const DOM: Readonly<{
-    /**
-     * Indicates whether the DOM supports the adoptedStyleSheets feature.
-     */
-    supportsAdoptedStyleSheets: boolean;
-    /**
-     * Sets the HTML trusted types policy used by the templating engine.
-     * @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;
+export declare interface Disposable {
     /**
-     * Turns a string into trusted HTML using the configured trusted types policy.
-     * @param html - The string to turn into trusted HTML.
-     * @remarks
-     * Used internally by the template engine when creating templates
-     * and setting innerHTML.
+     * Disposes the resources.
      */
-    createHTML(html: string): string;
-    /**
-     * Determines if the provided node is a template marker used by the runtime.
-     * @param node - The node to test.
-     */
-    isMarker(node: Node): node is Comment;
-    /**
-     * Given a marker node, extract the {@link HTMLDirective} index from the placeholder.
-     * @param node - The marker node to extract the index from.
-     */
-    extractDirectiveIndexFromMarker(node: Comment): number;
-    /**
-     * Creates a placeholder string suitable for marking out a location *within*
-     * an attribute value or HTML content.
-     * @param index - The directive index to create the placeholder for.
-     * @remarks
-     * Used internally by binding directives.
-     */
-    createInterpolationPlaceholder(index: number): string;
-    /**
-     * Creates a placeholder that manifests itself as an attribute on an
-     * element.
-     * @param attributeName - The name of the custom attribute.
-     * @param index - The directive index to create the placeholder for.
-     * @remarks
-     * Used internally by attribute directives such as `ref`, `slotted`, and `children`.
-     */
-    createCustomAttributePlaceholder(attributeName: string, index: number): string;
-    /**
-     * Creates a placeholder that manifests itself as a marker within the DOM structure.
-     * @param index - The directive index to create the placeholder for.
-     * @remarks
-     * Used internally by structural directives such as `repeat`.
-     */
-    createBlockPlaceholder(index: number): string;
+    dispose(): void;
+}
+
+/**
+ * Common DOM APIs.
+ * @public
+ */
+export declare const DOM: Readonly<{
     /**
-     * Schedules DOM update work in the next async batch.
-     * @param callable - The callable function or object to queue.
+     * @deprecated
+     * Use Updates.enqueue().
      */
     queueUpdate: (callable: Callable) => void;
     /**
-     * Immediately processes all work previously scheduled
-     * through queueUpdate.
-     * @remarks
-     * This also forces nextUpdate promises
-     * to resolve.
+     * @deprecated
+     * Use Updates.next()
      */
-    processUpdates: () => void;
+    nextUpdate: () => Promise<void>;
     /**
-     * Resolves with the next DOM update.
+     * @deprecated
+     * Use Updates.process()
      */
-    nextUpdate(): Promise<void>;
+    processUpdates: () => void;
     /**
      * Sets an attribute value on an element.
      * @param element - The element to set the attribute value on.
@@ -670,16 +832,6 @@ export declare const DOM: Readonly<{
      * If the value is true, the attribute is added; otherwise it is removed.
      */
     setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
-    /**
-     * Removes all the child nodes of the provided parent node.
-     * @param parent - The node to remove the children from.
-     */
-    removeChildNodes(parent: Node): void;
-    /**
-     * Creates a TreeWalker configured to walk a template fragment.
-     * @param fragment - The fragment to walk.
-     */
-    createTemplateWalker(fragment: DocumentFragment): TreeWalker;
 }>;
 
 /**
@@ -687,7 +839,7 @@ export declare const DOM: Readonly<{
  * @param selector - An optional selector to restrict the filter to.
  * @public
  */
-export declare function elements(selector?: string): ElementsFilter;
+export declare const elements: (selector?: string) => ElementsFilter;
 
 /**
  * Elements filter function type.
@@ -696,44 +848,56 @@ export declare function elements(selector?: string): ElementsFilter;
  */
 export declare type ElementsFilter = (value: Node, index: number, array: Node[]) => boolean;
 
-/**
- * Creates an ElementStyles instance for an array of ComposableStyles.
- * @public
- */
-export declare type ElementStyleFactory = (styles: ReadonlyArray<ComposableStyles>) => ElementStyles;
-
 /**
  * Represents styles that can be applied to a custom element.
  * @public
  */
-export declare abstract class ElementStyles {
+export declare class ElementStyles {
+    readonly styles: ReadonlyArray<ComposableStyles>;
     private targets;
-    /** @internal */
-    abstract readonly styles: ReadonlyArray<ComposableStyles>;
-    /** @internal */
-    abstract readonly behaviors: ReadonlyArray<Behavior> | null;
-    /** @internal */
-    addStylesTo(target: StyleTarget): void;
-    /** @internal */
-    removeStylesFrom(target: StyleTarget): void;
-    /** @internal */
-    isAttachedTo(target: StyleTarget): boolean;
+    private _strategy;
+    /**
+     * The behaviors associated with this set of styles.
+     */
+    readonly behaviors: ReadonlyArray<Behavior<HTMLElement>> | null;
+    /**
+     * Gets the StyleStrategy associated with these element styles.
+     */
+    get strategy(): StyleStrategy;
+    /**
+     * Creates an instance of ElementStyles.
+     * @param styles - The styles that will be associated with elements.
+     */
+    constructor(styles: ReadonlyArray<ComposableStyles>);
+    /* Excluded from this release type: addStylesTo */
+    /* Excluded from this release type: removeStylesFrom */
+    /* Excluded from this release type: isAttachedTo */
     /**
      * Associates behaviors with this set of styles.
      * @param behaviors - The behaviors to associate.
      */
-    withBehaviors(...behaviors: Behavior[]): this;
+    withBehaviors(...behaviors: Behavior<HTMLElement>[]): this;
+    /**
+     * Sets the strategy that handles adding/removing these styles for an element.
+     * @param strategy - The strategy to use.
+     */
+    withStrategy(Strategy: ConstructibleStyleStrategy): this;
     /**
-     * Create ElementStyles from ComposableStyles.
+     * Sets the default strategy type to use when creating style strategies.
+     * @param Strategy - The strategy type to construct.
      */
-    static readonly create: ElementStyleFactory;
+    static setDefaultStrategy(Strategy: ConstructibleStyleStrategy): void;
+    /**
+     * Indicates whether the DOM supports the adoptedStyleSheets feature.
+     */
+    static readonly supportsAdoptedStyleSheets: boolean;
 }
 
 /**
  * A View representing DOM nodes specifically for rendering the view of a custom element.
  * @public
  */
-export declare interface ElementView extends View {
+export declare interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
     /**
      * Appends the view's DOM nodes to the referenced node.
      * @param node - The parent node to append the view's DOM nodes to.
@@ -745,12 +909,12 @@ export declare interface ElementView extends View {
  * A template capable of creating views specifically for rendering custom elements.
  * @public
  */
-export declare interface ElementViewTemplate {
+export declare interface ElementViewTemplate<TSource = any, TParent = any> {
     /**
      * Creates an ElementView instance based on this template definition.
      * @param hostBindingTarget - The element that host behaviors will be bound to.
      */
-    create(hostBindingTarget: Element): ElementView;
+    create(hostBindingTarget: Element): ElementView<TSource, TParent>;
     /**
      * 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.
@@ -758,7 +922,7 @@ export declare interface ElementViewTemplate {
      * @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: any, host: Node, hostBindingTarget?: Element): HTMLView;
+    render(source: TSource, host: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
 }
 
 /**
@@ -766,25 +930,54 @@ export declare interface ElementViewTemplate {
  * @remarks
  * Typically returned by APIs that return arrays when there are
  * no actual items to return.
- * @internal
+ * @public
  */
 export declare const emptyArray: readonly never[];
 
 /**
- * Enables the array observation mechanism.
- * @remarks
- * Array observation is enabled automatically when using the
- * {@link RepeatDirective}, so calling this API manually is
- * not typically necessary.
+ * A binding behavior for handling events.
  * @public
  */
-export declare function enableArrayObservation(): void;
+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;
+    /* Excluded from this release type: handleEvent */
+}
 
 /**
  * Provides additional contextual information available to behaviors and expressions.
  * @public
  */
-export declare class ExecutionContext<TParent = any, TGrandparent = any> {
+export declare class ExecutionContext<TParentSource = any> {
+    /**
+     * The default execution context.
+     */
+    static readonly default: ExecutionContext<any>;
     /**
      * The index of the current item within a repeat context.
      */
@@ -794,13 +987,14 @@ export declare class ExecutionContext<TParent = any, TGrandparent = any> {
      */
     length: number;
     /**
-     * The parent data object within a repeat context.
+     * The parent data source within a nested context.
      */
-    parent: TParent;
+    readonly parent: TParentSource;
     /**
      * The parent execution context when in nested context scenarios.
      */
-    parentContext: ExecutionContext<TGrandparent>;
+    readonly parentContext: ExecutionContext<TParentSource>;
+    private constructor();
     /**
      * The current event within an event handler.
      */
@@ -831,24 +1025,47 @@ export declare class ExecutionContext<TParent = any, TGrandparent = any> {
      */
     get isLast(): boolean;
     /**
-     * Sets the event for the current execution context.
-     * @param event - The event to set.
-     * @internal
+     * 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;
+    /**
+     * 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.
+     */
+    updatePosition(index: number, length: number): void;
+    /**
+     * 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.
+     */
+    createChildContext<TParentSource>(parentSource: TParentSource): ExecutionContext<TParentSource>;
+    /**
+     * 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.
+     */
+    createItemContext(index: number, length: number): ExecutionContext<TParentSource>;
+    /* Excluded from this release type: setEvent */
+    /**
+     * Creates a new root execution context.
+     * @returns A new execution context.
      */
-    static setEvent(event: Event | null): void;
+    static create(): ExecutionContext;
 }
 
-/**
- * The FAST global.
- * @internal
- */
-export declare const FAST: FASTGlobal;
+/* Excluded from this release type: FAST */
 
 /**
  * Represents a custom element based on the FASTElement infrastructure.
  * @public
  */
-export declare interface FASTElement {
+export declare interface FASTElement extends HTMLElement {
     /**
      * The underlying controller that handles the lifecycle and rendering of
      * this FASTElement.
@@ -886,7 +1103,7 @@ export declare interface FASTElement {
      * This method is invoked by the platform whenever an observed
      * attribute of FASTElement has a value change.
      */
-    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
 }
 
 /**
@@ -910,14 +1127,20 @@ export declare const FASTElement: (new () => HTMLElement & FASTElement) & {
      * @param nameOrDef - The name of the element to define or a definition object
      * that describes the element to define.
      */
-    define<TType extends Function>(type: TType, nameOrDef?: string | PartialFASTElementDefinition | undefined): TType;
+    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>;
 };
 
 /**
  * Defines metadata for a FASTElement.
  * @public
  */
-export declare class FASTElementDefinition<TType extends Function = Function> {
+export declare class FASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
     private observedAttributes;
     /**
      * The type this element definition describes.
@@ -969,51 +1192,26 @@ export declare class FASTElementDefinition<TType extends Function = Function> {
     /**
      * Defines a custom element based on this definition.
      * @param registry - The element registry to define the element in.
+     * @remarks
+     * This operation is idempotent per registry.
      */
     define(registry?: CustomElementRegistry): this;
     /**
      * Gets the element definition associated with the specified type.
      * @param type - The custom element type to retrieve the definition for.
      */
-    static readonly forType: <TType_1 extends Function>(key: TType_1) => FASTElementDefinition<Function> | undefined;
-}
-
-/**
- * The FAST global.
- * @internal
- */
-export declare interface FASTGlobal {
-    /**
-     * The list of loaded versions.
-     */
-    readonly versions: string[];
+    static readonly getByType: (key: Function) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
     /**
-     * Gets a kernel value.
-     * @param id - The id to get the value for.
-     * @param initialize - Creates the initial value for the id if not already existing.
+     * Gets the element definition associated with the instance.
+     * @param instance - The custom element instance to retrieve the definition for.
      */
-    getById<T>(id: string | number): T | null;
-    getById<T>(id: string | number, initialize: () => T): T;
+    static readonly getForInstance: (object: any) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
 }
 
-/**
- * The platform global type.
- * @public
- */
-export declare type Global = typeof globalThis & {
-    /**
-     * Enables working with trusted types.
-     */
-    trustedTypes: TrustedTypes;
-    /**
-     * The FAST global.
-     * @internal
-     */
-    readonly FAST: FASTGlobal;
-};
+/* Excluded from this release type: FASTGlobal */
 
 /**
- * Transforms a template literal string into a renderable ViewTemplate.
+ * 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
@@ -1024,77 +1222,135 @@ export declare type Global = typeof globalThis & {
 export declare function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
 
 /**
- * A directive that configures data binding to element content and attributes.
+ * A directive that applies bindings.
  * @public
  */
-export declare class HTMLBindingDirective extends TargetedHTMLDirective {
+export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
     binding: Binding;
-    private cleanedTargetName?;
-    private originalTargetName?;
-    private bind;
-    private unbind;
-    private updateTarget;
-    private isBindingVolatile;
+    mode: BindingMode;
+    options: any;
+    private factory;
+    /**
+     * The unique id of the factory.
+     */
+    id: string;
+    /**
+     * The structural id of the DOM node to which the created behavior will apply.
+     */
+    nodeId: string;
+    /**
+     * The original source aspect exactly as represented in markup.
+     */
+    sourceAspect: string;
+    /**
+     * The evaluated target aspect, determined after processing the source.
+     */
+    targetAspect: string;
     /**
-     * Creates an instance of BindingDirective.
-     * @param binding - A binding that returns the data used to update the DOM.
+     * The type of aspect to target.
      */
-    constructor(binding: Binding);
+    aspectType: Aspect;
     /**
-     * Gets/sets the name of the attribute or property that this
-     * binding is targeting.
+     * 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.
      */
-    get targetName(): string | undefined;
-    set targetName(value: string | undefined);
+    constructor(binding: Binding, mode: BindingMode, options: any);
     /**
-     * Makes this binding target the content of an element rather than
-     * a particular attribute or property.
+     * Creates HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
      */
-    targetAtContent(): void;
+    createHTML(add: AddViewBehaviorFactory): string;
     /**
-     * Creates the runtime BindingBehavior instance based on the configuration
-     * information stored in the BindingDirective.
-     * @param target - The target node that the binding behavior should attach to.
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
      */
-    createBehavior(target: Node): BindingBehavior;
+    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
 }
 
 /**
  * Instructs the template engine to apply behavior to a node.
  * @public
  */
-export declare abstract class HTMLDirective implements NodeBehaviorFactory {
+export declare interface HTMLDirective {
     /**
-     * The index of the DOM node to which the created behavior will apply.
+     * Creates HTML to be used within a template.
+     * @param add - Can be used to add  behavior factories to a template.
      */
-    targetIndex: number;
+    createHTML(add: AddViewBehaviorFactory): string;
+}
+
+/**
+ * Instructs the template engine to apply behavior to a node.
+ * @public
+ */
+export declare const HTMLDirective: Readonly<{
     /**
-     * Creates a placeholder string based on the directive's index within the template.
-     * @param index - The index of the directive within the template.
+     * Gets the directive definition associated with the instance.
+     * @param instance - The directive instance to retrieve the definition for.
      */
-    abstract createPlaceholder(index: number): string;
+    getForInstance: (object: any) => HTMLDirectiveDefinition<Constructable<HTMLDirective>> | undefined;
     /**
-     * Creates a behavior for the provided target node.
-     * @param target - The node instance to create the behavior for.
+     * Gets the directive definition associated with the specified type.
+     * @param type - The directive type to retrieve the definition for.
      */
-    abstract createBehavior(target: Node): Behavior;
+    getByType: (key: Function) => HTMLDirectiveDefinition<Constructable<HTMLDirective>> | undefined;
+    /**
+     * Defines an HTMLDirective based on the options.
+     * @param type - The type to define as a directive.
+     * @param options - Options that specify the directive's application.
+     */
+    define<TType extends Constructable<HTMLDirective>>(type: TType, options?: PartialHTMLDirectiveDefinition): TType;
+}>;
+
+/**
+ * Decorator: Defines an HTMLDirective.
+ * @param options - Provides options that specify the directive's application.
+ * @public
+ */
+export declare function htmlDirective(options?: PartialHTMLDirectiveDefinition): (type: Constructable<HTMLDirective>) => void;
+
+/**
+ * Defines metadata for an HTMLDirective.
+ * @public
+ */
+export declare interface HTMLDirectiveDefinition<TType extends Constructable<HTMLDirective> = Constructable<HTMLDirective>> extends Required<PartialHTMLDirectiveDefinition> {
+    /**
+     * The type that the definition provides metadata for.
+     */
+    readonly type: TType;
+}
+
+/**
+ * The result of a template compilation operation.
+ * @public
+ */
+export declare interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
+    /**
+     * Creates a view instance.
+     * @param hostBindingTarget - The host binding target for the view.
+     */
+    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
 }
 
 /**
  * The standard View implementation, which also implements ElementView and SyntheticView.
  * @public
  */
-export declare class HTMLView implements ElementView, SyntheticView {
+export declare class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent> {
     private fragment;
+    private factories;
+    private targets;
     private behaviors;
     /**
      * The data that the view is bound to.
      */
-    source: any | null;
+    source: TSource | null;
     /**
      * The execution context the view is running within.
      */
-    context: ExecutionContext | null;
+    context: ExecutionContext<TParent> | null;
     /**
      * The first DOM node in the range of nodes that make up the view.
      */
@@ -1108,7 +1364,7 @@ export declare class HTMLView implements ElementView, SyntheticView {
      * @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, behaviors: Behavior[]);
+    constructor(fragment: DocumentFragment, factories: ReadonlyArray<ViewBehaviorFactory>, 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.
@@ -1134,7 +1390,7 @@ export declare class HTMLView implements ElementView, SyntheticView {
      * @param source - The binding source for the view's binding behaviors.
      * @param context - The execution context to run the behaviors within.
      */
-    bind(source: unknown, context: ExecutionContext): void;
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source.
      */
@@ -1147,40 +1403,56 @@ export declare class HTMLView implements ElementView, SyntheticView {
 }
 
 /**
- * Core services shared across FAST instances.
- * @internal
+ * Observes array lengths.
+ * @public
  */
-export declare const enum KernelServiceId {
-    updateQueue = 1,
-    observable = 2,
-    contextEvent = 3,
-    elementRegistry = 4
+export declare interface LengthObserver extends Subscriber {
+    /**
+     * The length of the observed array.
+     */
+    length: number;
 }
 
 /**
- * Reverses all readonly members, making them mutable.
- * @internal
+ * Enables observing the length of an array.
+ * @param array - The array to observe the length of.
+ * @returns The length of the array.
+ * @public
  */
-export declare type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
+export declare function lengthOf<T>(array: readonly T[]): number;
 
 /**
- * A factory that can create a {@link Behavior} associated with a particular
- * location within a DOM fragment.
+ * Common APIs related to markup generation.
  * @public
  */
-export declare interface NodeBehaviorFactory {
+export declare const Markup: Readonly<{
     /**
-     * The index of the DOM node to which the created behavior will apply.
+     * Creates a placeholder string suitable for marking out a location *within*
+     * an attribute value or HTML content.
+     * @param index - The directive index to create the placeholder for.
+     * @remarks
+     * Used internally by binding directives.
      */
-    targetIndex: number;
+    interpolation: (id: string) => string;
     /**
-     * Creates a behavior for the provided target node.
-     * @param target - The node instance to create the behavior for.
+     * Creates a placeholder that manifests itself as an attribute on an
+     * element.
+     * @param attributeName - The name of the custom attribute.
+     * @param index - The directive index to create the placeholder for.
+     * @remarks
+     * Used internally by attribute directives such as `ref`, `slotted`, and `children`.
      */
-    createBehavior(target: Node): Behavior;
-}
+    attribute: (id: string) => string;
+    /**
+     * Creates a placeholder that manifests itself as a marker within the DOM structure.
+     * @param index - The directive index to create the placeholder for.
+     * @remarks
+     * Used internally by structural directives such as `repeat`.
+     */
+    comment: (id: string) => string;
+}>;
+
+/* Excluded from this release type: Mutable */
 
 /**
  * Options for configuring node observation behavior.
@@ -1203,61 +1475,72 @@ export declare interface NodeBehaviorOptions<T = any> {
 
 /**
  * A base class for node observation.
- * @internal
+ * @public
+ * @remarks
+ * Internally used by the SlottedDirective and the ChildrenDirective.
  */
-declare abstract class NodeObservationBehavior<T extends NodeBehaviorOptions> implements Behavior {
-    protected target: HTMLElement;
-    protected options: T;
-    private source;
-    private shouldUpdate;
+export declare abstract class NodeObservationDirective<T extends NodeBehaviorOptions> extends StatelessAttachedAttributeDirective<T> {
+    private sourceProperty;
     /**
-     * Creates an instance of NodeObservationBehavior.
-     * @param target - The target to assign the nodes property on.
-     * @param options - The options to use in configuring node observation.
+     * 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.
      */
-    constructor(target: HTMLElement, options: T);
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /**
-     * Begins observation of the nodes.
+     * 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.
      */
-    abstract observe(): void;
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /**
-     * Disconnects observation of the nodes.
+     * Gets the data source for the target.
+     * @param target - The target to get the source for.
+     * @returns The source.
      */
-    abstract disconnect(): void;
+    protected getSource(target: Node): any;
     /**
-     * Retrieves the nodes that should be assigned to the target.
+     * Updates the source property with the computed nodes.
+     * @param source - The source object to assign the nodes property to.
+     * @param value - The nodes to assign to the source object property.
      */
-    protected abstract getNodes(): Node[];
+    protected updateTarget(source: any, value: ReadonlyArray<any>): void;
     /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
+     * Computes the set of nodes that should be assigned to the source property.
+     * @param target - The target to compute the nodes for.
+     * @returns The computed nodes.
+     * @remarks
+     * Applies filters if provided.
      */
-    bind(source: any): void;
+    protected computeNodes(target: any): Node[];
     /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
+     * Begins observation of the nodes.
+     * @param target - The target to observe.
      */
-    unbind(): void;
-    /** @internal */
-    handleEvent(): void;
-    private computeNodes;
-    private updateTarget;
+    protected abstract observe(target: any): void;
+    /**
+     * Disconnects observation of the nodes.
+     * @param target - The target to unobserve.
+     */
+    protected abstract disconnect(target: any): void;
+    /**
+     * Retrieves the raw nodes that should be assigned to the source property.
+     * @param target - The target to get the node to.
+     */
+    protected abstract getNodes(target: any): Node[];
 }
 
-declare function normalBind(this: BindingBehavior, source: unknown, context: ExecutionContext): void;
-
-declare function normalUnbind(this: BindingBehavior): void;
-
 /**
- * Provides change notification for a source object.
+ * Provides change notifications for an observed subject.
  * @public
  */
 export declare interface Notifier {
     /**
-     * The source object that this notifier provides change notification for.
+     * The object that subscribers will receive notifications for.
      */
-    readonly source: any;
+    readonly subject: any;
     /**
      * Notifies all subscribers, based on the args.
      * @param args - Data passed along to subscribers during notification.
@@ -1298,16 +1581,12 @@ export declare const nullableNumberConverter: ValueConverter;
  * @public
  */
 export declare const Observable: Readonly<{
-    /**
-     * @internal
-     * @param factory - The factory used to create array observers.
-     */
-    setArrayObserverFactory(factory: (collection: any[]) => Notifier): void;
+    /* Excluded from this release type: setArrayObserverFactory */
     /**
      * Gets a notifier for an object or Array.
      * @param source - The object or Array to get the notifier for.
      */
-    getNotifier: (source: any) => Notifier;
+    getNotifier: <T extends Notifier = Notifier>(source: any) => T;
     /**
      * Records a property change for a source object.
      * @param source - The object to record the change against.
@@ -1345,13 +1624,13 @@ export declare const Observable: Readonly<{
      * @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, TParent = any>(binding: Binding<TSource, TReturn, TParent>, initialSubscriber?: Subscriber | undefined, isVolatileBinding?: boolean): BindingObserver<TSource, TReturn, TParent>;
+    binding<TSource = any, TReturn = any>(binding: Binding<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): BindingObserver<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.
      */
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any, TParent_1 = any>(binding: Binding<TSource_1, TReturn_1, TParent_1>): boolean;
+    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(binding: Binding<TSource_1, TReturn_1, any>): boolean;
 }>;
 
 /**
@@ -1377,6 +1656,48 @@ export declare interface ObservationRecord {
     propertyName: string;
 }
 
+/**
+ * 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.
+ * @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;
+}
+
+/**
+ * Common APIs related to content parsing.
+ * @public
+ */
+export declare const Parser: Readonly<{
+    /**
+     * Parses text content or HTML attribute content, separating out the static strings
+     * from the directives.
+     * @param value - The content or attribute string to parse.
+     * @param factories - A list of directives to search for in the string.
+     * @returns A heterogeneous array of static strings interspersed with
+     * directives or null if no directives are found in the string.
+     */
+    parse(value: string, factories: Record<string, ViewBehaviorFactory>): (string | ViewBehaviorFactory)[] | null;
+}>;
+
 /**
  * Represents metadata configuration for a custom element.
  * @public
@@ -1408,6 +1729,18 @@ export declare interface PartialFASTElementDefinition {
     readonly elementOptions?: ElementDefinitionOptions;
 }
 
+/**
+ * Represents metadata configuration for an HTMLDirective.
+ * @public
+ */
+export declare interface PartialHTMLDirectiveDefinition {
+    /**
+     * Indicates whether the directive needs access to template contextual information
+     * such as the sourceAspect, targetAspect, and aspectType.
+     */
+    aspected?: boolean;
+}
+
 /**
  * An implementation of Notifier that allows subscribers to be notified
  * of individual property changes on an object.
@@ -1415,16 +1748,16 @@ export declare interface PartialFASTElementDefinition {
  */
 export declare class PropertyChangeNotifier implements Notifier {
     private subscribers;
-    private sourceSubscribers;
+    private subjectSubscribers;
     /**
-     * The source that property changes are being notified for.
+     * The subject that property changes are being notified for.
      */
-    readonly source: any;
+    readonly subject: any;
     /**
-     * Creates an instance of PropertyChangeNotifier for the specified source.
-     * @param source - The object source that subscribers will receive notifications from.
+     * Creates an instance of PropertyChangeNotifier for the specified subject.
+     * @param subject - The object that subscribers will receive notifications for.
      */
-    constructor(source: any);
+    constructor(subject: any);
     /**
      * Notifies all subscribers, based on the specified property.
      * @param propertyName - The property name, passed along to subscribers during notification.
@@ -1449,27 +1782,20 @@ export declare class PropertyChangeNotifier implements Notifier {
  * @param propertyName - The name of the property to assign the reference to.
  * @public
  */
-export declare function ref<T = any>(propertyName: keyof T & string): CaptureType<T>;
+export declare const ref: <T = any>(propertyName: keyof T & string) => CaptureType<T>;
 
 /**
  * The runtime behavior for template references.
  * @public
  */
-export declare class RefBehavior implements Behavior {
-    private target;
-    private propertyName;
-    /**
-     * Creates an instance of RefBehavior.
-     * @param target - The element to reference.
-     * @param propertyName - The name of the property to assign the reference to.
-     */
-    constructor(target: HTMLElement, propertyName: string);
+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(source: any): void;
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     /**
      * Unbinds this behavior from the source.
      * @param source - The source to unbind from.
@@ -1477,6 +1803,8 @@ export declare class RefBehavior implements Behavior {
     unbind(): void;
 }
 
+declare const reflectMode = "reflect";
+
 /**
  * A directive that enables list rendering.
  * @param itemsBinding - The array to render.
@@ -1485,7 +1813,7 @@ export declare class RefBehavior implements Behavior {
  * @param options - Options used to turn on special repeat features.
  * @public
  */
-export declare function repeat<TSource = any, TItem = any>(itemsBinding: Binding<TSource, readonly TItem[]>, templateOrTemplateBinding: SyntheticViewTemplate | Binding<TSource, SyntheticViewTemplate>, options?: RepeatOptions): CaptureType<TSource>;
+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>;
 
 /**
  * A behavior that renders a template for each item in an array.
@@ -1503,7 +1831,7 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
     private items;
     private itemsObserver;
     private itemsBindingObserver;
-    private originalContext;
+    private context;
     private childContext;
     private bindView;
     /**
@@ -1527,7 +1855,11 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
      * @param source - The source to unbind from.
      */
     unbind(): void;
-    /** @internal */
+    /**
+     * Handles changes in the array, its items, and the repeat template.
+     * @param source - The source of the change.
+     * @param args - The details about what was changed.
+     */
     handleChange(source: any, args: Splice[]): void;
     private observeItems;
     private updateViews;
@@ -1539,17 +1871,25 @@ export declare class RepeatBehavior<TSource = any> implements Behavior, Subscrib
  * A directive that configures list rendering.
  * @public
  */
-export declare class RepeatDirective<TSource = any> extends HTMLDirective {
-    private itemsBinding;
-    private templateBinding;
-    private options;
+export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
+    readonly itemsBinding: Binding;
+    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;
     /**
      * Creates a placeholder string based on the directive's index within the template.
      * @param index - The index of the directive within the template.
      */
-    createPlaceholder: (index: number) => string;
+    createHTML(add: AddViewBehaviorFactory): string;
     /**
      * Creates an instance of RepeatDirective.
      * @param itemsBinding - The binding that provides the array to render.
@@ -1561,7 +1901,7 @@ export declare class RepeatDirective<TSource = any> extends HTMLDirective {
      * Creates a behavior for the provided target node.
      * @param target - The node instance to create the behavior for.
      */
-    createBehavior(target: Node): RepeatBehavior<TSource>;
+    createBehavior(targets: ViewBehaviorTargets): RepeatBehavior<TSource>;
 }
 
 /**
@@ -1585,57 +1925,251 @@ export declare interface RepeatOptions {
  * @param propertyOrOptions - The options used to configure slotted node observation.
  * @public
  */
-export declare function slotted<T = any>(propertyOrOptions: (keyof T & string) | SlottedBehaviorOptions<keyof T & string>): CaptureType<T>;
+export declare function slotted<T = any>(propertyOrOptions: (keyof T & string) | SlottedDirectiveOptions<keyof T & string>): CaptureType<T>;
 
 /**
  * The runtime behavior for slotted node observation.
  * @public
  */
-export declare class SlottedBehavior extends NodeObservationBehavior<SlottedBehaviorOptions> {
-    /**
-     * Creates an instance of SlottedBehavior.
-     * @param target - The slot element target to observe.
-     * @param options - The options to use when observing the slot.
-     */
-    constructor(target: HTMLSlotElement, options: SlottedBehaviorOptions);
+export declare class SlottedDirective extends NodeObservationDirective<SlottedDirectiveOptions> {
     /**
      * Begins observation of the nodes.
+     * @param target - The target to observe.
      */
-    observe(): void;
+    observe(target: EventSource): void;
     /**
      * Disconnects observation of the nodes.
+     * @param target - The target to unobserve.
      */
-    disconnect(): void;
+    disconnect(target: EventSource): void;
     /**
-     * Retrieves the nodes that should be assigned to the target.
+     * Retrieves the raw nodes that should be assigned to the source property.
+     * @param target - The target to get the node to.
      */
-    protected getNodes(): Node[];
+    getNodes(target: HTMLSlotElement): Node[];
+    /* Excluded from this release type: handleEvent */
 }
 
 /**
  * The options used to configure slotted node observation.
  * @public
  */
-export declare interface SlottedBehaviorOptions<T = any> extends NodeBehaviorOptions<T>, AssignedNodesOptions {
+export declare interface SlottedDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, AssignedNodesOptions {
 }
 
 /**
- * Represents a set of splice-based changes against an Array.
+ * 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
+ * tuples of
+ *
+ *   (index, removed, addedCount)
+ *
+ * which are kept in ascending index order of. The tuple represents that at
+ * the |index|, |removed| sequence of items were removed, and counting forward
+ * from |index|, |addedCount| items were added.
  * @public
  */
-export declare interface Splice {
+export declare class Splice {
+    index: number;
+    removed: any[];
+    addedCount: number;
     /**
-     * The index that the splice occurs at.
+     * Indicates that this splice represents a complete array reset.
      */
-    index: number;
+    reset?: boolean;
     /**
-     * The items that were removed.
+     * Creates a splice.
+     * @param index - The index that the splice occurs at.
+     * @param removed - The items that were removed.
+     * @param addedCount - The  number of items that were added.
      */
-    removed: any[];
+    constructor(index: number, removed: any[], addedCount: number);
     /**
-     * The  number of items that were added.
+     * Adjusts the splice index based on the provided array.
+     * @param array - The array to adjust to.
+     * @returns The same splice, mutated based on the reference array.
      */
-    addedCount: number;
+    adjustTo(array: any[]): this;
+}
+
+/**
+ * An approach to tracking changes in an array.
+ * @public
+ */
+export declare interface SpliceStrategy {
+    /**
+     * The level of feature support the splice strategy provides.
+     */
+    readonly support: SpliceStrategySupport;
+    /**
+     * Normalizes the splices before delivery to array change subscribers.
+     * @param previous - The previous version of the array if a reset has taken place.
+     * @param current - The current version of the array.
+     * @param changes - The set of changes tracked against the array.
+     */
+    normalize(previous: unknown[] | undefined, current: unknown[], changes: Splice[] | undefined): readonly Splice[];
+    /**
+     * Performs and tracks a pop operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param pop - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    pop(array: any[], observer: ArrayObserver, pop: typeof Array.prototype.pop, args: any[]): any;
+    /**
+     * Performs and tracks a push operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param push - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    push(array: any[], observer: ArrayObserver, push: typeof Array.prototype.push, args: any[]): any;
+    /**
+     * Performs and tracks a reverse operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param reverse - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    reverse(array: any[], observer: ArrayObserver, reverse: typeof Array.prototype.reverse, args: any[]): any;
+    /**
+     * Performs and tracks a shift operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param shift - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    shift(array: any[], observer: ArrayObserver, shift: typeof Array.prototype.shift, args: any[]): any;
+    /**
+     * Performs and tracks a sort operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param sort - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    sort(array: any[], observer: ArrayObserver, sort: typeof Array.prototype.sort, args: any[]): any[];
+    /**
+     * Performs and tracks a splice operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param splice - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    splice(array: any[], observer: ArrayObserver, splice: typeof Array.prototype.splice, args: any[]): any;
+    /**
+     * Performs and tracks an unshift operation on an array.
+     * @param array - The array to track the change for.
+     * @param observer - The observer to register the change with.
+     * @param unshift - The operation to perform.
+     * @param args - The arguments for the operation.
+     */
+    unshift(array: any[], observer: ArrayObserver, unshift: typeof Array.prototype.unshift, args: any[]): any[];
+}
+
+/**
+ * Functionality related to tracking changes in arrays.
+ * @public
+ */
+export declare const SpliceStrategy: Readonly<{
+    /**
+     * A set of changes that represent a full array reset.
+     */
+    readonly reset: Splice[];
+    /**
+     * Sets the default strategy to use for array observers.
+     * @param strategy - The splice strategy to use.
+     */
+    readonly setDefaultStrategy: (strategy: SpliceStrategy) => void;
+}>;
+
+/**
+ * Indicates what level of feature support the splice
+ * strategy provides.
+ * @public
+ */
+export declare const SpliceStrategySupport: Readonly<{
+    /**
+     * Only supports resets.
+     */
+    readonly reset: 1;
+    /**
+     * Supports tracking splices and resets.
+     */
+    readonly splice: 2;
+    /**
+     * Supports tracking splices and resets, while applying some form
+     * of optimization, such as merging, to the splices.
+     */
+    readonly optimized: 3;
+}>;
+
+/**
+ * The available values for SpliceStrategySupport.
+ * @public
+ */
+export declare type SpliceStrategySupport = typeof SpliceStrategySupport[keyof typeof SpliceStrategySupport];
+
+/**
+ * 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;
+    /**
+     * 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.
+     */
+    constructor(options: T);
+    /**
+     * Creates a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
+     */
+    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+    /**
+     * Creates a placeholder string based on the directive's index within the template.
+     * @param index - The index of the directive within the template.
+     * @remarks
+     * Creates a custom attribute placeholder.
+     */
+    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.
+     */
+    abstract bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    /**
+     * Unbinds this behavior from the source.
+     * @param source - The source to unbind from.
+     */
+    abstract unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+}
+
+/**
+ * Implemented to provide specific behavior when adding/removing styles
+ * for elements.
+ * @public
+ */
+export declare interface StyleStrategy {
+    /**
+     * Adds styles to the target.
+     * @param target - The target to add the styles to.
+     */
+    addStylesTo(target: StyleTarget): void;
+    /**
+     * Removes styles from the target.
+     * @param target - The target to remove the styles from.
+     */
+    removeStylesFrom(target: StyleTarget): void;
 }
 
 /**
@@ -1652,12 +2186,6 @@ export declare interface StyleTarget {
      * @param styles - The styles element to add.
      */
     append(styles: HTMLStyleElement): void;
-    /**
-     * Adds styles to the target by prepending the styles.
-     * @param styles - The styles element to add.
-     * @deprecated - use append()
-     */
-    prepend(styles: HTMLStyleElement): void;
     /**
      * Removes styles from the target.
      * @param styles - The styles element to remove.
@@ -1676,17 +2204,17 @@ export declare interface StyleTarget {
  */
 export declare interface Subscriber {
     /**
-     * Called when a source this instance has subscribed to changes.
-     * @param source - The source of the change.
+     * 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.
      */
-    handleChange(source: any, args: any): void;
+    handleChange(subject: any, args: any): void;
 }
 
 /**
  * An implementation of {@link Notifier} that efficiently keeps track of
  * subscribers interested in a specific change notification on an
- * observable source.
+ * observable subject.
  *
  * @remarks
  * This set is optimized for the most common scenario of 1 or 2 subscribers.
@@ -1699,15 +2227,15 @@ export declare class SubscriberSet implements Notifier {
     private sub2;
     private spillover;
     /**
-     * The source that this subscriber set is reporting changes for.
+     * The object that subscribers will receive notifications for.
      */
-    readonly source: any;
+    readonly subject: any;
     /**
-     * Creates an instance of SubscriberSet for the specified source.
-     * @param source - The object source that subscribers will receive notifications from.
+     * Creates an instance of SubscriberSet for the specified subject.
+     * @param subject - The subject that subscribers will receive notifications from.
      * @param initialSubscriber - An initial subscriber to changes.
      */
-    constructor(source: any, initialSubscriber?: Subscriber);
+    constructor(subject: any, initialSubscriber?: Subscriber);
     /**
      * Checks whether the provided subscriber has been added to this set.
      * @param subscriber - The subscriber to test for inclusion in this set.
@@ -1734,7 +2262,7 @@ export declare class SubscriberSet implements Notifier {
  * The options used to configure subtree observation.
  * @public
  */
-export declare interface SubtreeBehaviorOptions<T = any> extends Omit<NodeBehaviorOptions<T>, "filter">, Omit<MutationObserverInit, "subtree" | "childList"> {
+export declare interface SubtreeDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
     /**
      * Indicates that child subtrees should be observed for changes.
      */
@@ -1750,7 +2278,7 @@ export declare interface SubtreeBehaviorOptions<T = any> extends Omit<NodeBehavi
  * A view representing a range of DOM nodes which can be added/removed ad hoc.
  * @public
  */
-export declare interface SyntheticView extends View {
+export declare interface SyntheticView<TSource = any, TParent = any> extends View<TSource, TParent> {
     /**
      * The first DOM node in the range of nodes that make up the view.
      */
@@ -1769,11 +2297,6 @@ export declare interface SyntheticView extends View {
      * The nodes are not disposed and the view can later be re-inserted.
      */
     remove(): void;
-    /**
-     * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
-     * Once a view has been disposed, it cannot be inserted or bound again.
-     */
-    dispose(): void;
 }
 
 /**
@@ -1784,31 +2307,14 @@ export declare interface SyntheticViewTemplate<TSource = any, TParent = any> {
     /**
      * Creates a SyntheticView instance based on this template definition.
      */
-    create(): SyntheticView;
-}
-
-/**
- * A {@link HTMLDirective} that targets a named attribute or property on a node.
- * @public
- */
-export declare abstract class TargetedHTMLDirective extends HTMLDirective {
-    /**
-     * Gets/sets the name of the attribute or property that this
-     * directive is targeting on the associated node.
-     */
-    abstract targetName: string | undefined;
-    /**
-     * Creates a placeholder string based on the directive's index within the template.
-     * @param index - The index of the directive within the template.
-     */
-    createPlaceholder: (index: number) => string;
+    create(): SyntheticView<TSource, TParent>;
 }
 
 /**
  * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export declare type TemplateValue<TScope, TParent = any> = Binding<TScope, any, TParent> | string | number | HTMLDirective | CaptureType<TScope>;
+export declare type TemplateValue<TSource, TParent = any> = Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource>;
 
 /**
  * Enables working with trusted types.
@@ -1835,7 +2341,107 @@ export declare type TrustedTypesPolicy = {
     createHTML(html: string): string;
 };
 
-declare function updatePropertyTarget(this: BindingBehavior, value: unknown): void;
+/* Excluded from this release type: TypeDefinition */
+
+/* Excluded from this release type: TypeRegistry */
+
+/**
+ * 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
+ */
+export declare interface UpdateQueue {
+    /**
+     * Schedules DOM update work in the next batch.
+     * @param callable - The callable function or object to queue.
+     */
+    enqueue(callable: Callable): void;
+    /**
+     * Resolves with the next DOM update.
+     */
+    next(): Promise<void>;
+    /**
+     * Immediately processes all work previously scheduled
+     * through enqueue.
+     * @remarks
+     * This also forces next() promises
+     * to resolve.
+     */
+    process(): void;
+    /**
+     * Sets the update mode used by enqueue.
+     * @param isAsync - Indicates whether DOM updates should be asynchronous.
+     * @remarks
+     * By default, the update mode is asynchronous, since that provides the best
+     * performance in the browser. Passing false to setMode will instead cause
+     * the queue to be immediately processed for each call to enqueue. However,
+     * ordering will still be preserved so that nested tasks do not run until
+     * after parent tasks complete.
+     */
+    setMode(isAsync: boolean): void;
+}
+
+/**
+ * The default UpdateQueue.
+ * @public
+ */
+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
@@ -1859,43 +2465,83 @@ export declare interface ValueConverter {
  * Represents a collection of DOM nodes which can be bound to a data source.
  * @public
  */
-export declare interface View {
+export declare interface View<TSource = any, TParent = any> extends Disposable {
     /**
      * The execution context the view is running within.
      */
-    readonly context: ExecutionContext | null;
+    readonly context: ExecutionContext<TParent> | null;
     /**
      * The data that the view is bound to.
      */
-    readonly source: any | null;
+    readonly source: TSource | null;
     /**
      * 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: unknown, context: ExecutionContext): void;
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
     /**
      * Unbinds a view's behaviors from its binding source and context.
      */
     unbind(): void;
+}
+
+/**
+ * Represents an object that can contribute behavior to a view.
+ * @public
+ */
+export declare interface ViewBehavior<TSource = any, TParent = any> {
     /**
-     * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
-     * Once a view has been disposed, it cannot be inserted or bound again.
+     * 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.
      */
-    dispose(): void;
+    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.
+     */
+    unbind(source: TSource, context: ExecutionContext<TParent>, targets: ViewBehaviorTargets): void;
+}
+
+/**
+ * A factory that can create a {@link Behavior} associated with a particular
+ * location within a DOM fragment.
+ * @public
+ */
+export declare interface ViewBehaviorFactory {
+    /**
+     * 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 a behavior.
+     * @param targets - The targets available for behaviors to be attached to.
+     */
+    createBehavior(targets: ViewBehaviorTargets): Behavior | ViewBehavior;
 }
 
+/**
+ * The target nodes available to a behavior.
+ * @public
+ */
+export declare type ViewBehaviorTargets = {
+    [id: string]: Node;
+};
+
 /**
  * A template capable of creating HTMLView instances or rendering directly to DOM.
  * @public
  */
-export declare class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate, SyntheticViewTemplate {
-    private behaviorCount;
-    private hasHostBehaviors;
-    private fragment;
-    private targetOffset;
-    private viewBehaviorFactories;
-    private hostBehaviorFactories;
+export declare class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
+    private result;
     /**
      * The html representing what this template will
      * instantiate, including placeholders for directives.
@@ -1904,18 +2550,18 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
     /**
      * The directives that will be connected to placeholders in the html.
      */
-    readonly directives: ReadonlyArray<HTMLDirective>;
+    readonly factories: Record<string, ViewBehaviorFactory>;
     /**
      * Creates an instance of ViewTemplate.
      * @param html - The html representing what this template will instantiate, including placeholders for directives.
-     * @param directives - The directives that will be connected to placeholders in the html.
+     * @param factories - The directives that will be connected to placeholders in the html.
      */
-    constructor(html: string | HTMLTemplateElement, directives: ReadonlyArray<HTMLDirective>);
+    constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
     /**
      * Creates an HTMLView instance based on this template definition.
      * @param hostBindingTarget - The element that host behaviors will be bound to.
      */
-    create(hostBindingTarget?: Element): HTMLView;
+    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     /**
      * 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.
@@ -1923,7 +2569,7 @@ 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 | string, hostBindingTarget?: Element): HTMLView;
+    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: ExecutionContext): HTMLView<TSource, TParent>;
 }
 
 /**