@microsoft/fast-element 2.0.0-beta.9 → 2.0.1

package/docs/{api-report.md → api-report.api.md}

@@ -17,19 +17,6 @@ export type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
 // @public
 export type AddViewBehaviorFactory = (factory: ViewBehaviorFactory) => string;
 
-// Warning: (ae-internal-missing-underscore) The name "AdoptedStyleSheetsStrategy" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
-export class AdoptedStyleSheetsStrategy implements StyleStrategy {
-    constructor(styles: (string | CSSStyleSheet)[]);
-    // (undocumented)
-    addStylesTo(target: StyleTarget): void;
-    // (undocumented)
-    removeStylesFrom(target: StyleTarget): void;
-    // (undocumented)
-    readonly sheets: CSSStyleSheet[];
-}
-
 // @public
 export interface ArrayObserver extends SubscriberSet {
     addSplice(splice: Splice): void;
@@ -44,24 +31,9 @@ export const ArrayObserver: Readonly<{
     readonly enable: () => void;
 }>;
 
-// @public
-export const Aspect: Readonly<{
-    readonly none: 0;
-    readonly attribute: 1;
-    readonly booleanAttribute: 2;
-    readonly property: 3;
-    readonly content: 4;
-    readonly tokenList: 5;
-    readonly event: 6;
-    readonly assign: (directive: Aspected, value?: string) => void;
-}>;
-
-// @public
-export type Aspect = typeof Aspect[Exclude<keyof typeof Aspect, "assign" | "none">];
-
 // @public
 export interface Aspected {
-    aspectType: Aspect;
+    aspectType: DOMAspect;
     dataBinding?: Binding;
     sourceAspect: string;
     targetAspect: string;
@@ -108,18 +80,24 @@ export class AttributeDefinition implements Accessor {
 // @public
 export type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
 
-// @public
-export function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
-
 // @public
 export abstract class Binding<TSource = any, TReturn = any, TParent = any> {
-    constructor(evaluate: Expression<TSource, TReturn, TParent>, isVolatile?: boolean);
-    abstract createObserver(directive: HTMLDirective, subscriber: Subscriber): ExpressionObserver<TSource, TReturn, TParent>;
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy | undefined, isVolatile?: boolean);
+    abstract createObserver(subscriber: Subscriber, directive: BindingDirective): ExpressionObserver<TSource, TReturn, TParent>;
     // (undocumented)
     evaluate: Expression<TSource, TReturn, TParent>;
     // (undocumented)
     isVolatile: boolean;
     options?: any;
+    // (undocumented)
+    policy?: DOMPolicy | undefined;
+}
+
+// @public
+export interface BindingDirective {
+    readonly aspectType?: DOMAspect;
+    readonly dataBinding: Binding;
+    readonly targetAspect?: string;
 }
 
 // @public
@@ -152,17 +130,25 @@ export class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiv
 // @public
 export type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 
+// @public
+export type Class<T, C = {}> = C & Constructable<T> & {
+    readonly prototype: T;
+};
+
 // @public
 export type CompilationStrategy = (
 html: string | HTMLTemplateElement,
-factories: Record<string, ViewBehaviorFactory>) => HTMLTemplateCompilationResult;
+factories: Record<string, ViewBehaviorFactory>,
+policy: DOMPolicy) => HTMLTemplateCompilationResult;
+
+// @public
+export type CompiledViewBehaviorFactory = Required<ViewBehaviorFactory>;
 
 // @public
 export const Compiler: {
-    setHTMLPolicy(policy: TrustedTypesPolicy): void;
-    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent>;
+    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy): HTMLTemplateCompilationResult<TSource, TParent>;
     setDefaultStrategy(strategy: CompilationStrategy): void;
-    aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
+    aggregate(parts: (string | ViewBehaviorFactory)[], policy?: DOMPolicy): ViewBehaviorFactory;
 };
 
 // @public
@@ -193,19 +179,30 @@ export interface ContentView {
     unbind(): void;
 }
 
