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

package/dist/dts/dom.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The type of HTML aspect to target.
+ * @public
+ */
+export declare const DOMAspect: Readonly<{
+    /**
+     * Not aspected.
+     */
+    readonly none: 0;
+    /**
+     * An attribute.
+     */
+    readonly attribute: 1;
+    /**
+     * A boolean attribute.
+     */
+    readonly booleanAttribute: 2;
+    /**
+     * A property.
+     */
+    readonly property: 3;
+    /**
+     * Content
+     */
+    readonly content: 4;
+    /**
+     * A token list.
+     */
+    readonly tokenList: 5;
+    /**
+     * An event.
+     */
+    readonly event: 6;
+}>;
+/**
+ * The type of HTML aspect to target.
+ * @public
+ */
+export declare type DOMAspect = (typeof DOMAspect)[Exclude<keyof typeof DOMAspect, "none">];
+/**
+ * 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 security policy that FAST can use to interact with the DOM.
+ * @public
+ */
+export interface DOMPolicy {
+    /**
+     * Creates safe HTML from the provided value.
+     * @param value - The source to convert to safe HTML.
+     */
+    createHTML(value: string): string;
+    /**
+     * Protects a DOM sink that intends to write to the DOM.
+     * @param tagName - The tag name for the element to write to.
+     * @param aspect - The aspect of the DOM to write to.
+     * @param aspectName - The name of the aspect to write to.
+     * @param sink - The sink that is used to write to the DOM.
+     */
+    protect(tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink): DOMSink;
+}
+/**
+ * Common DOM APIs.
+ * @public
+ */
+export declare const DOM: Readonly<{
+    /**
+     * Gets the dom policy used by the templating system.
+     */
+    readonly policy: DOMPolicy;
+    /**
+     * Sets the dom policy used by the templating system.
+     * @param policy - The policy to set.
+     * @remarks
+     * This API can only be called once, for security reasons. It should be
+     * called by the application developer at the start of their program.
+     */
+    setPolicy(value: DOMPolicy): void;
+    /**
+     * Sets an attribute value on an element.
+     * @param element - The element to set the attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is `null` or `undefined`, the attribute is removed, otherwise
+     * it is set to the provided value using the standard `setAttribute` API.
+     */
+    setAttribute(element: HTMLElement, attributeName: string, value: any): void;
+    /**
+     * Sets a boolean attribute value.
+     * @param element - The element to set the boolean attribute value on.
+     * @param attributeName - The attribute name to set.
+     * @param value - The value of the attribute to set.
+     * @remarks
+     * If the value is true, the attribute is added; otherwise it is removed.
+     */
+    setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
+}>;

package/dist/dts/hydration/target-builder.d.ts

@@ -0,0 +1,63 @@
+import type { CompiledViewBehaviorFactory, ViewBehaviorFactory, ViewBehaviorTargets } from "../templating/html-directive.js";
+export declare class HydrationTargetElementError extends Error {
+    /**
+     * The Compiled View Behavior Factories that belong to the view.
+     */
+    readonly factories: CompiledViewBehaviorFactory[];
+    /**
+     * The node to target factory.
+     */
+    readonly node: Element;
+    /**
+     * String representation of the HTML in the template that
+     * threw the target element error.
+     */
+    templateString?: string;
+    constructor(
+    /**
+     * The error message
+     */
+    message: string | undefined, 
+    /**
+     * The Compiled View Behavior Factories that belong to the view.
+     */
+    factories: CompiledViewBehaviorFactory[], 
+    /**
+     * The node to target factory.
+     */
+    node: Element);
+}
+/**
+ * Represents the DOM boundaries controlled by a view
+ */
+export interface ViewBoundaries {
+    first: Node;
+    last: Node;
+}
+/**
+ * Stores relationships between a {@link ViewBehaviorFactory} and
+ * the {@link ViewBoundaries} the factory created.
+ */
+export interface ViewBehaviorBoundaries {
+    [factoryId: string]: ViewBoundaries;
+}
+/**
+ * Returns a range object inclusive of all nodes including and between the
+ * provided first and last node.
+ * @param first - The first node
+ * @param last - This last node
+ * @returns
+ */
+export declare function createRangeForNodes(first: Node, last: Node): Range;
+/**
+ * Maps {@link CompiledViewBehaviorFactory} ids to the corresponding node targets for the view.
+ * @param firstNode - The first node of the view.
+ * @param lastNode -  The last node of the view.
+ * @param factories - The Compiled View Behavior Factories that belong to the view.
+ * @returns - A {@link ViewBehaviorTargets } object for the factories in the view.
+ */
+export declare function buildViewBindingTargets(firstNode: Node, lastNode: Node, factories: CompiledViewBehaviorFactory[]): {
+    targets: ViewBehaviorTargets;
+    boundaries: ViewBehaviorBoundaries;
+};
+export declare function targetFactory(factory: ViewBehaviorFactory, node: Node, targets: ViewBehaviorTargets): void;

