@microsoft/fast-element 2.10.4 → 3.0.0-rc.2

package/dist/fast-element.untrimmed.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Core APIs for building standards-based Web Components with FAST Element.
+ * @packageDocumentation
+ */
+
+/**
+ * A path discovered from an access expression.
+ * @public
+ */
+export declare interface AccessCachedPath extends CachedPathCommon {
+    type: "access";
+}
+
 /**
  * Represents a getter/setter property accessor on an object.
  * @public
@@ -20,12 +33,6 @@ export declare interface Accessor {
     setValue(source: any, value: any): void;
 }
 
-/**
- * Used to add behaviors when constructing styles.
- * @public
- */
-export declare type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
-
 /**
  * Used to add behavior factories when constructing templates.
  * @public
@@ -80,7 +87,7 @@ export declare const ArrayObserver: Readonly<{
      * Enables the array observation mechanism.
      * @remarks
      * Array observation is enabled automatically when using the
-     * {@link RepeatDirective}, so calling this API manually is
+     * `RepeatDirective`, so calling this API manually is
      * not typically necessary.
      */
     readonly enable: () => void;
@@ -222,7 +229,7 @@ export declare class AttributeDefinition implements Accessor {
  * changes in the DOM, but does not reflect property changes back.
  * @public
  */
-export declare type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
+export declare type AttributeMode = "reflect" | "boolean" | "fromView";
 
 /**
  * Captures a binding expression along with related information and capabilities.
@@ -230,20 +237,29 @@ export declare type AttributeMode = typeof reflectMode | typeof booleanMode | "f
  * @public
  */
 export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
-    evaluate: Expression<TSource, TReturn, TParent>;
-    policy?: DOMPolicy | undefined;
-    isVolatile: boolean;
     /**
      * Options associated with the binding.
      */
     options?: any;
+    /**
+     * Evaluates the binding.
+     */
+    evaluate: Expression<TSource, TReturn, TParent>;
+    /**
+     * The security policy to associate with this binding.
+     */
+    policy?: DOMPolicy;
+    /**
+     * Indicates whether the binding is volatile.
+     */
+    isVolatile: boolean;
     /**
      * Creates a binding.
      * @param evaluate - Evaluates the binding.
      * @param policy - The security policy to associate with this binding.
      * @param isVolatile - Indicates whether the binding is volatile.
      */
-    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy | undefined, isVolatile?: boolean);
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy, isVolatile?: boolean);
     /**
      * Creates an observer capable of notifying a subscriber when the output of a binding changes.
      * @param subscriber - The subscriber to changes in the binding.
@@ -280,7 +296,27 @@ export declare interface BindingDirective {
  */
 export declare const booleanConverter: ValueConverter;
 
-declare const booleanMode = "boolean";
+/**
+ * A path discovered while parsing a template.
+ * @public
+ */
+export declare type CachedPath = DefaultCachedPath | RepeatCachedPath | AccessCachedPath | EventCachedPath;
+
+/**
+ * Common metadata for paths cached while parsing a template.
+ * @public
+ */
+export declare interface CachedPathCommon {
+    parentContext: string | null;
+    currentContext: string | null;
+    path: string;
+}
+
+/**
+ * A map from element names and root properties to JSON schemas.
+ * @public
+ */
+export declare type CachedPathMap = Map<string, Map<string, JSONSchema>>;
 
 /**
  * Represents a callable type such as a function or an object with a "call" method.
@@ -295,7 +331,7 @@ export declare type Callable = typeof Function.prototype.call | {
  * into templates.
  * @public
  */
-export declare interface CaptureType<TSource, TParent> {
+export declare interface CaptureType<TSource = any, TParent = any> {
 }
 
 /**
@@ -347,6 +383,15 @@ export declare class ChildrenDirective extends NodeObservationDirective<Children
  */
 export declare type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
 
+/**
+ * Describes a child custom element binding referenced by a schema path.
+ * @public
+ */
+export declare interface ChildrenMap {
+    customElementName: string;
+    attributeName: string;
+}
+
 /**
  * Represents a constructable class with a prototype.
  * @public
@@ -423,9 +468,84 @@ export declare const Compiler: {
  */
 export declare type ComposableStyles = string | ElementStyles | CSSStyleSheet;
 
-declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+/**
+ * Determines if the reference element contains the test element in a "composed" DOM tree that
+ * ignores shadow DOM boundaries.
+ *
+ * Returns true of the test element is a descendent of the reference, or exists in
+ * a shadow DOM that is a logical descendent of the reference. Otherwise returns false.
+ * @param reference - The element to test for containment against.
+ * @param test - The element being tested for containment.
+ *
+ * @public
+ */
+export declare function composedContains(reference: HTMLElement, test: HTMLElement): boolean;
+
+/**
+ * Retrieves the "composed parent" element of a node, ignoring DOM tree boundaries.
+ * When the parent of a node is a shadow-root, it will return the host
+ * element of the shadow root. Otherwise it will return the parent node or null if
+ * no parent node exists.
+ * @param element - The element for which to retrieve the composed parent
+ *
+ * @public
+ */
+export declare function composedParent<T extends HTMLElement>(element: T): HTMLElement | null;
+
+/**
+ * Provides computed state capabilities.
+ * @beta
+ */
+export declare type ComputedBuilder = {
+    /**
+     * Callbacks related to computed state.
+     */
+    on: {
+        /**
+         * Provides a setup callback for the computation.
+         * @param callback - The callback to run to setup the computation.
+         */
+        setup(callback: ComputedSetupCallback): void;
+    };
+};
+
+/**
+ * A callback that initializes the computation.
+ * @beta
+ */
+export declare type ComputedInitializer<T> = (builder: ComputedBuilder) => () => T;
 
-declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+/**
+ * A callback that enables computation setup.
+ * @beta
+ */
+export declare type ComputedSetupCallback = () => (() => void) | void;
+
+/**
+ * State whose value is computed from other dependencies.
+ * @beta
+ */
+export declare type ComputedState<T> = ReadonlyState<T> & Disposable & {
+    /**
+     * Subscribes to notification of changes in the state.
+     * @param subscriber - The object that is subscribing for change notification.
+     */
+    subscribe(subscriber: Subscriber): void;
+    /**
+     * Unsubscribes from notification of changes in the state.
+     * @param subscriber - The object that is unsubscribing from change notification.
+     */
+    unsubscribe(subscriber: Subscriber): void;
+};
+
+/**
+ * Creates a ComputedState.
+ * @param initialize - The initialization callback.
+ * @param name - A friendly name for this computation.
+ * @returns A ComputedState
+ * @beta
+ */
+export declare function computedState<T>(initialize: ComputedInitializer<T>, name?: string): ComputedState<T>;
 
 /**
  * Represents a type which can be constructed with the new operator.
@@ -492,82 +612,26 @@ export declare interface ContentView {
  * @param strings - The string fragments that are interpolated with the values.
  * @param values - The values that are interpolated with the string fragments.
  * @remarks
- * The css helper supports interpolation of strings and ElementStyle instances.
+ * The css helper supports interpolation of static composable styles and CSS directives.
  * @public
  */
 export declare const css: CSSTemplateTag;
 
 /**
- * Enables bindings in CSS.
- *
- * @public
- */
-export declare class CSSBindingDirective implements HostBehavior, Subscriber, CSSDirective, BindingDirective {
-    readonly dataBinding: Binding;
-    readonly targetAspect: string;
-    /**
-     * Creates an instance of CSSBindingDirective.
-     * @param dataBinding - The binding to use in CSS.
-     * @param targetAspect - The CSS property to target.
-     */
-    constructor(dataBinding: Binding, targetAspect: string);
-    /**
-     * Creates a CSS fragment to interpolate into the CSS document.
-     * @returns - the string to interpolate into CSS
-     */
-    createCSS(add: AddBehavior): ComposableStyles;
-    /**
-     * Executed when this behavior is attached to a controller.
-     * @param controller - Controls the behavior lifecycle.
-     */
-    addedCallback(controller: HostController<HTMLElement & {
-        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
-    }>): void;
-    /**
-     * Executed when this behavior's host is connected.
-     * @param controller - Controls the behavior lifecycle.
-     */
-    connectedCallback(controller: HostController<HTMLElement & {
-        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
-    }>): void;
-    /**
-     * Executed when this behavior is detached from a controller.
-     * @param controller - Controls the behavior lifecycle.
-     */
-    removedCallback(controller: HostController<HTMLElement & {
-        $cssBindings: Map<CSSBindingDirective, CSSBindingEntry>;
-    }>): void;
-    /**
-     * Called when a subject this instance has subscribed to changes.
-     * @param subject - The subject of the change.
-     * @param args - The event args detailing the change that occurred.
-     *
-     * @internal
-     */
-    handleChange(_: any, observer: ExpressionObserver): void;
-}
-
-declare type CSSBindingEntry = {
-    observer: ExpressionObserver;
-    controller: HostController;
-};
-
-/**
- * Directive for use in {@link css}.
+ * Directive for use in CSS templates.
  *
  * @public
  */
 export declare interface CSSDirective {
     /**
-     * Creates a CSS fragment to interpolate into the CSS document.
-     * @returns - the string to interpolate into CSS
+     * Creates static styles to interpolate into the CSS document.
+     * @returns - the styles to interpolate into CSS
      */
-    createCSS(add: AddBehavior): ComposableStyles;
+    createCSS(): ComposableStyles;
 }
 
 /**
- * Instructs the css engine to provide dynamic styles or
- * associate behaviors with styles.
+ * Instructs the css engine to provide styles during CSS template composition.
  * @public
  */
 export declare const CSSDirective: Readonly<{
@@ -610,25 +674,25 @@ export declare interface CSSDirectiveDefinition<TType extends Constructable<CSSD
  * @param strings - The string fragments that are interpolated with the values.
  * @param values - The values that are interpolated with the string fragments.
  * @remarks
- * The css helper supports interpolation of strings and ElementStyle instances.
+ * The css helper supports interpolation of static composable styles and CSS directives.
  * Use the .partial method to create partial CSS fragments.
  * @public
  */
-export declare type CSSTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]) => ElementStyles) & {
+export declare type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: CSSValue[]) => ElementStyles) & {
     /**
      * Transforms a template literal string into partial CSS.
      * @param strings - The string fragments that are interpolated with the values.
      * @param values - The values that are interpolated with the string fragments.
      * @public
      */
-    partial<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]): CSSDirective;
+    partial(strings: TemplateStringsArray, ...values: CSSValue[]): CSSDirective;
 };
 
 /**
  * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export declare type CSSValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | ComposableStyles | CSSDirective;
+export declare type CSSValue = ComposableStyles | CSSDirective;
 
 /**
  * Decorator: Defines a platform custom element based on `FASTElement`.
@@ -644,7 +708,19 @@ export declare function customElement(nameOrDef: string | PartialFASTElementDefi
  */
 export declare type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
 