-// Warning: (ae-internal-missing-underscore) The name "createMetadataLocator" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
-export function createMetadataLocator<TMetadata>(): (target: {}) => TMetadata[];
-
-// Warning: (ae-internal-missing-underscore) The name "createTypeRegistry" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
-export function createTypeRegistry<TDefinition extends TypeDefinition>(): TypeRegistry<TDefinition>;
-
 // @public
 export const css: CSSTemplateTag;
 
+// @public
+export class CSSBindingDirective implements HostBehavior, Subscriber, CSSDirective, BindingDirective {
+    constructor(dataBinding: Binding, targetAspect: string);
+    addedCallback(controller: HostController<HTMLElement & {
+        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
+    }>): void;
+    connectedCallback(controller: HostController<HTMLElement & {
+        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
+    }>): void;
+    createCSS(add: AddBehavior): ComposableStyles;
+    // (undocumented)
+    readonly dataBinding: Binding;
+    // @internal
+    handleChange(_: any, observer: ExpressionObserver): void;
+    removedCallback(controller: HostController<HTMLElement & {
+        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
+    }>): void;
+    // (undocumented)
+    readonly targetAspect: string;
+}
+
 // @public
 export interface CSSDirective {
     createCSS(add: AddBehavior): ComposableStyles;
@@ -226,14 +223,14 @@ export interface CSSDirectiveDefinition<TType extends Constructable<CSSDirective
     readonly type: TType;
 }
 
-// @public @deprecated (undocumented)
-export const cssPartial: (strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => CSSDirective;
-
 // @public
-export type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => ElementStyles) & {
-    partial(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): CSSDirective;
+export type CSSTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]) => ElementStyles) & {
+    partial<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]): CSSDirective;
 };
 
+// @public
+export type CSSValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | ComposableStyles | CSSDirective;
+
 // @public
 export function customElement(nameOrDef: string | PartialFASTElementDefinition): (type: Constructable<HTMLElement>) => void;
 
@@ -247,36 +244,87 @@ export interface Disposable {
 
 // @public
 export const DOM: Readonly<{
-    queueUpdate: (callable: Callable) => void;
-    nextUpdate: () => Promise<void>;
-    processUpdates: () => void;
+    readonly policy: DOMPolicy;
+    setPolicy(value: DOMPolicy): void;
     setAttribute(element: HTMLElement, attributeName: string, value: any): void;
     setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
 }>;
 
+// @public
+export const DOMAspect: Readonly<{
+    readonly none: 0;
+    readonly attribute: 1;
+    readonly booleanAttribute: 2;
+    readonly property: 3;
+    readonly content: 4;
+    readonly tokenList: 5;
+    readonly event: 6;
+}>;
+
+// @public
+export type DOMAspect = (typeof DOMAspect)[Exclude<keyof typeof DOMAspect, "none">];
+
+// @public
+export interface DOMPolicy {
+    createHTML(value: string): string;
+    protect(tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink): DOMSink;
+}
+
+// @public
+export type DOMSink = (target: Node, aspectName: string, value: any, ...args: any[]) => void;
+
 // @public
 export class ElementController<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier implements HostController<TElement> {
     // @internal
     constructor(element: TElement, definition: FASTElementDefinition);
     addBehavior(behavior: HostBehavior<TElement>): void;
     addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    // (undocumented)
+    protected behaviors: Map<HostBehavior<TElement>, number> | null;
+    // (undocumented)
+    protected bindObservables(): void;
     connect(): void;
+    // (undocumented)
+    protected connectBehaviors(): void;
+    get context(): ExecutionContext;
     readonly definition: FASTElementDefinition;
     disconnect(): void;
+    // (undocumented)
+    protected disconnectBehaviors(): void;
     emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
     static forCustomElement(element: HTMLElement): ElementController;
+    get isBound(): boolean;
     get isConnected(): boolean;
     get mainStyles(): ElementStyles | null;
     set mainStyles(value: ElementStyles | null);
+    // (undocumented)
+    protected needsInitialization: boolean;
     onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    onUnbind(behavior: {
+        unbind(controller: ExpressionController<TElement>): any;
+    }): void;
     removeBehavior(behavior: HostBehavior<TElement>, force?: boolean): void;
     removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    // (undocumented)
+    protected renderTemplate(template: ElementViewTemplate | null | undefined): void;
+    static setStrategy(strategy: ElementControllerStrategy): void;
     readonly source: TElement;
+    get sourceLifetime(): SourceLifetime | undefined;
+    // Warning: (ae-forgotten-export) The symbol "Stages" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    protected stage: Stages;
     get template(): ElementViewTemplate<TElement> | null;
     set template(value: ElementViewTemplate<TElement> | null);
     readonly view: ElementView<TElement> | null;
 }
 
+// @public
+export interface ElementControllerStrategy {
+    // (undocumented)
+    new (element: HTMLElement, definition: FASTElementDefinition): ElementController;
+}
+
 // @public
 export const elements: (selector?: string) => ElementsFilter;
 
@@ -306,6 +354,10 @@ export class ElementStyles {
 // @public
 export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
     appendTo(node: Node): void;
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): any;
+    }): void;
+    readonly sourceLifetime?: SourceLifetime;
 }
 
 // @public