package/dist/dts/index.d.ts

@@ -1,27 +1,34 @@
-export type { Callable, Constructable, Disposable, FASTGlobal, Mutable, StyleStrategy, StyleTarget, TrustedTypes, TrustedTypesPolicy, } from "./interfaces.js";
-export * from "./platform.js";
-export * from "./observation/observable.js";
-export * from "./observation/notifier.js";
-export * from "./observation/arrays.js";
-export * from "./observation/update-queue.js";
-export * from "./styles/element-styles.js";
-export * from "./styles/css.js";
-export * from "./styles/css-directive.js";
-export * from "./styles/host.js";
-export * from "./templating/dom.js";
-export * from "./templating/template.js";
-export * from "./templating/compiler.js";
+export type { Callable, Constructable, Class, Disposable, FASTGlobal, TrustedTypesPolicy, } from "./interfaces.js";
+export { FAST, emptyArray } from "./platform.js";
+export { DOMAspect, DOMSink, DOMPolicy, DOM } from "./dom.js";
+export { Accessor, Expression, ExecutionContext, ExpressionController, ExpressionObserver, ExpressionNotifier, Observable, observable, ObservationRecord, SourceLifetime, volatile, } from "./observation/observable.js";
+export { Notifier, PropertyChangeNotifier, Subscriber, SubscriberSet, } from "./observation/notifier.js";
+export { ArrayObserver, LengthObserver, lengthOf, Splice, SpliceStrategy, SpliceStrategySupport, } from "./observation/arrays.js";
+export { UpdateQueue, Updates } from "./observation/update-queue.js";
+export { Binding, BindingDirective } from "./binding/binding.js";
+export { listener, oneWay } from "./binding/one-way.js";
+export { oneTime } from "./binding/one-time.js";
+export { normalizeBinding } from "./binding/normalize.js";
+export { ComposableStyles, ConstructibleStyleStrategy, ElementStyles, } from "./styles/element-styles.js";
+export { css, CSSTemplateTag, CSSValue } from "./styles/css.js";
+export { AddBehavior, cssDirective, CSSDirective, CSSDirectiveDefinition, } from "./styles/css-directive.js";
+export { HostController, HostBehavior } from "./styles/host.js";
+export { StyleStrategy, StyleTarget } from "./styles/style-strategy.js";
+export { CSSBindingDirective } from "./styles/css-binding-directive.js";
+export { CaptureType, ElementViewTemplate, html, HTMLTemplateCompilationResult, HTMLTemplateTag, InlineTemplateDirective, SyntheticViewTemplate, TemplateValue, ViewTemplate, } from "./templating/template.js";
+export { CompilationStrategy, Compiler } from "./templating/compiler.js";
 export { Markup, Parser } from "./templating/markup.js";
-export * from "./templating/binding.js";
-export * from "./templating/html-directive.js";
-export * from "./templating/ref.js";
-export * from "./templating/when.js";
-export * from "./templating/repeat.js";
-export * from "./templating/slotted.js";
-export * from "./templating/children.js";
-export * from "./templating/view.js";
-export * from "./templating/node-observation.js";
-export * from "./components/fast-element.js";
-export * from "./components/fast-definitions.js";
-export * from "./components/attributes.js";
-export * from "./components/element-controller.js";
+export { ContentTemplate, ContentView, HTMLBindingDirective, } from "./templating/html-binding-directive.js";
+export { AddViewBehaviorFactory, Aspected, CompiledViewBehaviorFactory, htmlDirective, HTMLDirective, HTMLDirectiveDefinition, PartialHTMLDirectiveDefinition, StatelessAttachedAttributeDirective, ViewBehavior, ViewBehaviorFactory, ViewBehaviorTargets, ViewController, } from "./templating/html-directive.js";
+export { ref, RefDirective } from "./templating/ref.js";
+export { when } from "./templating/when.js";
+export { repeat, RepeatBehavior, RepeatDirective, RepeatOptions, } from "./templating/repeat.js";
+export { slotted, SlottedDirective, SlottedDirectiveOptions, } from "./templating/slotted.js";
+export { children, ChildrenDirective, ChildrenDirectiveOptions, ChildListDirectiveOptions, SubtreeDirectiveOptions, } from "./templating/children.js";
+export { ElementView, HTMLView, SyntheticView, View, HydratableView, HydrationBindingError, } from "./templating/view.js";
+export { elements, ElementsFilter, NodeBehaviorOptions, NodeObservationDirective, } from "./templating/node-observation.js";
+export { render, RenderBehavior, RenderDirective } from "./templating/render.js";
+export { customElement, FASTElement } from "./components/fast-element.js";
+export { FASTElementDefinition, PartialFASTElementDefinition, ShadowRootOptions, } from "./components/fast-definitions.js";
+export { attr, AttributeConfiguration, AttributeDefinition, AttributeMode, booleanConverter, DecoratorAttributeConfiguration, nullableBooleanConverter, nullableNumberConverter, ValueConverter, } from "./components/attributes.js";
+export { ElementController, ElementControllerStrategy, HydratableElementController, } from "./components/element-controller.js";