-declare class DefaultExecutionContext<TParent> implements ExecutionContext<TParent> {
+/**
+ * A path discovered from a default binding.
+ * @public
+ */
+export declare interface DefaultCachedPath extends CachedPathCommon {
+    type: "default";
+}
+
+/**
+ * The default execution context for template views.
+ * @public
+ */
+export declare class DefaultExecutionContext<TParent> implements ExecutionContext<TParent> {
     /**
      * The index of the current item within a repeat context.
      */
@@ -700,20 +776,6 @@ declare class DefaultExecutionContext<TParent> implements ExecutionContext<TPare
     eventTarget<TTarget extends EventTarget>(): TTarget;
 }
 
-/**
- * The attribute used to defer hydration of an element.
- * @beta
- */
-export declare const deferHydrationAttribute = "defer-hydration";
-
-declare function define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition): TType;
-
-declare function define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): TType;
-
-declare function defineAsync<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition): Promise<FASTElementDefinition<TType>>;
-
-declare function defineAsync<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): Promise<FASTElementDefinition<TType>>;
-
 /**
  * Provides a mechanism for releasing resources.
  * @public
@@ -805,7 +867,59 @@ export declare const DOMAspect: Readonly<{
 export declare type DOMAspect = (typeof DOMAspect)[Exclude<keyof typeof DOMAspect, "none">];
 
 /**
- * A security policy that FAST can use to interact with the DOM.
+ * Aspect-specific guards for a DOM Policy.
+ * @public
+ */
+export declare type DOMAspectGuards = {
+    /**
+     * Guards for attributes.
+     */
+    [DOMAspect.attribute]?: DOMSinkGuards;
+    /**
+     * Guards for boolean attributes.
+     */
+    [DOMAspect.booleanAttribute]?: DOMSinkGuards;
+    /**
+     * Guards for properties.
+     */
+    [DOMAspect.property]?: DOMSinkGuards;
+    /**
+     * Guards for content.
+     */
+    [DOMAspect.content]?: DOMSinkGuards;
+    /**
+     * Guards for token list manipulation.
+     */
+    [DOMAspect.tokenList]?: DOMSinkGuards;
+    /**
+     * Guards for events.
+     */
+    [DOMAspect.event]?: DOMSinkGuards;
+};
+
+/**
+ * Element-specific guards for a DOM Policy.
+ * @public
+ */
+export declare type DOMElementGuards = Record<string, DOMAspectGuards>;
+
+/**
+ * Guard configuration for a DOM Policy.
+ * @public
+ */
+export declare type DOMGuards = {
+    /**
+     * Guards for specific elements.
+     */
+    elements: DOMElementGuards;
+    /**
+     * General aspect guards independent of the element type.
+     */
+    aspects: DOMAspectGuards;
+};
+
+/**
+ * A policy that controls whether values can be written to DOM sinks.
  * @public
  */
 export declare interface DOMPolicy {
@@ -824,17 +938,55 @@ export declare interface DOMPolicy {
     protect(tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink): DOMSink;
 }
 
+/**
+ * A helper for creating DOM policies.
+ * @public
+ */
+export declare const DOMPolicy: Readonly<{
+    /**
+     * Creates a new DOM Policy object.
+     * @param options - The options to use in creating the policy.
+     * @returns The newly created DOMPolicy.
+     */
+    create(options?: DOMPolicyOptions): Readonly<DOMPolicy>;
+}>;
+
+/**
+ * Options for creating a DOM Policy.
+ * @public
+ */
+export declare type DOMPolicyOptions = {
+    /**
+     * The trusted type to use for HTML creation.
+     */
+    trustedType?: TrustedTypesPolicy;
+    /**
+     * The DOM guards used to override or extend the defaults.
+     */
+    guards?: Partial<DOMGuards>;
+};
+
 /**
  * A function used to send values to a DOM sink.
  * @public
  */
 export declare type DOMSink = (target: Node, aspectName: string, value: any, ...args: any[]) => void;
 
+/**
+ * A specific DOM sink guard for a node aspect.
+ * @public
+ */
+export declare type DOMSinkGuards = Record<string, (tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink) => DOMSink>;
+
 /**
  * Controls the lifecycle and rendering of a `FASTElement`.
  * @public
  */
-export declare class ElementController<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier implements HostController<TElement> {
+export declare class ElementController<TElement extends HTMLElement = HTMLElement> implements Notifier, HostController<TElement> {
+    /**
+     * Internal notifier used to delegate subscriber management.
+     */
+    private _notifier;
     /**
      * A map of observable properties that were set on the element before upgrade.
      */
@@ -847,6 +999,26 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * Indicates whether the element has an existing shadow root (e.g. from declarative shadow DOM).
      */
     protected hasExistingShadowRoot: boolean;
+    /**
+     * Resolves the isPrerendered promise.
+     */
+    private _resolvePrerendered;
+    /**
+     * Resolves the isHydrated promise.
+     */
+    private _resolveHydrated;
+    /**
+     * Resolves `true` when the element had an existing shadow root
+     * (from SSR or declarative shadow DOM) at connect time, `false`
+     * otherwise.
+     */
+    readonly isPrerendered: Promise<boolean>;
+    /**
+     * Resolves `true` after prerendered content has been successfully
+     * hydrated, or `false` when the component is client-side rendered
+     * or hydration is not enabled.
+     */
+    readonly isHydrated: Promise<boolean>;
     /**
      * The template used to render the component.
      */
@@ -946,6 +1118,27 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * @internal
      */
     constructor(element: TElement, definition: FASTElementDefinition);
+    /**
+     * The subject that subscribers will receive notifications for.
+     */
+    get subject(): TElement;
+    /**
+     * Notifies all subscribers of a property change.
+     * @param args - The property name that changed.
+     */
+    notify(args: any): void;
+    /**
+     * Subscribes to notification of changes in the element's state.
+     * @param subscriber - The object that is subscribing for change notification.
+     * @param propertyToWatch - The name of the property to watch for changes.
+     */
+    subscribe(subscriber: Subscriber, propertyToWatch?: any): void;
+    /**
+     * Unsubscribes from notification of changes in the element's state.
+     * @param subscriber - The object that is unsubscribing from change notification.
+     * @param propertyToUnwatch - The name of the property to unsubscribe from.
+     */
+    unsubscribe(subscriber: Subscriber, propertyToUnwatch?: any): void;
     /**
      * Registers an unbind handler with the controller.
      * @param behavior - An object to call when the controller unbinds.
@@ -982,6 +1175,22 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * Binds any observables that were set before upgrade.
      */
     protected bindObservables(): void;
+    /**
+     * Captures own-properties that shadow observable accessors on the prototype so
+     * they can be rebound through the accessor before rendering.
+     */
+    protected captureBoundObservables(): void;
+    /**
+     * Synchronizes late-defined attribute-map attributes from the live DOM to the
+     * associated property values before the initial render occurs.
+     */
+    protected syncLateAttributes(): void;
+    /**
+     * Observes late-defined attribute-map attributes that the platform does not
+     * surface through attributeChangedCallback because they were added after
+     * customElements.define() completed.
+     */
+    protected observeLateAttributes(): void;
     /**
      * Connects any existing behaviors on the associated element.
      */
@@ -1018,6 +1227,11 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * If `null` is provided, any existing view will be removed.
      */
     protected renderTemplate(template: ElementViewTemplate | null | undefined): void;
+    /**
+     * Standard client-side render: clears any stale content, clones the
+     * compiled fragment, binds, and appends to the host.
+     */
+    private renderClientSide;
     /**
      * Locates or creates a controller for the specified element.
      * @param element - The element to return the controller for.
@@ -1034,6 +1248,18 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * @param strategy - The strategy to use.
      */
     static setStrategy(strategy: ElementControllerStrategy): void;
+    /**
+     * A hook that, when set, handles prerendered content hydration.
+     * Called by renderTemplate when an existing shadow root is detected.
+     * Returns true if hydration was performed, false to fall back to client-side.
+     * @internal
+     */
+    private static hydrationHook;
+    /**
+     * Installs the hydration hook. Called by enableHydration().
+     * @internal
+     */
+    static installHydrationHook(hook: (controller: ElementController, template: ElementViewTemplate, element: HTMLElement, host: Node) => boolean): void;
 }
 
 /**
@@ -1066,10 +1292,6 @@ export declare class ElementStyles {
     readonly styles: ReadonlyArray<ComposableStyles>;
     private targets;
     private _strategy;
-    /**
-     * The behaviors associated with this set of styles.
-     */
-    readonly behaviors: ReadonlyArray<HostBehavior<HTMLElement>> | null;
     /**
      * Gets the StyleStrategy associated with these element styles.
      */
@@ -1085,11 +1307,6 @@ export declare class ElementStyles {
     removeStylesFrom(target: StyleTarget): void;
     /** @internal */
     isAttachedTo(target: StyleTarget): boolean;
-    /**
-     * Associates behaviors with this set of styles.
-     * @param behaviors - The behaviors to associate.
-     */
-    withBehaviors(...behaviors: HostBehavior<HTMLElement>[]): this;
     /**
      * Sets the strategy that handles adding/removing these styles for an element.
      * @param strategy - The strategy to use.
@@ -1164,6 +1381,20 @@ export declare interface ElementViewTemplate<TSource = any, TParent = any> {
  */
 export declare const emptyArray: readonly never[];
 
+/**
+ * Enables human-readable FAST debug messages.
+ * @public
+ */
+export declare function enableDebug(): void;
+
+/**
+ * A path discovered from an event binding.
+ * @public
+ */
+export declare interface EventCachedPath extends CachedPathCommon {
+    type: "event";
+}
+
 /**
  * Provides additional contextual information available to behaviors and expressions.
  * @public
@@ -1232,7 +1463,7 @@ export declare const ExecutionContext: Readonly<{
     /**
      * A default execution context.
      */
-    default: ExecutionContext<any>;
+    default: ExecutionContext;
     /**
      * Gets the current event.
      * @returns An event object.
@@ -1323,10 +1554,28 @@ export declare interface ExpressionObserver<TSource = any, TReturn = any, TParen
 }
 
 /**
- * The FAST global.
+ * The FAST messaging API for warnings and errors.
  * @public
  */
-export declare const FAST: FASTGlobal;
+export declare const FAST: {
+    /**
+     * Sends a warning to the developer.
+     * @param code - The warning code to send.
+     * @param values - Values relevant for the warning message.
+     */
+    warn(_code: number, _values?: Record<string, any>): void;
+    /**
+     * Creates an error from a code.
+     * @param code - The error code.
+     * @param values - Values relevant for the error message.
+     */
+    error(code: number, _values?: Record<string, any>): Error;
+    /**
+     * Adds debug messages for errors and warnings.
+     * @param messages - The message dictionary to add.
+     */
+    addMessages(messages: Record<number, string>): void;
+};
 
 /**
  * Represents a custom element based on the FASTElement infrastructure.
@@ -1378,13 +1627,49 @@ export declare interface FASTElement extends HTMLElement {
  * static helpers for working with FASTElements.
  * @public
  */
-export declare const FASTElement: {
+export declare const FASTElement: FASTElementConstructor;
+
+/**
+ * The FASTElement constructor and static registration helpers.
+ * @public
+ */
+export declare interface FASTElementConstructor {
+    /**
+     * Creates a FASTElement instance.
+     */
     new (): FASTElement;
-    define: typeof define;
-    compose: typeof compose;
-    defineAsync: typeof defineAsync;
-    from: typeof from;
-};
+    /**
+     * Defines a platform custom element based on the provided type and definition.
+     * @param nameOrDef - The name of the element to define or a definition object.
+     * @param extensions - Optional callbacks to run before registration.
+     */
+    define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition<TType>, extensions?: FASTElementExtension[]): Promise<TType>;
+    /**
+     * Defines a platform custom element based on the provided type and definition.
+     * @param type - The custom element type to define.
+     * @param nameOrDef - The name of the element to define or a definition object.
+     * @param extensions - Optional callbacks to run before registration.
+     */
+    define<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>, extensions?: FASTElementExtension[]): Promise<TType>;
+    /**
+     * Composes FASTElement metadata without registering the element.
+     * @param nameOrDef - The name of the element to compose or a definition object.
+     */
+    compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
+    /**
+     * Composes FASTElement metadata without registering the element.
+     * @param type - The custom element type to compose.
+     * @param nameOrDef - The name of the element to compose or a definition object.
+     */
+    compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
+    /**
+     * Creates a new FASTElement base class inherited from the provided base type.
+     * @param BaseType - The base element type to inherit from.
+     */
+    from<TBase extends typeof HTMLElement>(BaseType: TBase): {
+        new (): InstanceType<TBase> & FASTElement;
+    };
+}
 
 /**
  * Defines metadata for a FASTElement.
@@ -1419,12 +1704,7 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
     /**
      * The template to render for the custom element.
      */
-    template?: ElementViewTemplate;
-    /**
-     * The template options.
-     * @alpha
-     */
-    templateOptions?: TemplateOptions;
+    template?: ElementViewTemplate<InstanceType<TType>>;
     /**
      * The styles to associate with the custom element.
      */
@@ -1445,6 +1725,12 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
      * Lifecycle callbacks for template events.
      */
     readonly lifecycleCallbacks?: TemplateLifecycleCallbacks;
+    /**
+     * The optional schema associated with the custom element definition.
+     * Declarative templates assign this automatically during template resolution.
+     * Non-declarative callers can provide one for schema-driven extensions.
+     */
+    schema?: Schema;
     /**
      * The definition has been registered to the FAST element registry.
      */
@@ -1453,17 +1739,19 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
     /**
      * Defines a custom element based on this definition.
      * @param registry - The element registry to define the element in.
+     * @param extensions - An optional array of extension callbacks to invoke
+     * with this definition before platform registration.
      * @remarks
      * This operation is idempotent per registry.
      */
-    define(registry?: CustomElementRegistry): this;
+    define(registry?: CustomElementRegistry, extensions?: FASTElementExtension[]): this;
     /**
      * Creates an instance of FASTElementDefinition.
      * @param type - The type this definition is being created for.
      * @param nameOrDef - The name of the element to define or a config object
      * that describes the element to define.
      */
-    static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+    static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition<TType>): Promise<FASTElementDefinition<TType>>;
     /**
      * Registers a FASTElement base type.
      * @param type - The type to register as a base type.
@@ -1485,64 +1773,31 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
      * @param name - The name of the defined custom element.
      * @alpha
      */