@@ -366,9 +418,7 @@ export interface ExpressionObserver<TSource = any, TReturn = any, TParent = any>
     bind(controller: ExpressionController<TSource, TParent>): TReturn;
 }
 
-// Warning: (ae-internal-missing-underscore) The name "FAST" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
+// @public
 export const FAST: FASTGlobal;
 
 // @public
@@ -400,6 +450,8 @@ export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Co
     get isDefined(): boolean;
     readonly name: string;
     readonly propertyLookup: Record<string, AttributeDefinition>;
+    // @internal
+    static registerBaseType(type: Function): void;
     readonly registry: CustomElementRegistry;
     readonly shadowOptions?: ShadowRootOptions;
     readonly styles?: ElementStyles;
@@ -407,9 +459,7 @@ export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Co
     readonly type: TType;
 }
 
-// Warning: (ae-internal-missing-underscore) The name "FASTGlobal" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
+// @public
 export interface FASTGlobal {
     addMessages(messages: Record<number, string>): void;
     error(code: number, values?: Record<string, any>): Error;
@@ -429,31 +479,24 @@ export interface HostBehavior<TSource = any> {
 }
 
 // @public
-export interface HostController<TSource = any> {
+export interface HostController<TSource = any> extends ExpressionController<TSource> {
     addBehavior(behavior: HostBehavior<TSource>): void;
     addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
     readonly isConnected: boolean;
     mainStyles: ElementStyles | null;
     removeBehavior(behavior: HostBehavior<TSource>, force?: boolean): void;
     removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-    readonly source: TSource;
 }
 
 // @public
-export function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
+export const html: HTMLTemplateTag;
 
 // @public
-export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected {
+export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected, BindingDirective {
     constructor(dataBinding: Binding);
-    aspectType: Aspect;
-    // @internal (undocumented)
-    bind: (controller: ViewController) => void;
+    aspectType: DOMAspect;
     // @internal (undocumented)
-    bindContent(controller: ViewController): void;
-    // @internal (undocumented)
-    bindDefault(controller: ViewController): void;
-    // @internal (undocumented)
-    bindEvent(controller: ViewController): void;
+    bind(controller: ViewController): void;
     createBehavior(): ViewBehavior;
     createHTML(add: AddViewBehaviorFactory): string;
     // (undocumented)
@@ -463,9 +506,11 @@ export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory,
     // @internal (undocumented)
     handleEvent(event: Event): void;
     id: string;
-    nodeId: string;
+    policy: DOMPolicy;
     sourceAspect: string;
     targetAspect: string;
+    targetNodeId: string;
+    targetTagName: string | null;
     // @internal (undocumented)
     unbind(controller: ViewController): void;
 }
@@ -480,6 +525,7 @@ export const HTMLDirective: Readonly<{
     getForInstance: (object: any) => HTMLDirectiveDefinition<Constructable<HTMLDirective>> | undefined;
     getByType: (key: Function) => HTMLDirectiveDefinition<Constructable<HTMLDirective>> | undefined;
     define<TType extends Constructable<HTMLDirective>>(type: TType, options?: PartialHTMLDirectiveDefinition): TType;
+    assignAspect(directive: Aspected, value?: string): void;
 }>;
 
 // @public
@@ -493,36 +539,33 @@ export interface HTMLDirectiveDefinition<TType extends Constructable<HTMLDirecti
 // @public
 export interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
     createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    // (undocumented)
+    readonly factories: CompiledViewBehaviorFactory[];
 }
 
 // @public
-export class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
-    constructor(fragment: DocumentFragment, factories: ReadonlyArray<ViewBehaviorFactory>, targets: ViewBehaviorTargets);
+export type HTMLTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]) => ViewTemplate<TSource, TParent>) & {
+    partial(html: string): InlineTemplateDirective;
+};
+
+// Warning: (ae-forgotten-export) The symbol "DefaultExecutionContext" needs to be exported by the entry point index.d.ts
+//
+// @public
+export class HTMLView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
+    constructor(fragment: DocumentFragment, factories: ReadonlyArray<CompiledViewBehaviorFactory>, targets: ViewBehaviorTargets);
     appendTo(node: Node): void;
     bind(source: TSource, context?: ExecutionContext<TParent>): void;
     context: ExecutionContext<TParent>;
     dispose(): void;
     static disposeContiguousBatch(views: SyntheticView[]): void;