package/dist/dts/index.rollup.d.ts

@@ -1,2 +1 @@
-import "./polyfills.js";
 export * from "./index.js";

package/dist/dts/index.rollup.debug.d.ts

@@ -1,3 +1,2 @@
-import "./polyfills.js";
 import "./debug.js";
 export * from "./index.js";

package/dist/dts/interfaces.d.ts

@@ -6,7 +6,7 @@ export declare type Callable = typeof Function.prototype.call | {
     call(): void;
 };
 /**
- * Allows for the creation of Constructable mixin classes.
+ * Represents a type which can be constructed with the new operator.
  *
  * @public
  */
@@ -14,18 +14,14 @@ export declare type Constructable<T = {}> = {
     new (...args: any[]): T;
 };
 /**
- * Represents a class.
+ * Represents a constructable class with a prototype.
  * @public
  */
-export declare type Class<T, C = {}> = C & {
+export declare type Class<T, C = {}> = C & Constructable<T> & {
     /**
      * The class's prototype;
      */
     readonly prototype: T;
-    /**
-     * The class's constructor.
-     */
-    new (...args: any[]): T;
 };
 /**
  * Provides a mechanism for releasing resources.
@@ -37,18 +33,6 @@ export interface Disposable {
      */
     dispose(): void;
 }
-/**
- * Reverses all readonly members, making them mutable.
- * @internal
- */
-export declare type Mutable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-/**
- * Extracts the item type from an array.
- * @public
- */
-export declare type ArrayItem<T> = T extends ReadonlyArray<infer TItem> ? TItem : T extends Array<infer TItem> ? TItem : any;
 /**
  * A policy for use with the standard trustedTypes platform API.
  * @public
@@ -61,20 +45,20 @@ export declare type TrustedTypesPolicy = {
     createHTML(html: string): string;
 };
 /**
- * Enables working with trusted types.
+ * Reverses all readonly members, making them mutable.
  * @public
  */
-export declare type TrustedTypes = {
-    /**
-     * Creates a trusted types policy.
-     * @param name - The policy name.
-     * @param rules - The policy rules implementation.
-     */
-    createPolicy(name: string, rules: TrustedTypesPolicy): TrustedTypesPolicy;
+export declare type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
 };