-    static registerAsync: (name: string) => Promise<Function>;
-    /**
-     * Creates an instance of FASTElementDefinition asynchronously. This option assumes
-     * that a template and shadowOptions will be provided and completes when those requirements
-     * are met.
-     * @param type - The type this definition is being created for.
-     * @param nameOrDef - The name of the element to define or a config object
-     * that describes the element to define.
-     * @alpha
-     */
-    static composeAsync<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): Promise<FASTElementDefinition<TType>>;
+    static register: (name: string, registry?: CustomElementRegistry) => Promise<Function>;
 }
 
 /**
- * The FAST custom element registry
- * @internal
+ * A callback that receives a FASTElementDefinition during element registration.
+ * Extensions are invoked before the element is registered with the platform,
+ * allowing plugins to inspect or act on the resolved definition.
+ * @public
  */
-export declare const fastElementRegistry: TypeRegistry<FASTElementDefinition>;
+export declare type FASTElementExtension = (definition: FASTElementDefinition) => void;
 
 /**
- * The FAST global.
+ * The FAST custom element registry.
+ * @remarks
+ * This registry stores FAST element definitions by constructor so consumers can
+ * look up the `FASTElementDefinition` associated with an element type or instance.
  * @public
  */
-export declare interface FASTGlobal {
-    /**
-     * The list of loaded versions.
-     */
-    readonly versions: string[];
-    /**
-     * Gets a kernel value.
-     * @param id - The id to get the value for.
-     * @param initialize - Creates the initial value for the id if not already existing.
-     */
-    getById<T>(id: string | number): T | null;
-    getById<T>(id: string | number, initialize: () => T): T;
-    /**
-     * Sends a warning to the developer.
-     * @param code - The warning code to send.
-     * @param values - Values relevant for the warning message.
-     */
-    warn(code: number, values?: Record<string, any>): void;
-    /**
-     * Creates an error.
-     * @param code - The error code to send.
-     * @param values - Values relevant for the error message.
-     */
-    error(code: number, values?: Record<string, any>): Error;
-    /**
-     * Adds debug messages for errors and warnings.
-     * @param messages - The message dictionary to add.
-     * @remarks
-     * Message can include placeholders like $\{name\} which can be
-     * replaced by values passed at runtime.
-     */
-    addMessages(messages: Record<number, string>): void;
-}
+export declare const fastElementRegistry: TypeRegistry<FASTElementDefinition>;
 