-    get event(): Event;
-    eventDetail<TDetail>(): TDetail;
-    eventTarget<TTarget extends EventTarget>(): TTarget;
     firstChild: Node;
-    index: number;
     insertBefore(node: Node): void;
     isBound: boolean;
-    get isEven(): boolean;
-    get isFirst(): boolean;
-    get isInMiddle(): boolean;
-    get isLast(): boolean;
-    get isOdd(): boolean;
     lastChild: Node;
-    length: number;
     // (undocumented)
     onUnbind(behavior: {
-        unbind(controller: ViewController<TSource, TParent>): any;
+        unbind(controller: ViewController<TSource, TParent>): void;
     }): void;
-    readonly parent: TParent;
-    readonly parentContext: ExecutionContext<TParent>;
     remove(): void;
     source: TSource | null;
     readonly sourceLifetime: SourceLifetime;
@@ -531,6 +574,50 @@ export class HTMLView<TSource = any, TParent = any> implements ElementView<TSour
     unbind(): void;
 }
 
+// @beta
+export class HydratableElementController<TElement extends HTMLElement = HTMLElement> extends ElementController<TElement> {
+    // (undocumented)
+    connect(): void;
+    // (undocumented)
+    disconnect(): void;
+    // (undocumented)
+    static install(): void;
+    protected needsHydration?: boolean;
+}
+
+// @public (undocumented)
+export interface HydratableView<TSource = any, TParent = any> extends ElementView, SyntheticView, DefaultExecutionContext<TParent> {
+    // (undocumented)
+    [Hydratable]: symbol;
+    // Warning: (ae-forgotten-export) The symbol "ViewNodes" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly bindingViewBoundaries: Record<string, ViewNodes>;
+    // Warning: (ae-forgotten-export) The symbol "HydrationStage" needs to be exported by the entry point index.d.ts
+    //
+    // (undocumented)
+    readonly hydrationStage: keyof typeof HydrationStage;
+}
+
+// @public (undocumented)
+export class HydrationBindingError extends Error {
+    constructor(
+    message: string | undefined,
+    factory: ViewBehaviorFactory,
+    fragment: DocumentFragment,
+    templateString: string);
+    readonly factory: ViewBehaviorFactory;
+    readonly fragment: DocumentFragment;
+    readonly templateString: string;
+}
+
+// @public
+export class InlineTemplateDirective implements HTMLDirective {
+    constructor(html: string, factories?: Record<string, ViewBehaviorFactory>);
+    createHTML(add: AddViewBehaviorFactory): string;
+    static readonly empty: InlineTemplateDirective;
+}
+
 // @public
 export interface LengthObserver extends Subscriber {
     length: number;
@@ -540,7 +627,7 @@ export interface LengthObserver extends Subscriber {
 export function lengthOf<T>(array: readonly T[]): number;
 
 // @public
-export function listener<T = any>(binding: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
+export function listener<T = any>(expression: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
 
 // @public
 export const Markup: Readonly<{
@@ -549,13 +636,6 @@ export const Markup: Readonly<{
     comment: (id: string) => string;
 }>;
 
-// Warning: (ae-internal-missing-underscore) The name "Mutable" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
-export type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-
 // @public
 export interface NodeBehaviorOptions<T = any> {
     filter?: ElementsFilter;
@@ -569,7 +649,10 @@ export abstract class NodeObservationDirective<T extends NodeBehaviorOptions> ex
     protected abstract disconnect(target: any): void;
     protected abstract getNodes(target: any): Node[];
     protected getSource(target: Node): any;
+    get id(): string;
+    set id(value: string);
     protected abstract observe(target: any): void;
+    targetNodeId: string;
     unbind(controller: ViewController): void;
     protected updateTarget(source: any, value: ReadonlyArray<any>): void;
 }
@@ -585,6 +668,9 @@ export interface Notifier {
     unsubscribe(subscriber: Subscriber, propertyToUnwatch?: any): void;
 }
 
+// @public
+export const nullableBooleanConverter: ValueConverter;
+
 // @public
 export const nullableNumberConverter: ValueConverter;
 
@@ -597,8 +683,8 @@ export const Observable: Readonly<{
     notify(source: unknown, args: any): void;
     defineProperty(target: {}, nameOrAccessor: string | Accessor): void;
     getAccessors: (target: {}) => Accessor[];
-    binding<TSource = any, TReturn = any>(binding: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn, any>;
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(binding: Expression<TSource_1, TReturn_1, any>): boolean;
+    binding<TSource = any, TReturn = any>(expression: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn, any>;
+    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(expression: Expression<TSource_1, TReturn_1, any>): boolean;
 }>;
 
 // @public
@@ -611,7 +697,10 @@ export interface ObservationRecord {
 }
 
 // @public
-export function oneTime<T = any>(binding: Expression<T>): Binding<T>;
+export function oneTime<T = any>(expression: Expression<T>, policy?: DOMPolicy): Binding<T>;
+
+// @public
+export function oneWay<T = any>(expression: Expression<T>, policy?: DOMPolicy, isVolatile?: boolean): Binding<T>;
 
 // @public
 export const Parser: Readonly<{
@@ -649,6 +738,33 @@ export const ref: <TSource = any, TParent = any>(propertyName: keyof TSource & s
 // @public
 export class RefDirective extends StatelessAttachedAttributeDirective<string> {
     bind(controller: ViewController): void;
+    targetNodeId: string;
+}
+
+// @public
+export function render<TSource = any, TItem = any, TParent = any>(value?: Expression<TSource, TItem> | Binding<TSource, TItem> | {}, template?: ContentTemplate | string | Expression<TSource, ContentTemplate | string | Node, TParent> | Binding<TSource, ContentTemplate | string | Node, TParent>): CaptureType<TSource, TParent>;
+
+// @public
+export class RenderBehavior<TSource = any> implements ViewBehavior, Subscriber {
+    constructor(directive: RenderDirective);
+    bind(controller: ViewController): void;
+    // @internal (undocumented)
+    handleChange(source: any, observer: ExpressionObserver): void;
+    unbind(controller: ViewController): void;
+}
+
+// @public
+export class RenderDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory, BindingDirective {
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, ContentTemplate>, templateBindingDependsOnData: boolean);
+    createBehavior(): RenderBehavior<TSource>;
+    createHTML(add: AddViewBehaviorFactory): string;
+    // (undocumented)
+    readonly dataBinding: Binding<TSource>;
+    targetNodeId: string;
+    // (undocumented)
+    readonly templateBinding: Binding<TSource, ContentTemplate>;
+    // (undocumented)
+    readonly templateBindingDependsOnData: boolean;
 }
 
 // @public
@@ -660,19 +776,20 @@ export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
     bind(controller: ViewController): void;
     handleChange(source: any, args: Splice[] | ExpressionObserver): void;
     unbind(): void;
+    // @internal (undocumented)
+    views: SyntheticView[];
 }
 
 // @public
-export class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
+export class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory, BindingDirective {
     constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
     createBehavior(): RepeatBehavior<TSource>;
     createHTML(add: AddViewBehaviorFactory): string;
     // (undocumented)
     readonly dataBinding: Binding<TSource>;
-    id: string;
-    nodeId: string;
     // (undocumented)
     readonly options: RepeatOptions;
+    targetNodeId: string;
     // (undocumented)
     readonly templateBinding: Binding<TSource, SyntheticViewTemplate>;
 }
@@ -712,7 +829,7 @@ export const SourceLifetime: Readonly<{
 }>;
 
 // @public
-export type SourceLifetime = typeof SourceLifetime[keyof typeof SourceLifetime];
+export type SourceLifetime = (typeof SourceLifetime)[keyof typeof SourceLifetime];
 
 // @public
 export class Splice {
@@ -754,7 +871,7 @@ export const SpliceStrategySupport: Readonly<{
 }>;
 
 // @public
-export type SpliceStrategySupport = typeof SpliceStrategySupport[keyof typeof SpliceStrategySupport];
+export type SpliceStrategySupport = (typeof SpliceStrategySupport)[keyof typeof SpliceStrategySupport];
 
 // @public
 export abstract class StatelessAttachedAttributeDirective<TOptions> implements HTMLDirective, ViewBehaviorFactory, ViewBehavior {
@@ -762,8 +879,6 @@ export abstract class StatelessAttachedAttributeDirective<TOptions> implements H
     abstract bind(controller: ViewController): void;
     createBehavior(): ViewBehavior;
     createHTML(add: AddViewBehaviorFactory): string;
-    id: string;
-    nodeId: string;
     // (undocumented)
     protected options: TOptions;
 }
@@ -775,7 +890,7 @@ export interface StyleStrategy {
 }
 
 // @public
-export interface StyleTarget {
+export interface StyleTarget extends Pick<Node, "getRootNode"> {
     adoptedStyleSheets?: CSSStyleSheet[];
     append(styles: HTMLStyleElement): void;
     querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
@@ -814,41 +929,17 @@ export interface SyntheticView<TSource = any, TParent = any> extends View<TSourc
 // @public
 export interface SyntheticViewTemplate<TSource = any, TParent = any> {
     create(): SyntheticView<TSource, TParent>;
+    inline(): CaptureType<TSource, TParent>;
 }
 
 // @public
 export type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
 
-// @public
-export type TrustedTypes = {
-    createPolicy(name: string, rules: TrustedTypesPolicy): TrustedTypesPolicy;
-};
-
 // @public
 export type TrustedTypesPolicy = {
     createHTML(html: string): string;
 };
 
-// Warning: (ae-internal-missing-underscore) The name "TypeDefinition" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
-export interface TypeDefinition {
-    // (undocumented)
-    type: Function;
-}
-
-// Warning: (ae-internal-missing-underscore) The name "TypeRegistry" should be prefixed with an underscore because the declaration is marked as @internal
-//
-// @internal
-export interface TypeRegistry<TDefinition extends TypeDefinition> {
-    // (undocumented)
-    getByType(key: Function): TDefinition | undefined;
-    // (undocumented)
-    getForInstance(object: any): TDefinition | undefined;
-    // (undocumented)
-    register(definition: TDefinition): boolean;
-}
-
 // @public
 export interface UpdateQueue {
     enqueue(callable: Callable): void;
@@ -870,6 +961,7 @@ export interface ValueConverter {
 export interface View<TSource = any, TParent = any> extends Disposable {
     bind(source: TSource, context?: ExecutionContext<TParent>): void;
     readonly context: ExecutionContext<TParent>;
+    readonly isBound: boolean;
     readonly source: TSource | null;
     unbind(): void;
 }
@@ -882,23 +974,12 @@ export interface ViewBehavior<TSource = any, TParent = any> {
 // @public
 export interface ViewBehaviorFactory {
     createBehavior(): ViewBehavior;
-    id: string;
-    nodeId: string;
-}
-
-// @public
-export interface ViewBehaviorOrchestrator<TSource = any, TParent = any> extends ViewController<TSource, TParent>, HostBehavior<TSource> {
-    addBehavior(behavior: ViewBehavior): void;
-    addBehaviorFactory(factory: ViewBehaviorFactory, target: Node): void;
-    // (undocumented)
-    addTarget(nodeId: string, target: Node): void;
+    id?: string;
+    policy?: DOMPolicy;
+    targetNodeId?: string;
+    targetTagName?: string | null;
 }
 
-// @public
-export const ViewBehaviorOrchestrator: Readonly<{
-    create<TSource = any, TParent = any>(source: TSource): ViewBehaviorOrchestrator<TSource, TParent>;
-}>;
-
 // @public
 export type ViewBehaviorTargets = {
     [id: string]: Node;
@@ -911,24 +992,30 @@ export interface ViewController<TSource = any, TParent = any> extends Expression
 
 // @public
 export class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
-    constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
+    constructor(html: string | HTMLTemplateElement, factories?: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy | undefined);
+    // @internal (undocumented)
+    compile(): HTMLTemplateCompilationResult<TSource, TParent>;
     create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    static create<TSource = any, TParent = any>(strings: string[], values: TemplateValue<TSource, TParent>[], policy?: DOMPolicy): ViewTemplate<TSource, TParent>;
     readonly factories: Record<string, ViewBehaviorFactory>;
     readonly html: string | HTMLTemplateElement;
+    inline(): CaptureType<TSource, TParent>;
     render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    withPolicy(policy: DOMPolicy): this;
 }
 
 // @public
 export function volatile(target: {}, name: string | Accessor, descriptor: PropertyDescriptor): PropertyDescriptor;
 
 // @public
-export function when<TSource = any, TReturn = any, TParent = any>(condition: Expression<TSource, TReturn, TParent> | boolean, templateOrTemplateBinding: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>): CaptureType<TSource, TParent>;
+export function when<TSource = any, TReturn = any, TParent = any>(condition: Expression<TSource, TReturn, TParent> | boolean, templateOrTemplateBinding: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>, elseTemplateOrTemplateBinding?: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>): CaptureType<TSource, TParent>;
 
 // Warnings were encountered during analysis:
 //
 // dist/dts/components/fast-element.d.ts:60:5 - (ae-forgotten-export) The symbol "define" needs to be exported by the entry point index.d.ts
 // dist/dts/components/fast-element.d.ts:61:5 - (ae-forgotten-export) The symbol "compose" needs to be exported by the entry point index.d.ts
 // dist/dts/components/fast-element.d.ts:62:5 - (ae-forgotten-export) The symbol "from" needs to be exported by the entry point index.d.ts
+// dist/dts/styles/css-binding-directive.d.ts:35:9 - (ae-forgotten-export) The symbol "CSSBindingEntry" needs to be exported by the entry point index.d.ts
 
 // (No @packageDocumentation comment for this package)