+/**
+ * A temporary type as a workaround for the TS compiler's erroneous built-in ParameterDecorator type.
+ * @public
+ */
+export declare type ParameterDecorator = (target: Object, propertyKey: string | undefined, parameterIndex: number) => void;
 /**
  * The FAST global.
- * @internal
+ * @public
  */
 export interface FASTGlobal {
     /**
@@ -110,69 +94,32 @@ export interface FASTGlobal {
     addMessages(messages: Record<number, string>): void;
 }
 /**
- * Core services shared across FAST instances.
+ * Core services that can be shared across FAST instances.
  * @internal
  */
-export declare const enum KernelServiceId {
-    updateQueue = 1,
-    observable = 2,
-    contextEvent = 3,
-    elementRegistry = 4,
-    styleSheetStrategy = 5
-}
-/**
- * A node that can be targeted by styles.
- * @public
- */
-export interface StyleTarget {
-    /**
-     * Stylesheets to be adopted by the node.
-     */
-    adoptedStyleSheets?: CSSStyleSheet[];
-    /**
-     * Adds styles to the target by appending the styles.
-     * @param styles - The styles element to add.
-     */
-    append(styles: HTMLStyleElement): void;
-    /**
-     * Removes styles from the target.
-     * @param styles - The styles element to remove.
-     */
-    removeChild(styles: HTMLStyleElement): void;
-    /**
-     * Returns all element descendants of node that match selectors.
-     * @param selectors - The CSS selector to use for the query.
-     */
-    querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
-}
-/**
- * Implemented to provide specific behavior when adding/removing styles
- * for elements.
- * @public
- */
-export interface StyleStrategy {
-    /**
-     * Adds styles to the target.
-     * @param target - The target to add the styles to.
-     */
-    addStylesTo(target: StyleTarget): void;
-    /**
-     * Removes styles from the target.
-     * @param target - The target to remove the styles from.
-     */
-    removeStylesFrom(target: StyleTarget): void;
-}
+declare type KernelServiceId = {
+    readonly updateQueue: string | number;
+    readonly observable: string | number;
+    readonly contextEvent: string | number;
+    readonly elementRegistry: string | number;
+};
+declare let KernelServiceId: KernelServiceId;
+export { KernelServiceId };
 /**
  * Warning and error messages.
  * @internal
  */
 export declare const enum Message {
     needsArrayObservation = 1101,
-    onlySetHTMLPolicyOnce = 1201,
+    onlySetDOMPolicyOnce = 1201,
     bindingInnerHTMLRequiresTrustedTypes = 1202,
     twoWayBindingRequiresObservables = 1203,
     hostBindingWithoutHost = 1204,
     unsupportedBindingBehavior = 1205,
+    directCallToHTMLTagNotAllowed = 1206,
+    onlySetTemplatePolicyOnce = 1207,
+    cannotSetTemplatePolicyAfterCompilation = 1208,
+    blockedByDOMPolicy = 1209,
     missingElementDefinition = 1401,
     noRegistrationForContext = 1501,
     noFactoryForResolver = 1502,
@@ -190,14 +137,17 @@ export declare const enum Message {
     connectUpdateRequiresController = 1514
 }
 /**
- * @internal
+ * Determines whether or not an object is a function.
+ * @public
  */
 export declare const isFunction: (object: any) => object is Function;
 /**
- * @internal
+ * Determines whether or not an object is a string.
+ * @public
  */
 export declare const isString: (object: any) => object is string;
 /**
- * @internal
+ * A function which does nothing.
+ * @public
  */
 export declare const noop: () => undefined;

package/dist/dts/metadata.d.ts

@@ -1,6 +1,7 @@
 import type { Constructable } from "./interfaces.js";
 /**
  * Provides basic metadata capabilities used by Context and Dependency Injection.
+ * @public
  */
 export declare const Metadata: Readonly<{
     /**
@@ -8,18 +9,18 @@ export declare const Metadata: Readonly<{
      * @param Type - The type to get the metadata for.
      * @returns The metadata array or a frozen empty array if no metadata is found.
      */
-    getDesignParamTypes: (Type: any) => any;
+    getDesignParamTypes: (Type: Constructable) => readonly any[];
     /**
      * Gets the "annotation:paramtypes" metadata for the specified type.
      * @param Type - The type to get the metadata for.
      * @returns The metadata array or a frozen empty array if no metadata is found.
      */
-    getAnnotationParamTypes: (Type: any) => any;
+    getAnnotationParamTypes: (Type: Constructable) => readonly any[];
     /**
-     *
-     * @param Type - Gets the "annotation:paramtypes" metadata for the specified type. If none is found,
+     * Gets the "annotation:paramtypes" metadata for the specified type. If none is found,
      * an empty, mutable metadata array is created and added.
-     * @returns The metadata array.
+     * @param Type - The type to get or create the metadata for.
+     * @returns A mutable metadata array.
      */
     getOrCreateAnnotationParamTypes(Type: Constructable): any[];
 }>;

package/dist/dts/observation/arrays.d.ts

@@ -57,7 +57,7 @@ export declare const SpliceStrategySupport: Readonly<{
  * The available values for SpliceStrategySupport.
  * @public
  */
-export declare type SpliceStrategySupport = typeof SpliceStrategySupport[keyof typeof SpliceStrategySupport];
+export declare type SpliceStrategySupport = (typeof SpliceStrategySupport)[keyof typeof SpliceStrategySupport];
 /**
  * An approach to tracking changes in an array.
  * @public

package/dist/dts/observation/observable.bench.d.ts

@@ -0,0 +1,18 @@
+import { FASTElement } from "../index.js";
+export declare class TestObservable extends FASTElement {
+    private _greetMessage;
+    private _name;
+    private _exit;
+    firstName: string;
+    lastName: string;
+    connectedCallback(): void;
+    get greetMessage(): string;
+    set greetMessage(value: string);
+    get name(): string;
+    set name(value: string);
+    get exit(): boolean;
+    set exit(value: boolean);
+}
+declare const itemRenderer: () => HTMLElement;
+export default itemRenderer;
+export { tests } from "@tensile-perf/web-components";

package/dist/dts/observation/observable.d.ts

@@ -60,7 +60,7 @@ export declare const SourceLifetime: Readonly<{
  * Describes how the source's lifetime relates to its controller's lifetime.
  * @public
  */
-export declare type SourceLifetime = typeof SourceLifetime[keyof typeof SourceLifetime];
+export declare type SourceLifetime = (typeof SourceLifetime)[keyof typeof SourceLifetime];
 /**
  * Controls the lifecycle of an expression and provides relevant context.
  * @public
@@ -176,17 +176,17 @@ export declare const Observable: Readonly<{
     /**
      * Creates a {@link ExpressionNotifier} that can watch the
      * provided {@link Expression} for changes.
-     * @param binding - The binding to observe.
+     * @param expression - The binding to observe.
      * @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>(binding: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn, any>;
+    binding<TSource = any, TReturn = any>(expression: Expression<TSource, TReturn, any>, initialSubscriber?: Subscriber, isVolatileBinding?: boolean): ExpressionNotifier<TSource, TReturn, any>;
     /**
      * Determines whether a binding expression is volatile and needs to have its dependency list re-evaluated
      * on every evaluation of the value.
-     * @param binding - The binding to inspect.
+     * @param expression - The binding to inspect.
      */
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(binding: Expression<TSource_1, TReturn_1, any>): boolean;
+    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(expression: Expression<TSource_1, TReturn_1, any>): boolean;
 }>;
 /**
  * Decorator: Defines an observable property on the target.

package/dist/dts/pending-task.d.ts

@@ -1,20 +1,32 @@
-/**
- * This module provides
- */
 /**
  * An implementation of the https://github.com/webcomponents-cg/community-protocols/blob/main/proposals/pending-task.md proposal.
- * @beta
+ * @public
  */
 export interface PendingTask extends Event {
-    complete: Promise<void>;
+    /**
+     * A promise that resolves when the pending task is complete.
+     */
+    readonly complete: Promise<void>;
 }
 /**
  * A concrete implementation of {@link PendingTask}
- * @beta
+ * @public
  */
 export declare class PendingTaskEvent extends Event implements PendingTask {
-    complete: Promise<void>;
+    readonly complete: Promise<void>;
+    /**
+     * The type of the pending task event.
+     */
     static readonly type = "pending-task";
+    /**
+     * Creates an instance of PendingTaskEvent.
+     * @param complete - A promise that resolves when the pending task is complete.
+     */
     constructor(complete: Promise<void>);
+    /**
+     * Determines whether a value is a PendingTaskEvent.
+     * @param value - The value to check.
+     * @returns True if the value is a PendingTaskEvent; false otherwise.
+     */
     static isPendingTask<T extends Event>(value: T | PendingTask): value is PendingTask;
 }

package/dist/dts/platform.d.ts

@@ -1,7 +1,8 @@
-import type { FASTGlobal } from "./interfaces.js";
+import { FASTGlobal } from "./interfaces.js";
+import "./polyfills.js";
 /**
  * The FAST global.
- * @internal
+ * @public
  */
 export declare const FAST: FASTGlobal;
 /**
@@ -39,3 +40,11 @@ export declare function createTypeRegistry<TDefinition extends TypeDefinition>()
  * @internal
  */
 export declare function createMetadataLocator<TMetadata>(): (target: {}) => TMetadata[];
+/**
+ * Makes a type noop for JSON serialization.
+ * @param type - The type to make noop for JSON serialization.
+ * @internal
+ */
+export declare function makeSerializationNoop(type: {
+    readonly prototype: any;
+}): void;

package/dist/dts/polyfills.d.ts

@@ -1,8 +0,0 @@
-import type { StyleStrategy, StyleTarget } from "./interfaces.js";
-export declare class StyleElementStrategy implements StyleStrategy {
-    private readonly styles;
-    private readonly styleClass;
-    constructor(styles: string[]);
-    addStylesTo(target: StyleTarget): void;
-    removeStylesFrom(target: StyleTarget): void;
-}

package/dist/dts/styles/css-binding-directive.d.ts

@@ -0,0 +1,60 @@
+import type { Binding, BindingDirective } from "../binding/binding.js";
+import type { Subscriber } from "../observation/notifier.js";
+import type { ExpressionObserver } from "../observation/observable.js";
+import { AddBehavior, CSSDirective } from "./css-directive.js";
+import type { ComposableStyles } from "./element-styles.js";
+import type { HostBehavior, HostController } from "./host.js";
+declare type CSSBindingEntry = {
+    observer: ExpressionObserver;
+    controller: HostController;
+};
+/**
+ * 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;
+}
+export {};