@microsoft/fast-element 2.10.3 → 3.0.0-rc.1

package/docs/api-report.api.md

@@ -4,6 +4,12 @@
 
 ```ts
 
+// @public
+export interface AccessCachedPath extends CachedPathCommon {
+    // (undocumented)
+    type: "access";
+}
+
 // @public
 export interface Accessor {
     getValue(source: any): any;
@@ -11,9 +17,6 @@ export interface Accessor {
     setValue(source: any, value: any): void;
 }
 
-// @public
-export type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
-
 // @public
 export type AddViewBehaviorFactory = (factory: ViewBehaviorFactory) => string;
 
@@ -77,23 +80,22 @@ export class AttributeDefinition implements Accessor {
     setValue(source: HTMLElement, newValue: any): void;
 }
 
-// Warning: (ae-forgotten-export) The symbol "reflectMode" needs to be exported by the entry point index.d.ts
-// Warning: (ae-forgotten-export) The symbol "booleanMode" needs to be exported by the entry point index.d.ts
-//
 // @public
-export type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
+export type AttributeMode = "reflect" | "boolean" | "fromView";
 
 // @public
 export abstract class Binding<TSource = any, TReturn = any, TParent = any> {
-    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy | undefined, isVolatile?: boolean);
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy_2 | undefined, isVolatile?: boolean);
     abstract createObserver(subscriber: Subscriber, directive: BindingDirective): ExpressionObserver<TSource, TReturn, TParent>;
     // (undocumented)
     evaluate: Expression<TSource, TReturn, TParent>;
     // (undocumented)
     isVolatile: boolean;
     options?: any;
+    // Warning: (ae-forgotten-export) The symbol "DOMPolicy_2" needs to be exported by the entry point index.d.ts
+    //
     // (undocumented)
-    policy?: DOMPolicy | undefined;
+    policy?: DOMPolicy_2 | undefined;
 }
 
 // @public
@@ -106,13 +108,29 @@ export interface BindingDirective {
 // @public
 export const booleanConverter: ValueConverter;
 
+// @public
+export type CachedPath = DefaultCachedPath | RepeatCachedPath | AccessCachedPath | EventCachedPath;
+
+// @public
+export interface CachedPathCommon {
+    // (undocumented)
+    currentContext: string | null;
+    // (undocumented)
+    parentContext: string | null;
+    // (undocumented)
+    path: string;
+}
+
+// @public
+export type CachedPathMap = Map<string, Map<string, JSONSchema>>;
+
 // @public
 export type Callable = typeof Function.prototype.call | {
     call(): void;
 };
 
 // @public
-export interface CaptureType<TSource, TParent> {
+export interface CaptureType {
 }
 
 // @public
@@ -120,7 +138,7 @@ export interface ChildListDirectiveOptions<T = any> extends NodeBehaviorOptions<
 }
 
 // @public
-export function children<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
+export function children<TSource = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType;
 
 // @public
 export class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiveOptions> {
@@ -133,6 +151,14 @@ export class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiv
 // @public
 export type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 
+// @public
+export interface ChildrenMap {
+    // (undocumented)
+    attributeName: string;
+    // (undocumented)
+    customElementName: string;
+}
+
 // @public
 export type Class<T, C = {}> = C & Constructable<T> & {
     readonly prototype: T;
@@ -142,21 +168,49 @@ export type Class<T, C = {}> = C & Constructable<T> & {
 export type CompilationStrategy = (
 html: string | HTMLTemplateElement,
 factories: Record<string, ViewBehaviorFactory>,
-policy: DOMPolicy) => HTMLTemplateCompilationResult;
+policy: DOMPolicy_2) => HTMLTemplateCompilationResult;
 
 // @public
 export type CompiledViewBehaviorFactory = Required<ViewBehaviorFactory>;
 
 // @public
 export const Compiler: {
-    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy): HTMLTemplateCompilationResult<TSource, TParent>;
+    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy_2): HTMLTemplateCompilationResult<TSource, TParent>;
     setDefaultStrategy(strategy: CompilationStrategy): void;
-    aggregate(parts: (string | ViewBehaviorFactory)[], policy?: DOMPolicy): ViewBehaviorFactory;
+    aggregate(parts: (string | ViewBehaviorFactory)[], policy?: DOMPolicy_2): ViewBehaviorFactory;
 };
 
 // @public
 export type ComposableStyles = string | ElementStyles | CSSStyleSheet;
 
+// @public
+export function composedContains(reference: HTMLElement, test: HTMLElement): boolean;
+
+// @public
+export function composedParent<T extends HTMLElement>(element: T): HTMLElement | null;
+
+// @beta
+export type ComputedBuilder = {
+    on: {
+        setup(callback: ComputedSetupCallback): void;
+    };
+};
+
+// @beta
+export type ComputedInitializer<T> = (builder: ComputedBuilder) => () => T;
+
+// @beta
+export type ComputedSetupCallback = () => (() => void) | void;
+
+// @beta
+export type ComputedState<T> = ReadonlyState<T> & Disposable & {
+    subscribe(subscriber: Subscriber): void;
+    unsubscribe(subscriber: Subscriber): void;
+};
+
+// @beta
+export function computedState<T>(initialize: ComputedInitializer<T>, name?: string): ComputedState<T>;
+
 // @public
 export type Constructable<T = {}> = {
     new (...args: any[]): T;
@@ -185,30 +239,9 @@ export interface ContentView {
 // @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;
+    createCSS(): ComposableStyles;
 }
 
 // @public
@@ -227,12 +260,12 @@ export interface CSSDirectiveDefinition<TType extends Constructable<CSSDirective
 }
 
 // @public
-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;
+export type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: CSSValue[]) => ElementStyles) & {
+    partial(strings: TemplateStringsArray, ...values: CSSValue[]): CSSDirective;
 };
 
 // @public
-export type CSSValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | ComposableStyles | CSSDirective;
+export type CSSValue = ComposableStyles | CSSDirective;
 
 // @public
 export function customElement(nameOrDef: string | PartialFASTElementDefinition): (type: Constructable<HTMLElement>) => void;
@@ -240,8 +273,27 @@ export function customElement(nameOrDef: string | PartialFASTElementDefinition):
 // @public
 export type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
 
-// @beta
-export const deferHydrationAttribute = "defer-hydration";
+// @public
+export interface DefaultCachedPath extends CachedPathCommon {
+    // (undocumented)
+    type: "default";
+}
+
+// @public
+export class DefaultExecutionContext<TParent> implements ExecutionContext<TParent> {
+    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: TParent;
+    readonly parentContext: ExecutionContext<TParent>;
+}
 
 // @public
 export interface Disposable {
@@ -250,8 +302,8 @@ export interface Disposable {
 
 // @public
 export const DOM: Readonly<{
-    readonly policy: DOMPolicy;
-    setPolicy(value: DOMPolicy): void;
+    readonly policy: DOMPolicy_2;
+    setPolicy(value: DOMPolicy_2): void;
     setAttribute(element: HTMLElement, attributeName: string, value: any): void;
     setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
 }>;
@@ -271,22 +323,50 @@ export const DOMAspect: Readonly<{
 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;
-}
+export type DOMAspectGuards = {
+    [DOMAspect.attribute]?: DOMSinkGuards;
+    [DOMAspect.booleanAttribute]?: DOMSinkGuards;
+    [DOMAspect.property]?: DOMSinkGuards;
+    [DOMAspect.content]?: DOMSinkGuards;
+    [DOMAspect.tokenList]?: DOMSinkGuards;
+    [DOMAspect.event]?: DOMSinkGuards;
+};
+
+// @public
+export type DOMElementGuards = Record<string, DOMAspectGuards>;
+
+// @public
+export type DOMGuards = {
+    elements: DOMElementGuards;
+    aspects: DOMAspectGuards;
+};
+
+// @public
+export const DOMPolicy: Readonly<{
+    create(options?: DOMPolicyOptions): Readonly<DOMPolicy_2>;
+}>;
+
+// @public
+export type DOMPolicyOptions = {
+    trustedType?: TrustedTypesPolicy;
+    guards?: Partial<DOMGuards>;
+};
 
 // @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> {
+export type DOMSinkGuards = Record<string, (tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink) => DOMSink>;
+
+// @public
+export class ElementController<TElement extends HTMLElement = HTMLElement> implements Notifier, HostController<TElement> {
     // @internal
     constructor(element: TElement, definition: FASTElementDefinition);
     addBehavior(behavior: HostBehavior<TElement>): void;
     addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
     protected behaviors: Map<HostBehavior<TElement>, number> | null;
     protected bindObservables(): void;
+    protected captureBoundObservables(): void;
     connect(): void;
     protected connectBehaviors(): void;
     get context(): ExecutionContext;
@@ -296,11 +376,17 @@ export class ElementController<TElement extends HTMLElement = HTMLElement> exten
     emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
     static forCustomElement(element: HTMLElement, override?: boolean): ElementController;
     protected hasExistingShadowRoot: boolean;
+    // @internal
+    static installHydrationHook(hook: (controller: ElementController, template: ElementViewTemplate, element: HTMLElement, host: Node) => boolean): void;
     get isBound(): boolean;
     get isConnected(): boolean;
+    readonly isHydrated: Promise<boolean>;
+    readonly isPrerendered: Promise<boolean>;
     get mainStyles(): ElementStyles | null;
     set mainStyles(value: ElementStyles | null);
     protected needsInitialization: boolean;
+    notify(args: any): void;
+    protected observeLateAttributes(): void;
     onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
     onUnbind(behavior: {
         unbind(controller: ExpressionController<TElement>): any;
@@ -314,8 +400,12 @@ export class ElementController<TElement extends HTMLElement = HTMLElement> exten
     readonly source: TElement;
     get sourceLifetime(): SourceLifetime | undefined;
     protected stage: Stages;
+    get subject(): TElement;
+    subscribe(subscriber: Subscriber, propertyToWatch?: any): void;
+    protected syncLateAttributes(): void;
     get template(): ElementViewTemplate<TElement> | null;
     set template(value: ElementViewTemplate<TElement> | null);
+    unsubscribe(subscriber: Subscriber, propertyToUnwatch?: any): void;
     readonly view: ElementView<TElement> | null;
 }
 
@@ -336,7 +426,6 @@ export class ElementStyles {
     constructor(styles: ReadonlyArray<ComposableStyles>);
     // @internal (undocumented)
     addStylesTo(target: StyleTarget): void;
-    readonly behaviors: ReadonlyArray<HostBehavior<HTMLElement>> | null;
     // @internal (undocumented)
     isAttachedTo(target: StyleTarget): boolean;
     static normalize(styles: ComposableStyles | ComposableStyles[] | undefined): ElementStyles | undefined;
@@ -347,7 +436,6 @@ export class ElementStyles {
     // (undocumented)
     readonly styles: ReadonlyArray<ComposableStyles>;
     static readonly supportsAdoptedStyleSheets: boolean;
-    withBehaviors(...behaviors: HostBehavior<HTMLElement>[]): this;
     withStrategy(Strategy: ConstructibleStyleStrategy): this;
 }
 
@@ -369,6 +457,15 @@ export interface ElementViewTemplate<TSource = any, TParent = any> {
 // @public
 export const emptyArray: readonly never[];
 
+// @public
+export function enableDebug(): void;
+
+// @public
+export interface EventCachedPath extends CachedPathCommon {
+    // (undocumented)
+    type: "event";
+}
+
 // @public
 export interface ExecutionContext<TParent = any> {
     readonly event: Event;
@@ -419,7 +516,11 @@ export interface ExpressionObserver<TSource = any, TReturn = any, TParent = any>
 }
 
 // @public
-export const FAST: FASTGlobal;
+export const FAST: {
+    warn(_code: number, _values?: Record<string, any>): void;
+    error(code: number, _values?: Record<string, any>): Error;
+    addMessages(messages: Record<number, string>): void;
+};
 
 // @public
 export interface FASTElement extends HTMLElement {
@@ -435,7 +536,6 @@ export const FASTElement: {
     new (): FASTElement;
     define: typeof define;
     compose: typeof compose;
-    defineAsync: typeof defineAsync;
     from: typeof from;
 };
 
@@ -443,10 +543,8 @@ export const FASTElement: {
 export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
     readonly attributeLookup: Record<string, AttributeDefinition>;
     readonly attributes: ReadonlyArray<AttributeDefinition>;
-    static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
-    // @alpha
-    static composeAsync<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): Promise<FASTElementDefinition<TType>>;
-    define(registry?: CustomElementRegistry): this;
+    static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
+    define(registry?: CustomElementRegistry, extensions?: FASTElementExtension[]): this;
     readonly elementOptions: ElementDefinitionOptions;
     static readonly getByType: (key: Function) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
     static readonly getForInstance: (object: any) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
@@ -456,33 +554,27 @@ export class FASTElementDefinition<TType extends Constructable<HTMLElement> = Co
     readonly name: string;
     readonly propertyLookup: Record<string, AttributeDefinition>;
     // @alpha
-    static registerAsync: (name: string) => Promise<Function>;
+    static register: (name: string, registry?: CustomElementRegistry) => Promise<Function>;
     // @internal
     static registerBaseType(type: Function): void;
     readonly registry: CustomElementRegistry;
+    schema?: Schema;
     shadowOptions?: ShadowRootOptions;
     readonly styles?: ElementStyles;
-    template?: ElementViewTemplate;
-    // @alpha
-    templateOptions?: TemplateOptions;
+    template?: ElementViewTemplate<InstanceType<TType>>;
     readonly type: TType;
 }
 
+// @public
+export type FASTElementExtension = (definition: FASTElementDefinition) => void;
+
 // Warning: (ae-internal-missing-underscore) The name "fastElementRegistry" should be prefixed with an underscore because the declaration is marked as @internal
 //
 // @internal
 export const fastElementRegistry: TypeRegistry<FASTElementDefinition>;
 
 // @public
-export interface FASTGlobal {
-    addMessages(messages: Record<number, string>): void;
-    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, values?: Record<string, any>): void;
-}
+export type FASTElementTemplateResolver<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> = (definition: FASTElementDefinition<TType>) => ElementViewTemplate<InstanceType<TType>> | Promise<ElementViewTemplate<InstanceType<TType>>>;
 
 // @public
 export interface HostBehavior<TSource = any> {
@@ -520,7 +612,7 @@ export class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory,
     // @internal
     handleEvent(event: Event): void;
     id: string;
-    policy: DOMPolicy;
+    policy: DOMPolicy_2;
     sourceAspect: string;
     targetAspect: string;
     targetNodeId: string;
@@ -562,8 +654,6 @@ export type HTMLTemplateTag = (<TSource = any, TParent = any>(strings: TemplateS
     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);
@@ -575,12 +665,16 @@ export class HTMLView<TSource = any, TParent = any> extends DefaultExecutionCont
     firstChild: Node;
     insertBefore(node: Node): void;
     isBound: boolean;
+    isHydrated: Promise<boolean>;
+    isPrerendered: Promise<boolean>;
     lastChild: Node;
     // (undocumented)
     onUnbind(behavior: {
         unbind(controller: ViewController<TSource, TParent>): void;
     }): void;
     remove(): void;
+    // @internal
+    _skipAttrUpdates: boolean;
     source: TSource | null;
     readonly sourceLifetime: SourceLifetime;
     // (undocumented)
@@ -588,79 +682,46 @@ export class HTMLView<TSource = any, TParent = any> extends DefaultExecutionCont
     unbind(): void;
 }
 
-// @beta
-export class HydratableElementController<TElement extends HTMLElement = HTMLElement> extends ElementController<TElement> {
-    static config(callbacks: HydrationControllerCallbacks): typeof HydratableElementController;
-    connect(): void;
-    disconnect(): void;
-    static install(): void;
-    static lifecycleCallbacks: HydrationControllerCallbacks;
-    protected needsHydration?: boolean;
-    get shadowOptions(): ShadowRootOptions | undefined;
-    set shadowOptions(value: ShadowRootOptions | undefined);
+// @public
+export class InlineTemplateDirective implements HTMLDirective {
+    constructor(html: string, factories?: Record<string, ViewBehaviorFactory>);
+    createHTML(add: AddViewBehaviorFactory): string;
+    static readonly empty: InlineTemplateDirective;
 }
 
-// @public (undocumented)
-export interface HydratableView<TSource = any, TParent = any> extends ElementView, SyntheticView, DefaultExecutionContext<TParent> {
+// @public
+export interface JSONSchema extends JSONSchemaCommon {
     // (undocumented)
-    [Hydratable]: symbol;
-    // Warning: (ae-forgotten-export) The symbol "ViewNodes" needs to be exported by the entry point index.d.ts
-    //
+    $defs?: Record<string, JSONSchemaDefinition>;
     // (undocumented)
-    readonly bindingViewBoundaries: Record<string, ViewNodes>;
-    // Warning: (ae-forgotten-export) The symbol "HydrationStage" needs to be exported by the entry point index.d.ts
-    //
+    $id: string;
     // (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;
+    $schema: string;
 }
 
 // @public
-export interface HydrationControllerCallbacks<TElement extends HTMLElement = HTMLElement> {
-    elementDidHydrate?(source: TElement): void;
-    elementWillHydrate?(source: TElement): void;
-    hydrationComplete?(): void;
-    hydrationStarted?(): void;
+export interface JSONSchemaCommon {
+    $observe?: boolean;
+    // (undocumented)
+    $ref?: string;
+    // (undocumented)
+    anyOf?: Array<any>;
+    // (undocumented)
+    items?: any;
+    // (undocumented)
+    properties?: any;
+    // (undocumented)
+    type?: string;
 }
 
 // @public
-export class InlineTemplateDirective implements HTMLDirective {
-    constructor(html: string, factories?: Record<string, ViewBehaviorFactory>);
-    createHTML(add: AddViewBehaviorFactory): string;
-    static readonly empty: InlineTemplateDirective;
+export interface JSONSchemaDefinition extends JSONSchemaCommon {
+    // (undocumented)
+    $fast_context: string;
+    // (undocumented)
+    $fast_parent_contexts: Array<string>;
 }
 
-// Warning: (ae-forgotten-export) The symbol "HydrationView" needs to be exported by the entry point index.d.ts
-//
-// @beta
-export function isHydratable(view: ViewController): view is HydrationView;
-
-// Warning: (ae-forgotten-export) The symbol "HydratableSyntheticViewTemplate" needs to be exported by the entry point index.d.ts
-//
-// @beta (undocumented)
-export function isHydratable<TSource = any, TParent = any>(template: SyntheticViewTemplate<TSource, TParent>): template is HydratableSyntheticViewTemplate<TSource, TParent>;
-
-// Warning: (ae-forgotten-export) The symbol "HydratableElementViewTemplate" needs to be exported by the entry point index.d.ts
-//
-// @beta (undocumented)
-export function isHydratable<TSource = any, TParent = any>(template: ElementViewTemplate<TSource, TParent>): template is HydratableElementViewTemplate<TSource, TParent>;
-
-// Warning: (ae-forgotten-export) The symbol "HydratableContentTemplate" needs to be exported by the entry point index.d.ts
-//
-// @beta (undocumented)
-export function isHydratable(template: ContentTemplate): template is HydratableContentTemplate;
-
 // @public
 export interface LengthObserver extends Subscriber {
     length: number;
@@ -679,9 +740,6 @@ export const Markup: Readonly<{
     comment: (id: string) => string;
 }>;
 
-// @public
-export const needsHydrationAttribute = "needs-hydration";
-
 // @public
 export interface NodeBehaviorOptions<T = any> {
     filter?: ElementsFilter;
@@ -743,10 +801,19 @@ export interface ObservationRecord {
 }
 
 // @public
-export function oneTime<T = any>(expression: Expression<T>, policy?: DOMPolicy): Binding<T>;
+export function oneTime<T = any>(expression: Expression<T>, policy?: DOMPolicy_2): Binding<T>;
 
 // @public
-export function oneWay<T = any>(expression: Expression<T>, policy?: DOMPolicy, isVolatile?: boolean): Binding<T>;
+export function oneWay<T = any>(expression: Expression<T>, policy?: DOMPolicy_2, isVolatile?: boolean): Binding<T>;
+
+// @beta
+export type OwnedState<T> = ReadonlyOwnedState<T> & {
+    set(owner: any, value: T): void;
+    asReadonly(): ReadonlyOwnedState<T>;
+};
+
+// @beta
+export function ownedState<T>(value: T | (() => T), options?: string | StateOptions): OwnedState<T>;
 
 // @public
 export const Parser: Readonly<{
@@ -754,17 +821,16 @@ export const Parser: Readonly<{
 }>;
 
 // @public
-export interface PartialFASTElementDefinition {
+export interface PartialFASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
     readonly attributes?: (AttributeConfiguration | string)[];
     readonly elementOptions?: ElementDefinitionOptions;
     readonly lifecycleCallbacks?: TemplateLifecycleCallbacks;
     readonly name: string;
     readonly registry?: CustomElementRegistry;
+    readonly schema?: Schema;
     readonly shadowOptions?: Partial<ShadowRootOptions> | null;
     readonly styles?: ComposableStyles | ComposableStyles[];
-    readonly template?: ElementViewTemplate;
-    // @alpha
-    readonly templateOptions?: TemplateOptions;
+    readonly template?: ElementViewTemplate<InstanceType<TType>> | FASTElementTemplateResolver<TType>;
 }
 
 // @public
@@ -781,8 +847,22 @@ export class PropertyChangeNotifier implements Notifier {
     unsubscribe(subscriber: Subscriber, propertyToUnwatch?: string): void;
 }
 
+// @beta
+export function reactive<T>(object: T, deep?: boolean): T;
+
+// @beta
+export type ReadonlyOwnedState<T> = {
+    (owner: any): T;
+};
+
+// @beta
+export type ReadonlyState<T> = {
+    (): T;
+    readonly current: T;
+};
+
 // @public
-export const ref: <TSource = any, TParent = any>(propertyName: keyof TSource & string) => CaptureType<TSource, TParent>;
+export const ref: <TSource = any>(propertyName: keyof TSource & string) => CaptureType;
 
 // @public
 export class RefDirective extends StatelessAttachedAttributeDirective<string> {
@@ -791,13 +871,23 @@ export class RefDirective extends StatelessAttachedAttributeDirective<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>;
+export interface RegisterPathConfig {
+    // (undocumented)
+    childrenMap: ChildrenMap | null;
+    // (undocumented)
+    pathConfig: CachedPath;
+    // (undocumented)
+    rootPropertyName: 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;
 
 // @public
 export class RenderBehavior<TSource = any> implements ViewBehavior, Subscriber {
     constructor(directive: RenderDirective);
     bind(controller: ViewController): void;
-    // @internal (undocumented)
+    // @internal
     handleChange(source: any, observer: ExpressionObserver): void;
     unbind(controller: ViewController): void;
 }
@@ -817,7 +907,7 @@ export class RenderDirective<TSource = any> implements HTMLDirective, ViewBehavi
 }
 
 // @public
-export function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>, TParent = any>(items: Expression<TSource, TArray, TParent> | Binding<TSource, TArray, TParent> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate<any, TSource>> | Binding<TSource, ViewTemplate<any, TSource>> | ViewTemplate<any, TSource>, options?: RepeatOptions): CaptureType<TSource, TParent>;
+export function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>, TParent = any>(items: Expression<TSource, TArray, TParent> | Binding<TSource, TArray, TParent> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate<any, TSource>> | Binding<TSource, ViewTemplate<any, TSource>> | ViewTemplate<any, TSource>, options?: RepeatOptions): CaptureType;
 
 // @public
 export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
@@ -829,6 +919,12 @@ export class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
     views: SyntheticView[];
 }
 
+// @public
+export interface RepeatCachedPath extends CachedPathCommon {
+    // (undocumented)
+    type: "repeat";
+}
+
 // @public
 export class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory, BindingDirective {
     constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
@@ -849,6 +945,17 @@ export interface RepeatOptions {
     recycle?: boolean;
 }
 
+// @public
+export class Schema {
+    constructor(name: string);
+    addPath(config: RegisterPathConfig): void;
+    getRootProperties(): IterableIterator<string>;
+    getSchema(rootPropertyName: string): JSONSchema | null;
+}
+
+// @public
+export const schemaRegistry: CachedPathMap;
+
 // @public
 export interface ShadowRootOptions extends ShadowRootInit {
     // @beta
@@ -856,7 +963,17 @@ export interface ShadowRootOptions extends ShadowRootInit {
 }
 
 // @public
-export function slotted<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | SlottedDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
+export const Signal: Readonly<{
+    subscribe(signal: string, subscriber: Subscriber): void;
+    unsubscribe(signal: string, subscriber: Subscriber): void;
+    send(signal: string): void;
+}>;
+
+// @public
+export function signal<T = any>(expression: Expression<T>, options: string | Expression<T>, policy?: DOMPolicy_2): Binding<T>;
+
+// @public
+export function slotted<TSource = any>(propertyOrOptions: (keyof TSource & string) | SlottedDirectiveOptions<keyof TSource & string>): CaptureType;
 
 // @public
 export class SlottedDirective extends NodeObservationDirective<SlottedDirectiveOptions> {
@@ -945,6 +1062,16 @@ export const enum Stages {
     disconnecting = 2
 }
 
+// @beta
+export type State<T> = ReadonlyState<T> & {
+    current: T;
+    set(value: T): void;
+    asReadonly(): ReadonlyState<T>;
+};
+
+// @beta
+export function state<T>(value: T, options?: string | StateOptions): State<T>;
+
 // @public
 export abstract class StatelessAttachedAttributeDirective<TOptions> implements HTMLDirective, ViewBehaviorFactory, ViewBehavior {
     constructor(options: TOptions);
@@ -955,6 +1082,12 @@ export abstract class StatelessAttachedAttributeDirective<TOptions> implements H
     protected options: TOptions;
 }
 
+// @beta
+export type StateOptions = {
+    deep?: boolean;
+    name?: string;
+};
+
 // @public
 export interface StyleStrategy {
     addStylesTo(target: StyleTarget): void;
@@ -1001,31 +1134,46 @@ 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>;
+    inline(): CaptureType;
 }
 
 // @public
 export interface TemplateLifecycleCallbacks {
     elementDidDefine?(name: string): void;
+    elementDidHydrate?(source: HTMLElement): void;
+    elementDidRegister?(name: string): void;
+    elementWillHydrate?(source: HTMLElement): void;
     templateDidUpdate?(name: string): void;
+    templateWillUpdate?(name: string): void;
 }
 
-// @alpha
-export const TemplateOptions: {
-    readonly deferAndHydrate: "defer-and-hydrate";
-};
-
-// @alpha
-export type TemplateOptions = (typeof TemplateOptions)[keyof typeof TemplateOptions];
-
 // @public
-export type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
+export type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType;
 
 // @public
 export type TrustedTypesPolicy = {
     createHTML(html: string): string;
 };
 
+// @public
+export function twoWay<T = any>(expression: Expression<T>, optionsOrChangeEvent?: TwoWayBindingOptions | string, policy?: DOMPolicy_2, isBindingVolatile?: boolean): Binding<T>;
+
+// @public
+export type TwoWayBindingOptions = {
+    changeEvent?: string;
+    fromView?: (value: any) => any;
+};
+
+// @public
+export interface TwoWaySettings {
+    determineChangeEvent(bindingSource: BindingDirective, target: HTMLElement): string;
+}
+
+// @public
+export const TwoWaySettings: Readonly<{
+    configure(settings: TwoWaySettings): void;
+}>;
+
 // Warning: (ae-forgotten-export) The symbol "TypeDefinition" needs to be exported by the entry point index.d.ts
 // Warning: (ae-internal-missing-underscore) The name "TypeRegistry" should be prefixed with an underscore because the declaration is marked as @internal
 //
@@ -1039,6 +1187,17 @@ export interface TypeRegistry<TDefinition extends TypeDefinition> {
     register(definition: TDefinition): boolean;
 }
 
+// Warning: (ae-internal-missing-underscore) The name "UnobservableMutationObserver" should be prefixed with an underscore because the declaration is marked as @internal
+//
+// @internal
+export class UnobservableMutationObserver extends MutationObserver {
+    constructor(callback: MutationCallback);
+    // (undocumented)
+    observe(target: Node, options?: MutationObserverInit | undefined): void;
+    // (undocumented)
+    unobserve(target: Node): void;
+}
+
 // @public
 export interface UpdateQueue {
     enqueue(callable: Callable): void;
@@ -1074,11 +1233,24 @@ export interface ViewBehavior<TSource = any, TParent = any> {
 export interface ViewBehaviorFactory {
     createBehavior(): ViewBehavior;
     id?: string;
-    policy?: DOMPolicy;
+    policy?: DOMPolicy_2;
     targetNodeId?: string;
     targetTagName?: string | null;
 }
 
+// @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;
+}
+
+// @public
+export const ViewBehaviorOrchestrator: Readonly<{
+    create<TSource = any, TParent = any>(source: TSource): ViewBehaviorOrchestrator<TSource, TParent>;
+}>;
+
 // @public
 export type ViewBehaviorTargets = {
     [id: string]: Node;
@@ -1086,36 +1258,41 @@ export type ViewBehaviorTargets = {
 
 // @public
 export interface ViewController<TSource = any, TParent = any> extends ExpressionController<TSource, TParent> {
+    readonly isHydrated?: Promise<boolean>;
+    readonly isPrerendered?: Promise<boolean>;
+    // @internal
+    readonly _skipAttrUpdates?: boolean;
     readonly targets: ViewBehaviorTargets;
 }
 
 // @public
 export class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
-    constructor(html: string | HTMLTemplateElement, factories?: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy | undefined);
+    constructor(html: string | HTMLTemplateElement, factories?: Record<string, ViewBehaviorFactory>, policy?: DOMPolicy_2 | 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>;
+    static create<TSource = any, TParent = any>(strings: string[], values: TemplateValue<TSource, TParent>[], policy?: DOMPolicy_2): ViewTemplate<TSource, TParent>;
     readonly factories: Record<string, ViewBehaviorFactory>;
     readonly html: string | HTMLTemplateElement;
-    inline(): CaptureType<TSource, TParent>;
+    inline(): CaptureType;
     render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
-    withPolicy(policy: DOMPolicy): this;
+    withPolicy(policy: DOMPolicy_2): this;
 }
 
 // @public
 export function volatile(target: {}, name: string | Accessor, descriptor: PropertyDescriptor): PropertyDescriptor;
 
+// @beta
+export function watch(object: any, subscriber: Subscriber | ((subject: any, args: any) => void)): Disposable;
+
 // @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>, elseTemplateOrTemplateBinding?: 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;
 
 // Warnings were encountered during analysis:
 //
-// dist/dts/components/fast-element.d.ts:62: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:63: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:64:5 - (ae-forgotten-export) The symbol "defineAsync" needs to be exported by the entry point index.d.ts
-// dist/dts/components/fast-element.d.ts:65: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
+// 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
 
 // (No @packageDocumentation comment for this package)