-declare function from<TBase extends typeof HTMLElement>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
+/**
+ * Resolves an element template from a composed definition.
+ * @public
+ */
+export declare type FASTElementTemplateResolver<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> = (definition: FASTElementDefinition<TType>) => ElementViewTemplate<InstanceType<TType>> | Promise<ElementViewTemplate<InstanceType<TType>>>;
 
 /**
  * Represents an object that can contribute behavior to a host.
@@ -1636,7 +1891,6 @@ export declare const html: HTMLTemplateTag;
  * @public
  */
 export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected, BindingDirective {
-    dataBinding: Binding;
     private data;
     private updateTarget;
     /**
@@ -1667,6 +1921,10 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
      * The type of aspect to target.
      */
     aspectType: DOMAspect;
+    /**
+     * The binding configuration to apply.
+     */
+    dataBinding: Binding;
     /**
      * Creates an instance of HTMLBindingDirective.
      * @param dataBinding - The binding configuration to apply.
@@ -1841,6 +2099,24 @@ export declare class HTMLView<TSource = any, TParent = any> extends DefaultExecu
      * Indicates how the source's lifetime relates to the controller's lifetime.
      */
     readonly sourceLifetime: SourceLifetime;
+    /**
+     * When true, directives skip attribute/booleanAttribute DOM
+     * updates during bind(). Set only during the prerendered bind
+     * window and cleared immediately after.
+     * @internal
+     */
+    _skipAttrUpdates: boolean;
+    /**
+     * A promise that resolves with `true` after prerendered content
+     * has been hydrated, or `false` when the view is client-side
+     * rendered. Resolves once the first bind completes.
+     */
+    isPrerendered: Promise<boolean>;
+    /**
+     * Resolves `true` after prerendered content has been hydrated,
+     * `false` when client-side rendered or hydration not enabled.
+     */
+    isHydrated: Promise<boolean>;
     /**
      * The execution context the view is running within.
      */
@@ -1908,228 +2184,7 @@ export declare class HTMLView<TSource = any, TParent = any> extends DefaultExecu
      * Efficiently disposes of a contiguous range of synthetic view instances.
      * @param views - A contiguous range of views to be disposed.
      */
-    static disposeContiguousBatch(views: SyntheticView[]): void;
-}
-
-/**
- * @internal
- */
-declare const Hydratable: unique symbol;
-
-declare interface HydratableContentTemplate extends ContentTemplate {
-    /**
-     * Hydrates a content view from first/last nodes.
-     */
-    hydrate(first: Node, last: Node): ContentView;
-}
-
-/**
- * An ElementController capable of hydrating FAST elements from
- * Declarative Shadow DOM.
- *
- * @beta
- */
-export declare class HydratableElementController<TElement extends HTMLElement = HTMLElement> extends ElementController<TElement> {
-    /**
-     * Controls whether the controller will hydrate during the connect() method.
-     * Initialized during the first connect() call to true when the `needs-hydration`
-     * attribute is present on the element.
-     */
-    protected needsHydration?: boolean;
-    private static hydrationObserver;
-    /**
-     * {@inheritdoc ElementController.shadowOptions}
-     */
-    get shadowOptions(): ShadowRootOptions | undefined;
-    set shadowOptions(value: ShadowRootOptions | undefined);
-    /**
-     * Lifecycle callbacks for hydration events
-     */
-    static lifecycleCallbacks: HydrationControllerCallbacks;
-    /**
-     * Whether the hydrationStarted callback has already been invoked.
-     */
-    private static hydrationStarted;
-    /**
-     * An idle callback ID used to track hydration completion
-     */
-    private static idleCallbackId;
-    /**
-     * Adds the current element instance to the hydrating instances map
-     */
-    private addHydratingInstance;
-    /**
-     * Configure lifecycle callbacks for hydration events
-     */
-    static config(callbacks: HydrationControllerCallbacks): typeof HydratableElementController;
-    private static hydrationObserverHandler;
-    /**
-     * Checks to see if hydration is complete and if so, invokes the hydrationComplete callback.
-     * Then resets the ElementController strategy to the default so that future elements
-     * don't use the HydratableElementController.
-     *
-     * @param deadline - the idle deadline object
-     */
-    private static checkHydrationComplete;
-    /**
-     * Runs connected lifecycle behavior on the associated element.
-     */
-    connect(): void;
-    /**
-     * A map of element instances by the name of the custom element they are
-     * associated with. The key is the custom element name, and the value is the
-     * instances of hydratable elements which currently need to be hydrated.
-     *
-     * When all of the instances in the set have been hydrated, the set is
-     * cleared and removed from the map. If the map is empty, the
-     * hydrationComplete callback is invoked.
-     */
-    private static hydratingInstances?;
-    /**
-     * Removes the current element instance from the hydrating instances map
-     */
-    private removeHydratingInstance;
-    /**
-     * Unregisters the hydration observer when the element is disconnected.
-     */
-    disconnect(): void;
-    /**
-     * Sets the ElementController strategy to HydratableElementController.
-     * @remarks
-     * This method is typically called during application startup to enable
-     * hydration support for FAST elements.
-     */
-    static install(): void;
-}
-
-declare interface HydratableElementViewTemplate<TSource = any, TParent = any> extends ElementViewTemplate<TSource, TParent> {
-    hydrate(firstChild: Node, lastChild: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
-}
-
-declare interface HydratableSyntheticViewTemplate<TSource = any, TParent = any> extends SyntheticViewTemplate {
-    hydrate(firstChild: Node, lastChild: Node): SyntheticView<TSource, TParent>;
-}
-
-/** @public */
-export declare interface HydratableView<TSource = any, TParent = any> extends ElementView, SyntheticView, DefaultExecutionContext<TParent> {
-    [Hydratable]: symbol;
-    readonly bindingViewBoundaries: Record<string, ViewNodes>;
-    readonly hydrationStage: keyof typeof HydrationStage;
-}
-
-/** @public */
-export declare class HydrationBindingError extends Error {
-    /**
-     * The factory that was unable to be bound
-     */
-    readonly factory: ViewBehaviorFactory;
-    /**
-     * A DocumentFragment containing a clone of the
-     * view's Nodes.
-     */
-    readonly fragment: DocumentFragment;
-    /**
-     * String representation of the HTML in the template that
-     * threw the binding error.
-     */
-    readonly templateString: string;
-    constructor(
-    /**
-     * The error message
-     */
-    message: string | undefined, 
-    /**
-     * The factory that was unable to be bound
-     */
-    factory: ViewBehaviorFactory, 
-    /**
-     * A DocumentFragment containing a clone of the
-     * view's Nodes.
-     */
-    fragment: DocumentFragment, 
-    /**
-     * String representation of the HTML in the template that
-     * threw the binding error.
-     */
-    templateString: string);
-}
-
-/**
- * Lifecycle callbacks for element hydration events
- * @public
- */
-export declare interface HydrationControllerCallbacks<TElement extends HTMLElement = HTMLElement> {
-    /**
-     * Called once when the first element enters the hydration pipeline.
-     * This is the earliest point at which we know a component has been
-     * async-defined with `defer-and-hydrate`, a template is pending via
-     * `<f-template>`, and the element has `needs-hydration`.
-     */
-    hydrationStarted?(): void;
-    /**
-     * Called before an individual element's hydration begins
-     */
-    elementWillHydrate?(source: TElement): void;
-    /**
-     * Called after an individual element's hydration has finished
-     */
-    elementDidHydrate?(source: TElement): void;
-    /**
-     * Called after all elements have completed hydration
-     */
-    hydrationComplete?(): void;
-}
-
-declare const HydrationStage: {
-    readonly unhydrated: "unhydrated";
-    readonly hydrating: "hydrating";
-    readonly hydrated: "hydrated";
-};
-
-declare class HydrationView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements HydratableView {
-    readonly firstChild: Node;
-    readonly lastChild: Node;
-    private sourceTemplate;
-    private hostBindingTarget?;
-    [Hydratable]: symbol;
-    context: ExecutionContext<any>;
-    source: TSource | null;
-    isBound: boolean;
-    get hydrationStage(): "unhydrated" | "hydrating" | "hydrated";
-    get targets(): ViewBehaviorTargets;
-    get bindingViewBoundaries(): ViewBehaviorBoundaries;
-    readonly sourceLifetime: SourceLifetime;
-    private unbindables;
-    private fragment;
-    private behaviors;
-    private factories;
-    private _hydrationStage;
-    private _bindingViewBoundaries;
-    private _targets;
-    constructor(firstChild: Node, lastChild: Node, sourceTemplate: ViewTemplate, hostBindingTarget?: Element | undefined);
-    /**
-     * no-op. Hydrated views are don't need to be moved from a documentFragment
-     * to the target node.
-     */
-    insertBefore(node: Node): void;
-    /**
-     * Appends the view to a node. In cases where this is called before the
-     * view has been removed, the method will no-op.
-     * @param node - the node to append the view to.
-     */
-    appendTo(node: Node): void;
-    remove(): void;
-    bind(source: TSource, context?: ExecutionContext<any>): void;
-    unbind(): void;
-    /**
-     * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
-     * Once a view has been disposed, it cannot be inserted or bound again.
-     */
-    dispose(): void;
-    onUnbind(behavior: {
-        unbind(controller: ViewController<TSource, TParent>): void;
-    }): void;
-    private evaluateUnbindables;
+    static disposeContiguousBatch(views: SyntheticView[]): void;
 }
 
 /**
@@ -2156,20 +2211,41 @@ export declare class InlineTemplateDirective implements HTMLDirective {
 }
 
 /**
- * Tests if a template or ViewController is hydratable.
- *
- * @beta
+ * A JSON schema describing a root property.
+ * @public
  */
-export declare function isHydratable(view: ViewController): view is HydrationView;
-
-/** @beta */
-export declare function isHydratable<TSource = any, TParent = any>(template: SyntheticViewTemplate<TSource, TParent>): template is HydratableSyntheticViewTemplate<TSource, TParent>;
+export declare interface JSONSchema extends JSONSchemaCommon {
+    $schema: string;
+    $id: string;
+    $defs?: Record<string, JSONSchemaDefinition>;
+}
 
-/** @beta */
-export declare function isHydratable<TSource = any, TParent = any>(template: ElementViewTemplate<TSource, TParent>): template is HydratableElementViewTemplate<TSource, TParent>;
+/**
+ * Common properties shared by schema nodes.
+ * @public
+ */
+export declare interface JSONSchemaCommon {
+    type?: string;
+    properties?: any;
+    items?: any;
+    anyOf?: Array<any>;
+    $ref?: string;
+    /**
+     * Stamped by `applyConfigToSchema` when an `ObserverMapConfig` excludes
+     * this path. When `false`, the proxy system skips observation for this
+     * node and (if all descendants are also `false`) its subtree.
+     */
+    $observe?: boolean;
+}
 
-/** @beta */
-export declare function isHydratable(template: ContentTemplate): template is HydratableContentTemplate;
+/**
+ * A reusable JSON schema definition.
+ * @public
+ */
+export declare interface JSONSchemaDefinition extends JSONSchemaCommon {
+    $fast_context: string;
+    $fast_parent_contexts: Array<string>;
+}
 
 /**
  * Observes array lengths.
@@ -2230,12 +2306,6 @@ export declare const Markup: Readonly<{
     comment: (id: string) => string;
 }>;
 
-/**
- * The attribute used to indicate that an element needs hydration.
- * @public
- */
-export declare const needsHydrationAttribute = "needs-hydration";
-
 /**
  * Options for configuring node observation behavior.
  * @public
@@ -2435,13 +2505,13 @@ export declare const Observable: Readonly<{
      * @param initialSubscriber - An initial subscriber to changes in the binding value.
      * @param isVolatileBinding - Indicates whether the binding's dependency list must be re-evaluated on every value evaluation.
      */
-    binding<TSource = any, TReturn = any>(expression: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn, any>;
+    binding<TSource = any, TReturn = any>(expression: Expression<TSource, TReturn>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn>;
     /**
      * Determines whether a binding expression is volatile and needs to have its dependency list re-evaluated
      * on every evaluation of the value.
      * @param expression - The binding to inspect.
      */
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(expression: Expression<TSource_1, TReturn_1, any>): boolean;
+    isVolatileBinding<TSource = any, TReturn = any>(expression: Expression<TSource, TReturn>): boolean;
 }>;
 
 /**
@@ -2486,6 +2556,32 @@ export declare function oneTime<T = any>(expression: Expression<T>, policy?: DOM
  */
 export declare function oneWay<T = any>(expression: Expression<T>, policy?: DOMPolicy, isVolatile?: boolean): Binding<T>;
 
+/**
+ * A read/write stateful value associated with an owner.
+ * @beta
+ */
+export declare type OwnedState<T> = ReadonlyOwnedState<T> & {
+    /**
+     * Sets
+     * @param owner - The object to set the state for the owner.
+     * @param value - The new state value.
+     */
+    set(owner: any, value: T): void;
+    /**
+     * Creates a readonly version of the state.
+     */
+    asReadonly(): ReadonlyOwnedState<T>;
+};
+
+/**
+ * Creates a reactive state that has its value associated with a specific owner.
+ * @param value - The initial value or a factory that provides an initial value for each owner.
+ * @param options - Options to customize the state or a friendly name.
+ * @returns An OwnedState instance.
+ * @beta
+ */
+export declare function ownedState<T>(value: T | (() => T), options?: string | StateOptions): OwnedState<T>;
+
 /**
  * Common APIs related to content parsing.
  * @public
@@ -2506,20 +2602,15 @@ export declare const Parser: Readonly<{
  * Represents metadata configuration for a custom element.
  * @public
  */
-export declare interface PartialFASTElementDefinition {
+export declare interface PartialFASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
     /**
      * The name of the custom element.
      */
     readonly name: string;
     /**
-     * The template to render for the custom element.
-     */
-    readonly template?: ElementViewTemplate;
-    /**
-     * Options controlling how the template will be created.
-     * @alpha
+     * The template, or template resolver, for the custom element.
      */
-    readonly templateOptions?: TemplateOptions;
+    readonly template?: ElementViewTemplate<InstanceType<TType>> | FASTElementTemplateResolver<TType>;
     /**
      * The styles to associate with the custom element.
      */
@@ -2549,6 +2640,12 @@ export declare interface PartialFASTElementDefinition {
      * Lifecycle callbacks for template events.
      */
     readonly lifecycleCallbacks?: TemplateLifecycleCallbacks;
+    /**
+     * The optional schema associated with the custom element definition.
+     * Declarative templates assign this automatically during template resolution.
+     * Non-declarative callers can provide one for schema-driven extensions.
+     */
+    readonly schema?: Schema;
 }
 
 /**
@@ -2599,6 +2696,41 @@ export declare class PropertyChangeNotifier implements Notifier {
     unsubscribe(subscriber: Subscriber, propertyToUnwatch?: string): void;
 }
 
+/**
+ * Converts a plain object to a reactive, observable object.
+ * @param object - The object to make reactive.
+ * @param deep - Indicates whether or not to deeply convert the oject.
+ * @returns The converted object.
+ * @beta
+ */
+export declare function reactive<T>(object: T, deep?: boolean): T;
+
+/**
+ * A readonly stateful value associated with an object owner.
+ * @beta
+ */
+export declare type ReadonlyOwnedState<T> = {
+    /**
+     * Gets the current stateful value for the owner.
+     */
+    (owner: any): T;
+};
+
+/**
+ * A readonly stateful value.
+ * @beta
+ */
+export declare type ReadonlyState<T> = {
+    /**
+     * Gets the current state value.
+     */
+    (): T;
+    /**
+     * Gets the current state value.
+     */
+    readonly current: T;
+};
+
 /**
  * A directive that observes the updates a property with a reference to the element.
  * @param propertyName - The name of the property to assign the reference to.
@@ -2622,7 +2754,15 @@ export declare class RefDirective extends StatelessAttachedAttributeDirective<st
     bind(controller: ViewController): void;
 }
 
-declare const reflectMode = "reflect";
+/**
+ * Configuration for registering a path with a schema.
+ * @public
+ */
+export declare interface RegisterPathConfig {
+    rootPropertyName: string;
+    pathConfig: CachedPath;
+    childrenMap: ChildrenMap | null;
+}
 
 /**
  * Creates a RenderDirective for use in advanced rendering scenarios.
@@ -2771,6 +2911,14 @@ export declare class RepeatBehavior<TSource = any> implements ViewBehavior, Subs
     private hydrateViews;
 }
 
+/**
+ * A path discovered from a repeat directive.
+ * @public
+ */
+export declare interface RepeatCachedPath extends CachedPathCommon {
+    type: "repeat";
+}
+
 /**
  * A directive that configures list rendering.
  * @public
@@ -2817,6 +2965,108 @@ export declare interface RepeatOptions {
     recycle?: boolean;
 }
 
+/**
+ * A constructed JSON schema from a template
+ * @public
+ */
+export declare class Schema {
+    /**
+     * The name of the custom element
+     */
+    private customElementName;
+    /**
+     * Instance-level JSON schema map describing each root property
+     */
+    private schemaMap;
+    constructor(name: string);
+    /**
+     * Add a path to a schema
+     * @param config - The path registration configuration.
+     */
+    addPath(config: RegisterPathConfig): void;
+    /**
+     * Gets the JSON schema for a property name
+     * @param rootPropertyName - the root property the JSON schema is mapped to
+     * @returns The JSON schema for the root property
+     */
+    getSchema(rootPropertyName: string): JSONSchema | null;
+    /**
+     * Gets root properties
+     * @returns IterableIterator<string>
+     */
+    getRootProperties(): IterableIterator<string>;
+    /**
+     * Get a path split into property names
+     * @param path - The dot syntax path, e.g. `a.b.c`.
+     * @returns An array of items in the path
+     */
+    private getSplitPath;
+    /**
+     * Gets the path to the $def
+     * @param context - The context name. For example, `item in items` creates the `item` context.
+     * @returns A string to use as a $ref
+     */
+    private getDefsPath;
+    /**
+     * Get the schema $id
+     * @param customElementName - The custom element name
+     * @param propertyName - The property name
+     * @returns The ID that can be used in the JSON schema as $id
+     */
+    private getSchemaId;
+    /**
+     * Add a new JSON schema to the JSON schema map
+     * @param propertyName - The name of the property to assign this JSON schema to.
+     */
+    private addNewSchema;
+    /**
+     * Add properties to a context
+     * @param schema - The schema to add the properties to.
+     * @param splitPath - The path split into property/context names.
+     * @param context - The path context.
+     */
+    private addPropertiesToAContext;
+    /**
+     * Add properties to an object
+     * @param schema - The schema to add the properties to.
+     * @param splitPath - The path split into property/context names.
+     * @param context - The path context.
+     * @param type - The data type (see JSON schema for details).
+     */
+    private addPropertiesToAnObject;
+    /**
+     * Add an array to an object property
+     * @param schema - The schema to add the properties to.
+     * @param context - The name of the context.
+     */
+    private addArrayToAnObject;
+    /**
+     * Add a context to the $defs property
+     * @param schema - The schema to use.
+     * @param propertyName - The name of the property the context belongs to.
+     * @param currentContext - The current context.
+     * @param parentContext - The parent context.
+     * @returns
+     */
+    private addContext;
+    /**
+     * Get parent contexts
+     * @param schema - The schema to use.
+     * @param parentContext - The parent context.
+     * @param contexts - A list of parent contexts.
+     * @returns
+     */
+    private getParentContexts;
+}
+
+/**
+ * Module-level registry that maps custom element names to their schema maps.
+ * Used for cross-element `$ref` resolution (e.g. nested element schemas).
+ * Each Schema instance registers itself here on construction.
+ * @public
+ */
+export declare const schemaRegistry: CachedPathMap;
+
 /**
  * Shadow root initialization options.
  * @public
@@ -2830,6 +3080,40 @@ export declare interface ShadowRootOptions extends ShadowRootInit {
     registry?: CustomElementRegistry;
 }
 
+/**
+ * The gateway to signal APIs.
+ * @public
+ */
+export declare const Signal: Readonly<{
+    /**
+     * Subscribes to a signal.
+     * @param signal - The signal to subscribe to.
+     * @param subscriber - The subscriber.
+     */
+    subscribe(signal: string, subscriber: Subscriber): void;
+    /**
+     * Unsubscribes from the signal.
+     * @param signal - The signal to unsubscribe from.
+     * @param subscriber - The subscriber.
+     */
+    unsubscribe(signal: string, subscriber: Subscriber): void;
+    /**
+     * Sends the specified signal to subscribers.
+     * @param signal - The signal to send.
+     */
+    send(signal: string): void;
+}>;
+
+/**
+ * Creates a signal binding configuration with the supplied options.
+ * @param expression - The binding to refresh when signaled.
+ * @param options - The signal name or a binding to use to retrieve the signal name.
+ * @param policy - The security policy to associate with th binding.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function signal<T = any>(expression: Expression<T>, options: string | Expression<T>, policy?: DOMPolicy): Binding<T>;
+
 /**
  * A directive that observes the `assignedNodes()` of a slot and updates a property
  * whenever they change.
@@ -3091,6 +3375,35 @@ export declare const enum Stages {
     disconnected = 3
 }
 
+/**
+ * A read/write stateful value.
+ * @beta
+ */
+export declare type State<T> = ReadonlyState<T> & {
+    /**
+     * Gets or sets the current state value.
+     */
+    current: T;
+    /**
+     * Sets the current state value.
+     * @param value - The new state value.
+     */
+    set(value: T): void;
+    /**
+     * Creates a readonly version of the state.
+     */
+    asReadonly(): ReadonlyState<T>;
+};
+
+/**
+ * Creates a reactive state value.
+ * @param value - The initial state value.
+ * @param options - Options to customize the state or a friendly name.
+ * @returns A State instance.
+ * @beta
+ */
+export declare function state<T>(value: T, options?: string | StateOptions): State<T>;
+
 /**
  * A base class used for attribute directives that don't need internal state.
  * @public
@@ -3121,6 +3434,21 @@ export declare abstract class StatelessAttachedAttributeDirective<TOptions> impl
     abstract bind(controller: ViewController): void;
 }
 
+/**
+ * Options for creating state.
+ * @beta
+ */
+export declare type StateOptions = {
+    /**
+     * Indicates whether to deeply make the state value observable.
+     */
+    deep?: boolean;
+    /**
+     * A friendly name for the state.
+     */
+    name?: string;
+};
+
 /**
  * Implemented to provide specific behavior when adding/removing styles
  * for elements.
@@ -3287,29 +3615,31 @@ export declare interface SyntheticViewTemplate<TSource = any, TParent = any> {
  */
 export declare interface TemplateLifecycleCallbacks {
     /**
-     * Called after the template has been assigned to the definition
+     * Called after the JS class definition has been registered.
+     */
+    elementDidRegister?(name: string): void;
+    /**
+     * Called before the template has been evaluated and assigned.
+     */
+    templateWillUpdate?(name: string): void;
+    /**
+     * Called after the template has been assigned to the definition.
      */
     templateDidUpdate?(name: string): void;
     /**
-     * Called after the custom element has been defined
+     * Called after the custom element has been defined.
      */
     elementDidDefine?(name: string): void;
+    /**
+     * Called before an individual element's hydration begins.
+     */
+    elementWillHydrate?(source: HTMLElement): void;
+    /**
+     * Called after an individual element's hydration has finished.
+     */
+    elementDidHydrate?(source: HTMLElement): void;
 }
 
-/**
- * Values for the `templateOptions` property.
- * @alpha
- */
-export declare const TemplateOptions: {
-    readonly deferAndHydrate: "defer-and-hydrate";
-};
-
-/**
- * Type for the `TemplateOptions` const enum.
- * @alpha
- */
-export declare type TemplateOptions = (typeof TemplateOptions)[keyof typeof TemplateOptions];
-
 /**
  * Represents the types of values that can be interpolated into a template.
  * @public
@@ -3329,23 +3659,100 @@ export declare type TrustedTypesPolicy = {
 };
 
 /**
- * Do not change. Part of shared kernel contract.
- * @internal
+ * Creates a default binding.
+ * @param expression - The binding to refresh when changed.
+ * @param optionsOrChangeEvent - The binding options or the name of the change event to use.
+ * @param policy - The security policy to associate with the binding.
+ * @param isBindingVolatile - Indicates whether the binding is volatile or not.
+ * @returns A binding.
+ * @public
+ */
+export declare function twoWay<T = any>(expression: Expression<T>, optionsOrChangeEvent?: TwoWayBindingOptions | string, policy?: DOMPolicy, isBindingVolatile?: boolean): Binding<T>;
+
+/**
+ * The twoWay binding options.
+ * @public
+ */
+export declare type TwoWayBindingOptions = {
+    changeEvent?: string;
+    fromView?: (value: any) => any;
+};
+
+/**
+ * The settings required to enable two-way binding.
+ * @public
+ */
+export declare interface TwoWaySettings {
+    /**
+     * Determines which event to listen to, to detect changes in the view.
+     * @param bindingSource - The directive to determine the change event for.
+     * @param target - The target element to determine the change event for.
+     */
+    determineChangeEvent(bindingSource: BindingDirective, target: HTMLElement): string;
+}
+
+/**
+ * Enables configuring two-way binding settings.
+ * @public
+ */
+export declare const TwoWaySettings: Readonly<{
+    /**
+     * Configures two-way binding.
+     * @param settings - The settings to use for the two-way binding system.
+     */
+    configure(settings: TwoWaySettings): void;
+}>;
+
+/**
+ * A type that can be registered with a `TypeRegistry`.
+ * @public
  */
-declare interface TypeDefinition {
+export declare interface TypeDefinition {
+    /**
+     * The registered type constructor.
+     */
     type: Function;
 }
 
 /**
- * Do not change. Part of shared kernel contract.
- * @internal
+ * A registry that stores definitions by type.
+ * @public
  */
 export declare interface TypeRegistry<TDefinition extends TypeDefinition> {
+    /**
+     * Registers a type definition.
+     * @param definition - The type definition to register.
+     * @returns `true` when the definition was registered, otherwise `false`.
+     */
     register(definition: TDefinition): boolean;
+    /**
+     * Gets a definition by type.
+     * @param key - The type to retrieve the definition for.
+     */
     getByType(key: Function): TDefinition | undefined;
+    /**
+     * Gets a definition by instance.
+     * @param object - The instance to retrieve the definition for.
+     */
     getForInstance(object: any): TDefinition | undefined;
 }
 
+/**
+ * An extension of MutationObserver that supports unobserving nodes.
+ * @internal
+ */
+export declare class UnobservableMutationObserver extends MutationObserver {
+    private readonly callback;
+    private observedNodes;
+    /**
+     * Creates an instance of UnobservableMutationObserver.
+     * @param callback - The callback to invoke when observed nodes are changed.
+     */
+    constructor(callback: MutationCallback);
+    observe(target: Node, options?: MutationObserverInit | undefined): void;
+    unobserve(target: Node): void;
+}
+
 /**
  * A work queue used to synchronize writes to the DOM.
  * @public
@@ -3445,14 +3852,6 @@ export declare interface ViewBehavior<TSource = any, TParent = any> {
     bind(controller: ViewController<TSource, TParent>): void;
 }
 
-/**
- * Stores relationships between a {@link ViewBehaviorFactory} and
- * the {@link ViewBoundaries} the factory created.
- */
-declare interface ViewBehaviorBoundaries {
-    [factoryId: string]: ViewBoundaries;
-}
-
 /**
  * A factory that can create a {@link ViewBehavior} associated with a particular
  * location within a DOM fragment.
@@ -3481,6 +3880,45 @@ export declare interface ViewBehaviorFactory {
     createBehavior(): ViewBehavior;
 }
 
+/**
+ * Bridges between ViewBehaviors and HostBehaviors, enabling a host to
+ * control ViewBehaviors.
+ * @public
+ */
+export declare interface ViewBehaviorOrchestrator<TSource = any, TParent = any> extends ViewController<TSource, TParent>, HostBehavior<TSource> {
+    /**
+     *
+     * @param nodeId - The structural id of the DOM node to which a behavior will apply.
+     * @param target - The DOM node associated with the id.
+     */
+    addTarget(nodeId: string, target: Node): void;
+    /**
+     * Adds a behavior.
+     * @param behavior - The behavior to add.
+     */
+    addBehavior(behavior: ViewBehavior): void;
+    /**
+     * Adds a behavior factory.
+     * @param factory - The behavior factory to add.
+     * @param target - The target the factory will create behaviors for.
+     */
+    addBehaviorFactory(factory: ViewBehaviorFactory, target: Node): void;
+}
+
+/**
+ * Bridges between ViewBehaviors and HostBehaviors, enabling a host to
+ * control ViewBehaviors.
+ * @public
+ */
+export declare const ViewBehaviorOrchestrator: Readonly<{
+    /**
+     * Creates a ViewBehaviorOrchestrator.
+     * @param source - The source to to associate behaviors with.
+     * @returns A ViewBehaviorOrchestrator.
+     */
+    create<TSource = any, TParent = any>(source: TSource): ViewBehaviorOrchestrator<TSource, TParent>;
+}>;
+
 /**
  * The target nodes available to a behavior.
  * @public
@@ -3489,14 +3927,6 @@ export declare type ViewBehaviorTargets = {
     [id: string]: Node;
 };
 
-/**
- * Represents the DOM boundaries controlled by a view
- */
-declare interface ViewBoundaries {
-    first: Node;
-    last: Node;
-}
-
 /**
  * Controls the lifecycle of a view and provides relevant context.
  * @public
@@ -3506,11 +3936,23 @@ export declare interface ViewController<TSource = any, TParent = any> extends Ex
      * The parts of the view that are targeted by view behaviors.
      */
     readonly targets: ViewBehaviorTargets;
-}
-
-declare interface ViewNodes {
-    first: Node;
-    last: Node;
+    /**
+     * When true, directives skip attribute/booleanAttribute DOM
+     * updates during bind(). This is an internal flag set only
+     * during the prerendered bind window.
+     * @internal
+     */
+    readonly _skipAttrUpdates?: boolean;
+    /**
+     * Resolves `true` when the view's host element had prerendered
+     * content (existing shadow root).
+     */
+    readonly isPrerendered?: Promise<boolean>;
+    /**
+     * Resolves `true` after prerendered content has been hydrated,
+     * `false` when client-side rendered or hydration not enabled.
+     */
+    readonly isHydrated?: Promise<boolean>;
 }
 
 /**
@@ -3540,11 +3982,6 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * @internal
      */
     compile(): HTMLTemplateCompilationResult<TSource, TParent>;
-    /**
-     * Creates an HTMLView instance based on this template definition.
-     * @param hostBindingTarget - The element that host behaviors will be bound to.
-     */
-    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     /**
      * Returns a directive that can inline the template.
      */
@@ -3566,6 +4003,11 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
      * host that the template is being attached to.
      */
     render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
+    /**
+     * Creates an HTMLView instance based on this template definition.
+     * @param hostBindingTarget - The element that host behaviors will be bound to.
+     */
+    create(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
     /**
      * Processes the tagged template literal's static strings and interpolated values and
      * creates a ViewTemplate.
@@ -3609,6 +4051,15 @@ export declare class ViewTemplate<TSource = any, TParent = any> implements Eleme
  */
 export declare function volatile(target: {}, name: string | Accessor, descriptor: PropertyDescriptor): PropertyDescriptor;
 
+/**
+ * Deeply subscribes to changes in existing observable objects.
+ * @param object - The observable object to watch.
+ * @param subscriber - The handler to call when changes are made to the object.
+ * @returns A disposable that can be used to unsubscribe from change updates.
+ * @beta
+ */
+export declare function watch(object: any, subscriber: Subscriber | ((subject: any, args: any) => void)): Disposable;
+
 /**
  * A directive that enables basic conditional rendering in a template.
  * @param condition - The condition to test for rendering.