@microsoft/fast-element 2.0.0-beta.1 → 2.0.0-beta.4

package/docs/api-report.md

@@ -53,7 +53,7 @@ export const Aspect: Readonly<{
     readonly content: 4;
     readonly tokenList: 5;
     readonly event: 6;
-    readonly assign: (directive: Aspected, value: string) => void;
+    readonly assign: (directive: Aspected, value?: string) => void;
 }>;
 
 // @public
@@ -62,7 +62,7 @@ export type Aspect = typeof Aspect[Exclude<keyof typeof Aspect, "assign" | "none
 // @public
 export interface Aspected {
     aspectType: Aspect;
-    binding?: Binding;
+    dataBinding?: Binding;
     sourceAspect: string;
     targetAspect: string;
 }
@@ -104,44 +104,35 @@ export class AttributeDefinition implements Accessor {
 export type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
 
 // @public
-export interface Behavior<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = RootContext> {
-    bind(source: TSource, context: TContext): void;
-    unbind(source: TSource, context: TContext): void;
+export interface Behavior<TSource = any, TParent = any> {
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
+    unbind(source: TSource, context: ExecutionContext<TParent>): void;
 }
 
 // @public
-export function bind<T = any>(binding: Binding<T>, config?: BindingConfig | DefaultBindingOptions): CaptureType<T>;
+export function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
 
 // @public
-export type Binding<TSource = any, TReturn = any, TContext extends ExecutionContext = ExecutionContext> = (source: TSource, context: TContext) => TReturn;
-
-// @public
-export interface BindingConfig<T = any> {
-    mode: BindingMode;
-    options: T;
+export abstract class Binding<TSource = any, TReturn = any, TParent = any> {
+    abstract createObserver(directive: HTMLDirective, subscriber: Subscriber): ExpressionObserver<TSource, TReturn, TParent>;
+    evaluate: Expression<TSource, TReturn, TParent>;
+    isVolatile?: boolean;
+    options?: any;
 }
 
 // @public
-export const BindingConfig: Readonly<{
-    define<T>(mode: BindingMode, defaultOptions: T): BindingConfig<T> & BindingConfigResolver<T>;
-}>;
-
-// @public
-export type BindingConfigResolver<T> = (options: T) => BindingConfig<T>;
-
-// @public
-export type BindingMode = Record<Aspect, (directive: HTMLBindingDirective) => Pick<ViewBehaviorFactory, "createBehavior">>;
-
-// @public
-export const BindingMode: Readonly<{
-    define(UpdateType: typeof UpdateBinding, EventType?: typeof EventBinding): BindingMode;
-}>;
-
-// @public
-export interface BindingObserver<TSource = any, TReturn = any, TParent = any> extends Notifier, Disposable {
-    observe(source: TSource, context?: ExecutionContext<TParent>): TReturn;
-    records(): IterableIterator<ObservationRecord>;
-    setMode(isAsync: boolean): void;
+export class BindingBehavior implements ViewBehavior {
+    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
+    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
+    // (undocumented)
+    readonly directive: HTMLBindingDirective;
+    protected getObserver(target: Node): ExpressionObserver;
+    // @internal (undocumented)
+    handleChange(binding: Expression, observer: ExpressionObserver): void;
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+    // (undocumented)
+    protected updateTarget: UpdateTarget;
 }
 
 // @public
@@ -156,26 +147,6 @@ export type Callable = typeof Function.prototype.call | {
 export interface CaptureType<TSource> {
 }
 
-// @public
-export class ChangeBinding extends UpdateBinding {
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    protected getObserver(target: Node): BindingObserver;
-    // @internal (undocumented)
-    handleChange(binding: Binding, observer: BindingObserver): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
-
-// @public
-export const child: <TChild = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TChild, TParent, ChildContext<TParent>>[]) => ChildViewTemplate<TChild, TParent>;
-
-// @public
-export interface ChildContext<TParentSource = any> extends RootContext {
-    createItemContext(index: number, length: number): ItemContext<TParentSource>;
-    readonly parent: TParentSource;
-    readonly parentContext: ChildContext<TParentSource>;
-}
-
 // @public
 export interface ChildListDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
 }
@@ -194,13 +165,6 @@ export class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiv
 // @public
 export type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 
-// @public
-export interface ChildViewTemplate<TSource = any, TParent = any> {
-    create(): SyntheticView<TSource, TParent, ChildContext<TParent>>;
-    // (undocumented)
-    type: "child";
-}
-
 // @public
 export type CompilationStrategy = (
 html: string | HTMLTemplateElement,
@@ -209,7 +173,7 @@ factories: Record<string, ViewBehaviorFactory>) => HTMLTemplateCompilationResult
 // @public
 export const Compiler: {
     setHTMLPolicy(policy: TrustedTypesPolicy): void;
-    compile<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent, TContext>;
+    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent>;
     setDefaultStrategy(strategy: CompilationStrategy): void;
     aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
 };
@@ -227,6 +191,24 @@ export type ConstructibleStyleStrategy = {
     new (styles: (string | CSSStyleSheet)[]): StyleStrategy;
 };
 
+// @public
+export class ContentBehavior extends BindingBehavior {
+    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
+}
+
+// @public
+export interface ContentTemplate {
+    create(): ContentView;
+}
+
+// @public
+export interface ContentView {
+    bind(source: any, context: ExecutionContext): void;
+    insertBefore(node: Node): void;
+    remove(): void;
+    unbind(): void;
+}
+
 // @public
 export class Controller<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier {
     // @internal
@@ -292,15 +274,6 @@ export function customElement(nameOrDef: string | PartialFASTElementDefinition):
 // @public
 export type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
 
-// @public
-export type DefaultBindingOptions = AddEventListenerOptions;
-
-// @public
-export type DefaultTwoWayBindingOptions = DefaultBindingOptions & {
-    changeEvent?: string;
-    fromView?: (value: any) => any;
-};
-
 // @public
 export interface Disposable {
     dispose(): void;
@@ -329,6 +302,7 @@ export class ElementStyles {
     readonly behaviors: ReadonlyArray<Behavior<HTMLElement>> | null;
     // @internal (undocumented)
     isAttachedTo(target: StyleTarget): boolean;
+    static normalize(styles: ComposableStyles | ComposableStyles[] | undefined): ElementStyles | undefined;
     // @internal (undocumented)
     removeStylesFrom(target: StyleTarget): void;
     static setDefaultStrategy(Strategy: ConstructibleStyleStrategy): void;
@@ -341,7 +315,7 @@ export class ElementStyles {
 }
 
 // @public
-export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent, RootContext> {
+export interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
     appendTo(node: Node): void;
 }
 
@@ -349,15 +323,13 @@ export interface ElementView<TSource = any, TParent = any> extends View<TSource,
 export interface ElementViewTemplate<TSource = any, TParent = any> {
     create(hostBindingTarget: Element): ElementView<TSource, TParent>;
     render(source: TSource, host: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
-    // (undocumented)
-    type: "element";
 }
 
 // @public
 export const emptyArray: readonly never[];
 
 // @public
-export class EventBinding {
+export class EventBehavior {
     constructor(directive: HTMLBindingDirective);
     bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
     createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
@@ -369,14 +341,41 @@ export class EventBinding {
 }
 
 // @public
-export const ExecutionContext: Readonly<{
-    default: RootContext;
-    setEvent(event: Event | null): void;
-    create(): RootContext;
-}>;
+export class ExecutionContext<TParentSource = any> {
+    static create(): ExecutionContext;
+    createChildContext<TParentSource>(parentSource: TParentSource): ExecutionContext<TParentSource>;
+    createItemContext(index: number, length: number): ExecutionContext<TParentSource>;
+    static readonly default: ExecutionContext<any>;
+    get event(): Event;
+    eventDetail<TDetail>(): TDetail;
+    eventTarget<TTarget extends EventTarget>(): TTarget;
+    index: number;
+    get isEven(): boolean;
+    get isFirst(): boolean;
+    get isInMiddle(): boolean;
+    get isLast(): boolean;
+    get isOdd(): boolean;
+    length: number;
+    readonly parent: TParentSource;
+    readonly parentContext: ExecutionContext<TParentSource>;
+    // @internal
+    static setEvent(event: Event | null): void;
+    updatePosition(index: number, length: number): void;
+}
+
+// @public
+export type Expression<TSource = any, TReturn = any, TParent = any> = (source: TSource, context: ExecutionContext<TParent>) => TReturn;
 
 // @public
-export type ExecutionContext<TParentSource = any> = RootContext | ChildContext<TParentSource> | ItemContext<TParentSource>;
+export interface ExpressionNotifier<TSource = any, TReturn = any, TParent = any> extends Notifier, ExpressionObserver<TSource, TReturn, TParent> {
+    records(): IterableIterator<ObservationRecord>;
+    setMode(isAsync: boolean): void;
+}
+
+// @public
+export interface ExpressionObserver<TSource = any, TReturn = any, TParent = any> extends Disposable {
+    observe(source: TSource, context?: ExecutionContext<TParent>): TReturn;
+}
 
 // Warning: (ae-internal-missing-underscore) The name "FAST" should be prefixed with an underscore because the declaration is marked as @internal
 //
@@ -398,14 +397,15 @@ export const FASTElement: (new () => HTMLElement & FASTElement) & {
         new (): HTMLElement;
         prototype: HTMLElement;
     }>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
-    define<TType extends Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): TType;
+    define: typeof define;
+    compose: typeof compose;
 };
 
 // @public
 export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
-    constructor(type: TType, nameOrConfig?: PartialFASTElementDefinition | string);
     readonly attributeLookup: Record<string, AttributeDefinition>;
     readonly attributes: ReadonlyArray<AttributeDefinition>;
+    static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
     define(registry?: CustomElementRegistry): this;
     readonly elementOptions?: ElementDefinitionOptions;
     static readonly getByType: (key: Function) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
@@ -424,31 +424,27 @@ export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Co
 // @internal
 export interface FASTGlobal {
     addMessages(messages: Record<number, string>): void;
-    error(code: number, ...args: any[]): Error;
+    error(code: number, values?: Record<string, any>): Error;
     getById<T>(id: string | number): T | null;
     // (undocumented)
     getById<T>(id: string | number, initialize: () => T): T;
     readonly versions: string[];
-    warn(code: number, ...args: any[]): void;
+    warn(code: number, values?: Record<string, any>): void;
 }
 
 // @public
-export function html<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent, TContext>[]): ViewTemplate<TSource, TParent>;
+export function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
 
 // @public
 export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, Aspected {
-    constructor(binding: Binding, mode: BindingMode, options: any);
+    constructor(dataBinding: Binding);
     aspectType: Aspect;
-    // (undocumented)
-    binding: Binding;
     createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
     createHTML(add: AddViewBehaviorFactory): string;
-    id: string;
     // (undocumented)
-    mode: BindingMode;
+    dataBinding: Binding;
+    id: string;
     nodeId: string;
-    // (undocumented)
-    options: any;
     sourceAspect: string;
     targetAspect: string;
 }
@@ -474,16 +470,16 @@ export interface HTMLDirectiveDefinition<TType extends Constructable<HTMLDirecti
 }
 
 // @public
-export interface HTMLTemplateCompilationResult<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> {
-    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent, TContext>;
+export interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
+    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
 }
 
 // @public
-export class HTMLView<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent, TContext> {
+export class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent> {
     constructor(fragment: DocumentFragment, factories: ReadonlyArray<ViewBehaviorFactory>, targets: ViewBehaviorTargets);
     appendTo(node: Node): void;
-    bind(source: TSource, context: TContext): void;
-    context: TContext | null;
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
+    context: ExecutionContext<TParent> | null;
     dispose(): void;
     static disposeContiguousBatch(views: SyntheticView[]): void;
     firstChild: Node;
@@ -495,35 +491,15 @@ export class HTMLView<TSource = any, TParent = any, TContext extends ExecutionCo
 }
 
 // @public
-export const item: <TItem = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TItem, TParent, ItemContext<TParent>>[]) => ItemViewTemplate<TItem, TParent>;
-
-// @public
-export interface ItemContext<TParentSource = any> extends ChildContext<TParentSource> {
-    readonly index: number;
-    readonly isEven: boolean;
-    readonly isFirst: boolean;
-    readonly isInMiddle: boolean;
-    readonly isLast: boolean;
-    readonly isOdd: boolean;
-    readonly length: number;
-    updatePosition(index: number, length: number): void;
-}
-
-// @public
-export interface ItemViewTemplate<TSource = any, TParent = any> {
-    create(): SyntheticView<TSource, TParent, ItemContext<TParent>>;
-    // (undocumented)
-    type: "item";
+export interface LengthObserver extends Subscriber {
+    length: number;
 }
 
 // @public
-function length_2<T>(array: readonly T[]): number;
-export { length_2 as length }
+export function lengthOf<T>(array: readonly T[]): number;
 
 // @public
-export interface LengthObserver extends Subscriber {
-    length: number;
-}
+export function listener<T = any>(binding: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
 
 // @public
 export const Markup: Readonly<{
@@ -557,6 +533,9 @@ export abstract class NodeObservationDirective<T extends NodeBehaviorOptions> ex
     protected updateTarget(source: any, value: ReadonlyArray<any>): void;
 }
 
+// @public
+export function normalizeBinding<TSource = any, TReturn = any, TParent = any>(value: Expression<TSource, TReturn, TParent> | Binding<TSource, TReturn, TParent> | {}): Binding<TSource, TReturn, TParent>;
+
 // @public
 export interface Notifier {
     notify(args: any): void;
@@ -577,8 +556,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: Binding<TSource, TReturn, ExecutionContext<any>>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): BindingObserver<TSource, TReturn, any>;
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(binding: Binding<TSource_1, TReturn_1, ExecutionContext<any>>): boolean;
+    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;
 }>;
 
 // @public
@@ -591,15 +570,7 @@ export interface ObservationRecord {
 }
 
 // @public
-export const onChange: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
-
-// @public
-export const oneTime: BindingConfig<AddEventListenerOptions> & BindingConfigResolver<AddEventListenerOptions>;
-
-// @public
-export class OneTimeBinding extends UpdateBinding {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
+export function oneTime<T = any>(binding: Expression<T>): Binding<T>;
 
 // @public
 export const Parser: Readonly<{
@@ -640,58 +611,24 @@ export class RefDirective extends StatelessAttachedAttributeDirective<string> {
 }
 
 // @public
-export function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ViewTemplate | Binding<TSource, ViewTemplate, RootContext>, options?: {
-    positioning: false;
-} | {
-    recycle: true;
-} | {
-    positioning: false;
-    recycle: false;
-} | {
-    positioning: false;
-    recycle: true;
-}): CaptureType<TSource>;
-
-// @public
-export function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ChildViewTemplate | Binding<TSource, ChildViewTemplate, ChildContext>, options?: {
-    positioning: false;
-} | {
-    recycle: true;
-} | {
-    positioning: false;
-    recycle: false;
-} | {
-    positioning: false;
-    recycle: true;
-}): CaptureType<TSource>;
-
-// @public
-export function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(itemsBinding: Binding<TSource, TArray, ExecutionContext<TSource>>, templateOrTemplateBinding: ItemViewTemplate | Binding<TSource, ItemViewTemplate, ItemContext>, options: {
-    positioning: true;
-} | {
-    positioning: true;
-    recycle: true;
-} | {
-    positioning: true;
-    recycle: false;
-}): CaptureType<TSource>;
+export function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>>(items: Expression<TSource, TArray, ExecutionContext<TSource>> | Binding<TSource, TArray> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate> | Binding<TSource, ViewTemplate> | ViewTemplate, options?: RepeatOptions): CaptureType<TSource>;
 
 // @public
 export class RepeatBehavior<TSource = any> implements Behavior, Subscriber {
-    constructor(location: Node, itemsBinding: Binding<TSource, any[]>, isItemsBindingVolatile: boolean, templateBinding: Binding<TSource, SyntheticViewTemplate>, isTemplateBindingVolatile: boolean, options: RepeatOptions);
+    constructor(directive: RepeatDirective, location: Node);
     bind(source: TSource, context: ExecutionContext): void;
-    handleChange(source: any, args: Splice[]): void;
+    handleChange(source: any, args: Splice[] | ExpressionObserver): void;
     unbind(): void;
 }
 
 // @public
 export class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
-    constructor(itemsBinding: Binding, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
+    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
     createBehavior(targets: ViewBehaviorTargets): RepeatBehavior<TSource>;
     createHTML(add: AddViewBehaviorFactory): string;
-    id: string;
     // (undocumented)
-    readonly itemsBinding: Binding;
+    readonly dataBinding: Binding<TSource>;
+    id: string;
     nodeId: string;
     // (undocumented)
     readonly options: RepeatOptions;
@@ -705,24 +642,6 @@ export interface RepeatOptions {
     recycle?: boolean;
 }
 
-// @public
-export interface RootContext {
-    createChildContext<TParentSource>(source: TParentSource): ChildContext<TParentSource>;
-    readonly event: Event;
-    eventDetail<TDetail = any>(): TDetail;
-    eventTarget<TTarget extends EventTarget = EventTarget>(): TTarget;
-}
-
-// @public
-export const signal: <T = any>(options: string | Binding<T, any, ExecutionContext<any>>) => BindingConfig<string | Binding<T, any, ExecutionContext<any>>>;
-
-// @public
-export class SignalBinding extends UpdateBinding {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    static send(signal: string): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
-
 // @public
 export function slotted<T = any>(propertyOrOptions: (keyof T & string) | SlottedDirectiveOptions<keyof T & string>): CaptureType<T>;
 
@@ -830,7 +749,7 @@ export interface SubtreeDirectiveOptions<T = any> extends NodeBehaviorOptions<T>
 }
 
 // @public
-export interface SyntheticView<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> extends View<TSource, TParent, TContext> {
+export interface SyntheticView<TSource = any, TParent = any> extends View<TSource, TParent> {
     readonly firstChild: Node;
     insertBefore(node: Node): void;
     readonly lastChild: Node;
@@ -838,14 +757,12 @@ export interface SyntheticView<TSource = any, TParent = any, TContext extends Ex
 }
 
 // @public
-export interface SyntheticViewTemplate<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> {
-    create(): SyntheticView<TSource, TParent, TContext>;
-    // (undocumented)
-    type: "synthetic";
+export interface SyntheticViewTemplate<TSource = any, TParent = any> {
+    create(): SyntheticView<TSource, TParent>;
 }
 
 // @public
-export type TemplateValue<TSource, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> = Binding<TSource, any, TContext> | HTMLDirective | CaptureType<TSource>;
+export type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource>;
 
 // @public
 export type TrustedTypes = {
@@ -857,23 +774,6 @@ export type TrustedTypesPolicy = {
     createHTML(html: string): string;
 };
 
-// @public
-export const twoWay: BindingConfig<DefaultTwoWayBindingOptions> & BindingConfigResolver<DefaultTwoWayBindingOptions>;
-
-// @public
-export class TwoWayBinding extends ChangeBinding {
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    static configure(settings: TwoWaySettings): void;
-    // @internal (undocumented)
-    handleEvent(event: Event): void;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-}
-
-// @public
-export interface TwoWaySettings {
-    determineChangeEvent(directive: HTMLBindingDirective, target: HTMLElement): string;
-}
-
 // Warning: (ae-internal-missing-underscore) The name "TypeDefinition" should be prefixed with an underscore because the declaration is marked as @internal
 //
 // @internal
@@ -894,18 +794,6 @@ export interface TypeRegistry<TDefinition extends TypeDefinition> {
     register(definition: TDefinition): boolean;
 }
 
-// @public
-export class UpdateBinding implements ViewBehavior {
-    constructor(directive: HTMLBindingDirective, updateTarget: UpdateTarget);
-    bind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    createBehavior(targets: ViewBehaviorTargets): ViewBehavior;
-    // (undocumented)
-    readonly directive: HTMLBindingDirective;
-    unbind(source: any, context: ExecutionContext, targets: ViewBehaviorTargets): void;
-    // (undocumented)
-    protected updateTarget: UpdateTarget;
-}
-
 // @public
 export interface UpdateQueue {
     enqueue(callable: Callable): void;
@@ -932,9 +820,9 @@ export interface ValueConverter {
 }
 
 // @public
-export interface View<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext<TParent>> extends Disposable {
-    bind(source: TSource, context: TContext): void;
-    readonly context: TContext | null;
+export interface View<TSource = any, TParent = any> extends Disposable {
+    bind(source: TSource, context: ExecutionContext<TParent>): void;
+    readonly context: ExecutionContext<TParent> | null;
     readonly source: TSource | null;
     unbind(): void;
 }
@@ -958,20 +846,24 @@ export type ViewBehaviorTargets = {
 };
 
 // @public
-export class ViewTemplate<TSource = any, TParent = any, TContext extends ExecutionContext<TParent> = ExecutionContext> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent, TContext> {
+export class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
     constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
-    create(hostBindingTarget?: Element): HTMLView<TSource, TParent, TContext>;
+    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     readonly factories: Record<string, ViewBehaviorFactory>;
     readonly html: string | HTMLTemplateElement;
-    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: TContext): HTMLView<TSource, TParent, TContext>;
-    type: any;
+    render(source: TSource, host: Node, hostBindingTarget?: Element, context?: ExecutionContext): HTMLView<TSource, TParent>;
 }
 
 // @public
 export function volatile(target: {}, name: string | Accessor, descriptor: PropertyDescriptor): PropertyDescriptor;
 
 // @public
-export function when<TSource = any, TReturn = any>(binding: Binding<TSource, TReturn>, templateOrTemplateBinding: SyntheticViewTemplate | Binding<TSource, SyntheticViewTemplate>): CaptureType<TSource>;
+export function when<TSource = any, TReturn = any>(condition: Expression<TSource, TReturn> | boolean, templateOrTemplateBinding: SyntheticViewTemplate | Expression<TSource, SyntheticViewTemplate>): CaptureType<TSource>;
+
+// Warnings were encountered during analysis:
+//
+// dist/dts/components/fast-element.d.ts:73: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:78:5 - (ae-forgotten-export) The symbol "compose" needs to be exported by the entry point index.d.ts
 
 // (No @packageDocumentation comment for this package)