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

package/dist/fast-element.d.ts

@@ -1,2698 +1,1119 @@
 /**
- * Represents a getter/setter property accessor on an object.
+ * A decorator and DI resolver that will resolve an array of all dependencies
+ * registered with the specified key.
+ * @param key - The key to resolve all dependencies for.
+ * @param searchAncestors - [optional] Indicates whether to search ancestor containers.
  * @public
  */
-export declare interface Accessor {
+export declare const all: (key: any, searchAncestors?: boolean) => ReturnType<typeof DI.inject>;
+
+/**
+ * A function capable of asynchronously locating a resolver for a key.
+ * @public
+ */
+export declare type AsyncRegistrationLocator = (key: Key) => Promise<Registration | null>;
+
+/**
+ * Represents a type which can be constructed with the new operator.
+ *
+ * @public
+ */
+declare type Constructable<T = {}> = {
+    new (...args: any[]): T;
+};
+
+/**
+ * Implemented by dependency injection containers.
+ * @public
+ */
+export declare interface Container extends ServiceLocator {
+    /**
+     * Registers dependencies with the container via registration objects.
+     * @param params - The registration objects.
+     */
+    register(...params: any[]): Container;
+    /**
+     * Registers a resolver with the container for the specified key.
+     * @param key - The key to register the resolver under.
+     * @param resolver - The resolver to register.
+     */
+    registerResolver<K extends Key, T = K>(key: K, resolver: Resolver<T>): Resolver<T>;
+    /**
+     * Registers a transformer with the container for the specified key.
+     * @param key - The key to resolved to register the transformer with.
+     * @param transformer - The transformer to register.
+     */
+    registerTransformer<K extends Key, T = K>(key: K, transformer: Transformer_2<T>): boolean;
+    /**
+     * Gets a resolver for the specified key.
+     * @param key - The key to get the resolver for.
+     * @param autoRegister - Indicates whether or not to try to auto-register a dependency for
+     * the key if one is not explicitly registered.
+     */
+    getResolver<K extends Key, T = K>(key: K | Key, autoRegister?: boolean): Resolver<T> | null;
     /**
-     * The name of the property.
+     * Registers a factory with the container for the specified key.
+     * @param key - The key to register the factory under.
+     * @param factory - The factory to register.
      */
-    name: string;
+    registerFactory<T extends Constructable>(key: T, factory: Factory<T>): void;
     /**
-     * Gets the value of the property on the source object.
-     * @param source - The source object to access.
+     * Gets the factory for the specified key.
+     * @param key - The key to get the factory for.
      */
-    getValue(source: any): any;
+    getFactory<T extends Constructable>(key: T): Factory<T>;
     /**
-     * Sets the value of the property on the source object.
-     * @param source - The source object to access.
-     * @param value - The value to set the property to.
+     * Creates a child dependency injection container parented to this container.
+     * @param config - The configuration for the new container.
      */
-    setValue(source: any, value: any): void;
+    createChild(config?: Partial<Omit<ContainerConfiguration, "parentLocator">>): Container;
 }
 
 /**
- * Used to add behaviors when constructing styles.
- * @public
- */
-export declare type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
-
-/**
- * Used to add behavior factories when constructing templates.
+ * The key that resolves the dependency injection Container itself.
  * @public
  */
-export declare type AddViewBehaviorFactory = (factory: ViewBehaviorFactory) => string;
-
-/* Excluded from this release type: AdoptedStyleSheetsStrategy */
+export declare const Container: ContextDecorator<Container>;
 
 /**
- * An observer for arrays.
+ * Configuration for a dependency injection container.
  * @public
  */
-export declare interface ArrayObserver extends SubscriberSet {
+export declare interface ContainerConfiguration {
     /**
-     * The strategy to use for tracking changes.
+     * The locator function used to find the parent of the container.
      */
-    strategy: SpliceStrategy | null;
+    parentLocator: ParentLocator;
     /**
-     * The length observer for the array.
+     * When an asynchronous get request is made to the container, if no
+     * resolver is found for the key, this function is called to provide
+     * a registration.
      */
-    readonly lengthObserver: LengthObserver;
+    asyncRegistrationLocator: AsyncRegistrationLocator;
     /**
-     * Adds a splice to the list of changes.
-     * @param splice - The splice to add.
+     * Indicates whether this container should resolve dependencies that are directly made
+     * by its owner. The default is "false" which results in the parent container being used.
      */
-    addSplice(splice: Splice): void;
+    responsibleForOwnerRequests: boolean;
     /**
-     * Indicates that a reset change has occurred.
-     * @param oldCollection - The collection as it was before the reset.
+     * Gets the default resolver to use during auto-registration.
+     * @param key - The key to register the dependency with.
+     * @param handler - The container that is handling the auto-registration request.
      */
-    reset(oldCollection: any[] | undefined): void;
-    /**
-     * Flushes the changes to subscribers.
-     */
-    flush(): void;
+    defaultResolver(key: Key, handler: Container): Resolver;
 }
 
 /**
- * An observer for arrays.
+ * Configuration for a dependency injection container.
  * @public
  */
-export declare const ArrayObserver: Readonly<{
+export declare const ContainerConfiguration: Readonly<{
     /**
-     * Enables the array observation mechanism.
+     * The default configuration used when creating a DOM-disconnected container.
      * @remarks
-     * Array observation is enabled automatically when using the
-     * {@link RepeatDirective}, so calling this API manually is
-     * not typically necessary.
+     * The default creates a root container, with no parent container. It does not handle
+     * owner requests and it uses singleton resolution behavior for auto-registration.
      */
-    readonly enable: () => void;
+    default: Readonly<ContainerConfiguration>;
 }>;
 
 /**
- * The type of HTML aspect to target.
+ * @internal
+ */
+export declare class ContainerImpl implements DOMContainer {
+    protected owner: any;
+    protected config: ContainerConfiguration;
+    private _parent;
+    private registerDepth;
+    private resolvers;
+    private isHandlingContextRequests;
+    get parent(): ContainerImpl | null;
+    get depth(): number;
+    get responsibleForOwnerRequests(): boolean;
+    constructor(owner: any, config: ContainerConfiguration);
+    handleContextRequests(enable: boolean): void;
+    register(...params: any[]): Container;
+    registerResolver<K extends Key, T = K>(key: K, resolver: Resolver<T>): Resolver<T>;
+    registerTransformer<K extends Key, T = K>(key: K, transformer: Transformer_2<T>): boolean;
+    getResolver<K extends Key, T = K>(key: K | Key, autoRegister?: boolean): Resolver<T> | null;
+    has<K extends Key>(key: K, searchAncestors?: boolean): boolean;
+    getAsync<K extends Key>(key: K): Promise<Resolved<K>>;
+    get<K extends Key>(key: K): Resolved<K>;
+    getAll<K extends Key>(key: K, searchAncestors?: boolean): readonly Resolved<K>[];
+    getFactory<K extends Constructable>(Type: K): Factory<K>;
+    registerFactory<K extends Constructable>(key: K, factory: Factory<K>): void;
+    createChild(config?: Partial<Omit<ContainerConfiguration, "parentLocator">>): Container;
+    private jitRegister;
+}
+
+/**
+ * A Context object defines an optional initial value for a Context, as well as a name identifier for debugging purposes.
+ * @public
+ */
+declare type Context<T> = {
+    readonly name: string;
+    readonly initialValue?: T;
+};
+
+/**
+ * Enables using:
+ * {@link https://github.com/webcomponents-cg/community-protocols/blob/main/proposals/context.md | W3C Community Context protocol.}
  * @public
  */
-export declare const Aspect: Readonly<{
+declare const Context: Readonly<{
+    /**
+     * The event type used for W3C Context Protocol requests.
+     */
+    eventType: "context-request";
     /**
-     * Not aspected.
+     * Returns a FASTContext object from the global context registry matching the given name if found.
+     * Otherwise, returns a new FASTContext with this name.
+     * @param name - The name of the FASTContext to get or create.
+     * @returns A FASTContext object.
      */
-    readonly none: 0;
+    for<T = unknown>(name: string): FASTContext<T>;
     /**
-     * An attribute.
+     * Creates a W3C Community Protocol-based Context object to use in requesting/providing
+     * context through the DOM.
+     * @param name - The name to use for the connext. Useful in debugging.
+     * @param initialValue - An optional initial value to use if a context handler isn't found.
      */
-    readonly attribute: 1;
+    create<T_1 = unknown>(name: string, initialValue?: T_1 | undefined): FASTContext<T_1>;
     /**
-     * A boolean attribute.
+     * Sets the strategy used by all FAST-specific context requests made through the
+     * Context.request, Context.get, Context.defineProperty, and ContextDecorator APIs.
+     * @param strategy - The strategy to use. By default, the strategy is Context.dispatch.
      */
-    readonly booleanAttribute: 2;
+    setDefaultRequestStrategy(strategy: FASTContextRequestStrategy): void;
     /**
-     * A property.
+     * Gets the context value for the target node or returns the initial value if
+     * a context handler is not found.
+     * @param target - The target to get the context for.
+     * @param context - The context to locate.
+     * @returns The context value.
+     * @remarks
+     * Uses the default request strategy to locate the context. If no context is found
+     * then the initial value of the context is returned.
      */
-    readonly property: 3;
+    get<T_2 extends UnknownContext>(target: EventTarget, context: T_2): ContextType<T_2>;
     /**
-     * Content
+     * Requests the context value for the target node.
+     * @param target - The target to request the context for.
+     * @param context - The context to locate.
+     * @param callback - A callback to invoke with the context value.
+     * @param multiple - Whether the context requestor expects to handle updates
+     * to the context value after the initial request.
+     * @remarks
+     * Uses the default request strategy to locate the context.
      */
-    readonly content: 4;
+    request<T_3 extends UnknownContext>(target: EventTarget, context: T_3, callback: ContextCallback<ContextType<T_3>>, multiple?: boolean): void;
     /**
-     * A token list.
+     *
+     * @param target - The target to dispatch the context event on.
+     * @param context - The context to locate.
+     * @param callback - The callback to invoke with the context value.
+     * @param multiple - Whether the context requestor expects to handle updates
+     * to the context value after the initial request.
+     * @remarks
+     * This API does NOT use the default request strategy. It always dispatches
+     * an event through the DOM.
      */
-    readonly tokenList: 5;
+    dispatch<T_4 extends UnknownContext>(target: EventTarget, context: T_4, callback: ContextCallback<ContextType<T_4>>, multiple?: boolean): void;
     /**
-     * An event.
+     * Enables an event target to provide a context value.
+     * @param target The target to provide the context value for.
+     * @param context The context to provide the value for.
+     * @param value The value to provide for the context.
      */
-    readonly event: 6;
+    provide<T_5 extends UnknownContext>(target: EventTarget, context: T_5, value: ContextType<T_5>): void;
     /**
      *
-     * @param directive - The directive to assign the aspect to.
-     * @param value - The value to base the aspect determination on.
+     * @param target - The target on which to handle context requests.
+     * @param callback - The callback to invoke when a context request is received.
+     * @param context - The context to handle requests for.
+     * @remarks
+     * If a context is not provided then the callback will be invoked for all context
+     * requests that are received on the target.
+     */
+    handle<T_6 extends UnknownContext>(target: EventTarget, callback: (event: ContextEvent<T_6>) => void, context?: T_6 | undefined): void;
+    /**
+     * Defines a getter-only property on the target that will return the context
+     * value for the target.
+     * @param target The target to define the property on.
+     * @param propertyName The name of the property to define.
+     * @param context The context that will be used to retrieve the property value.
      * @remarks
-     * If a falsy value is provided, then the content aspect will be assigned.
+     * Uses the default request strategy to locate the context and will return the
+     * initialValue if the context isn't handled.
      */
-    readonly assign: (directive: Aspected, value?: string) => void;
+    defineProperty<T_7 extends UnknownContext>(target: Constructable<EventTarget> | EventTarget, propertyName: string, context: T_7): void;
 }>;
 
 /**
- * The type of HTML aspect to target.
+ * A callback which is provided by a context requester and is called with the value satisfying the request.
+ * This callback can be called multiple times by context providers as the requested value is changed.
  * @public
  */
-export declare type Aspect = typeof Aspect[Exclude<keyof typeof Aspect, "assign" | "none">];
+declare type ContextCallback<ValueType> = (value: ValueType, dispose?: () => void) => void;
 
 /**
- * Represents something that applies to a specific aspect of the DOM.
+ * A constant key that can be used to represent a Context dependency.
+ * The key can be used for context or DI but also doubles as a decorator for
+ * resolving the associated dependency.
  * @public
  */
-export declare interface Aspected {
-    /**
-     * The original source aspect exactly as represented in markup.
-     */
-    sourceAspect: string;
-    /**
-     * The evaluated target aspect, determined after processing the source.
-     */
-    targetAspect: string;
-    /**
-     * The type of aspect to target.
-     */
-    aspectType: Aspect;
-    /**
-     * A binding if one is associated with the aspect.
-     */
-    dataBinding?: Binding;
-}
+declare type ContextDecorator<T = any> = Readonly<Context<T>> & PropertyDecorator & ParameterDecorator_2;
 
 /**
- * Decorator: Specifies an HTML attribute.
- * @param config - The configuration for the attribute.
+ * An event fired by a context requester to signal it desires a named context.
+ *
+ * A provider should inspect the `context` property of the event to determine if it has a value that can
+ * satisfy the request, calling the `callback` with the requested value if so.
+ *
+ * If the requested context event contains a truthy `multiple` value, then a provider can call the callback
+ * multiple times if the value is changed, if this is the case the provider should pass a `dispose`
+ * method to the callback which requesters can invoke to indicate they no longer wish to receive these updates.
  * @public
  */
-export declare function attr(config?: DecoratorAttributeConfiguration): (target: {}, property: string) => void;
+declare class ContextEvent<T extends UnknownContext> extends Event {
+    readonly context: T;
+    readonly callback: ContextCallback<ContextType<T>>;
+    readonly multiple?: boolean | undefined;
+    constructor(context: T, callback: ContextCallback<ContextType<T>>, multiple?: boolean | undefined);
+}
 
 /**
- * Decorator:  Specifies an HTML attribute.
- * @param target - The class to define the attribute on.
- * @param prop - The property name to be associated with the attribute.
+ * A helper type which can extract a Context value type from a Context type
  * @public
  */
-export declare function attr(target: {}, prop: string): void;
+declare type ContextType<T extends UnknownContext> = T extends Context<infer Y> ? Y : never;
 
-/**
- * Metadata used to configure a custom attribute's behavior.
- * @public
- */
-export declare type AttributeConfiguration = {
-    property: string;
-    attribute?: string;
-    mode?: AttributeMode;
-    converter?: ValueConverter;
-};
+declare function createContext<K extends Key>(nameConfigOrCallback?: string | ((builder: ResolverBuilder<K>) => Resolver<K>) | InterfaceConfiguration, configuror?: (builder: ResolverBuilder<K>) => Resolver<K>): ContextDecorator<K>;
 
 /**
- * Metadata used to configure a custom attribute's behavior.
+ * A set of default resolvers useful in configuring a container.
  * @public
  */
-export declare const AttributeConfiguration: Readonly<{
+export declare const DefaultResolver: Readonly<{
     /**
-     * Locates all attribute configurations associated with a type.
+     * Disables auto-registration and throws for all un-registered dependencies.
+     * @param key - The key to create the resolver for.
      */
-    locate: (target: {}) => AttributeConfiguration[];
+    none(key: Key): Resolver;
+    /**
+     * Provides default singleton resolution behavior during auto-registration.
+     * @param key - The key to create the resolver for.
+     * @returns The resolver.
+     */
+    singleton(key: Key): Resolver;
+    /**
+     * Provides default transient resolution behavior during auto-registration.
+     * @param key - The key to create the resolver for.
+     * @returns The resolver.
+     */
+    transient(key: Key): Resolver;
 }>;
 
 /**
- * An implementation of {@link Accessor} that supports reactivity,
- * change callbacks, attribute reflection, and type conversion for
- * custom elements.
+ * The gateway to dependency injection APIs.
  * @public
  */
-export declare class AttributeDefinition implements Accessor {
-    private readonly fieldName;
-    private readonly callbackName;
-    private readonly hasCallback;
-    private readonly guards;
+export declare const DI: Readonly<{
     /**
-     * The class constructor that owns this attribute.
+     * Installs dependency injection as the default strategy for handling
+     * all calls to Context.request.
+     * @param fallback - Creates a container if one cannot be found.
      */
-    readonly Owner: Function;
+    installAsContextRequestStrategy(fallback?: () => DOMContainer): void;
     /**
-     * The name of the property associated with the attribute.
+     * Creates a new dependency injection container.
+     * @param config - The configuration for the container.
+     * @returns A newly created dependency injection container.
      */
-    readonly name: string;
+    createContainer(config?: Partial<ContainerConfiguration>): Container;
+    /**
+     * Finds the dependency injection container responsible for providing dependencies
+     * to the specified node.
+     * @param target - The node to find the responsible container for.
+     * @param fallback - Creates a container if one cannot be found.
+     * @returns The container responsible for providing dependencies to the node.
+     * @remarks
+     * This will be the same as the parent container if the specified node
+     * does not itself host a container configured with responsibleForOwnerRequests.
+     */
+    findResponsibleContainer(target: EventTarget, fallback?: () => DOMContainer): DOMContainer;
     /**
-     * The name of the attribute in HTML.
+     * Find the dependency injection container up the DOM tree from this node.
+     * @param target - The node to find the parent container for.
+     * @param fallback - Creates a container if one cannot be found.
+     * @returns The parent container of this node.
+     * @remarks
+     * This will be the same as the responsible container if the specified node
+     * does not itself host a container configured with responsibleForOwnerRequests.
      */
-    readonly attribute: string;
+    findParentContainer(target: EventTarget, fallback?: () => DOMContainer): DOMContainer;
     /**
-     * The {@link AttributeMode} that describes the behavior of this attribute.
+     * Returns a dependency injection container if one is explicitly owned by the specified
+     * node. If one is not owned, then a new container is created and assigned to the node.
+     * @param target - The node to find or create the container for.
+     * @param config - The configuration for the container if one needs to be created.
+     * @returns The located or created container.
+     * @remarks
+     * This API does not search for a responsible or parent container. It looks only for a container
+     * directly defined on the specified node and creates one at that location if one does not
+     * already exist.
+     */
+    getOrCreateDOMContainer(target?: EventTarget, config?: Partial<Omit<ContainerConfiguration, "parentLocator">>): DOMContainer;
+    /**
+     * Gets the dependency keys representing what is needed to instantiate the specified type.
+     * @param Type - The type to get the dependencies for.
+     * @returns An array of dependency keys.
+     */
+    getDependencies(Type: Constructable | Injectable): Key[];
+    /**
+     * Defines a property on a web component class. The value of this property will
+     * be resolved from the dependency injection container responsible for the element
+     * instance, based on where it is connected in the DOM.
+     * @param target - The target to define the property on.
+     * @param propertyName - The name of the property to define.
+     * @param key - The dependency injection key.
+     * @param respectConnection - Indicates whether or not to update the property value if the
+     * hosting component is disconnected and then re-connected at a different location in the DOM.
+     * @remarks
+     * The respectConnection option is only applicable to elements that descend from FASTElement.
      */
-    readonly mode: AttributeMode;
+    defineProperty(target: {}, propertyName: string, key: Key, respectConnection?: boolean): void;
     /**
-     * A {@link ValueConverter} that integrates with the property getter/setter
-     * to convert values to and from a DOM string.
+     * Creates a dependency injection key.
+     * @param nameConfigOrCallback - A friendly name for the key or a lambda that configures a
+     * default resolution for the dependency.
+     * @param configuror - If a friendly name was provided for the first parameter, then an optional
+     * lambda that configures a default resolution for the dependency can be provided second.
+     * @returns The created key.
+     * @remarks
+     * The created key can be used as a property decorator or constructor parameter decorator,
+     * in addition to its standard use in an inject array or through direct container APIs.
      */
-    readonly converter?: ValueConverter;
+    createContext: typeof createContext;
     /**
-     * Creates an instance of AttributeDefinition.
-     * @param Owner - The class constructor that owns this attribute.
-     * @param name - The name of the property associated with the attribute.
-     * @param attribute - The name of the attribute in HTML.
-     * @param mode - The {@link AttributeMode} that describes the behavior of this attribute.
-     * @param converter - A {@link ValueConverter} that integrates with the property getter/setter
-     * to convert values to and from a DOM string.
+     * A decorator that specifies what to inject into its target.
+     * @param dependencies - The dependencies to inject.
+     * @returns The decorator to be applied to the target class.
+     * @remarks
+     * The decorator can be used to decorate a class, listing all of the classes dependencies.
+     * Or it can be used to decorate a constructor parameter, indicating what to inject for that
+     * parameter.
+     * Or it can be used for a web component property, indicating what that property should resolve to.
      */
-    constructor(Owner: Function, name: string, attribute?: string, mode?: AttributeMode, converter?: ValueConverter);
+    inject(...dependencies: Key[]): (target: any, key?: string | number, descriptor?: PropertyDescriptor | number) => void;
     /**
-     * Sets the value of the attribute/property on the source element.
-     * @param source - The source element to access.
-     * @param value - The value to set the attribute/property to.
+     * Registers the `target` class as a transient dependency; each time the dependency is resolved
+     * a new instance will be created.
+     *
+     * @param target - The class / constructor function to register as transient.
+     * @returns The same class, with a static `register` method that takes a container and returns the appropriate resolver.
+     *
+     * @example
+     * On an existing class
+     * ```ts
+     * class Foo { }
+     * DI.transient(Foo);
+     * ```
+     *
+     * @example
+     * Inline declaration
+     *
+     * ```ts
+     * const Foo = DI.transient(class { });
+     * // Foo is now strongly typed with register
+     * Foo.register(container);
+     * ```
+     *
+     * @public
      */
-    setValue(source: HTMLElement, newValue: any): void;
+    transient<T extends Constructable<{}>>(target: T & Partial<RegisterSelf<T>>): T & RegisterSelf<T>;
     /**
-     * Gets the value of the attribute/property on the source element.
-     * @param source - The source element to access.
+     * Registers the `target` class as a singleton dependency; the class will only be created once. Each
+     * consecutive time the dependency is resolved, the same instance will be returned.
+     *
+     * @param target - The class / constructor function to register as a singleton.
+     * @returns The same class, with a static `register` method that takes a container and returns the appropriate resolver.
+     * @example
+     * On an existing class
+     * ```ts
+     * class Foo { }
+     * DI.singleton(Foo);
+     * ```
+     *
+     * @example
+     * Inline declaration
+     * ```ts
+     * const Foo = DI.singleton(class { });
+     * // Foo is now strongly typed with register
+     * Foo.register(container);
+     * ```
+     *
+     * @public
      */
-    getValue(source: HTMLElement): any;
-    /* Excluded from this release type: onAttributeChangedCallback */
-    private tryReflectToAttribute;
-    /* Excluded from this release type: collect */
-}
+    singleton<T_1 extends Constructable<{}>>(target: T_1 & Partial<RegisterSelf<T_1>>, options?: SingletonOptions): T_1 & RegisterSelf<T_1>;
+}>;
 
 /**
- * The mode that specifies the runtime behavior of the attribute.
- * @remarks
- * By default, attributes run in `reflect` mode, propagating their property
- * values to the DOM and DOM values to the property. The `boolean` mode also
- * reflects values, but uses the HTML standard boolean attribute behavior,
- * interpreting the presence of the attribute as `true` and the absence as
- * `false`. The `fromView` behavior only updates the  property value based on
- * changes in the DOM, but does not reflect property changes back.
+ * A Container that is associated with a specific Node in the DOM.
  * @public
  */
-export declare type AttributeMode = typeof reflectMode | typeof booleanMode | "fromView";
+export declare interface DOMContainer extends Container {
+    /**
+     * Instructs this particular Container to handle W3C Community Context requests
+     * that propagate to its associated DOM node.
+     * @param enable - true to enable context requests handling; false otherwise.
+     * @beta
+     */
+    handleContextRequests(enable: boolean): void;
+}
 
 /**
- * Creates an standard binding.
- * @param binding - The binding to refresh when changed.
- * @param isVolatile - Indicates whether the binding is volatile or not.
- * @returns A binding configuration.
+ * The key that resolves a DOMContainer itself.
  * @public
  */
-export declare function bind<T = any>(binding: Expression<T>, isVolatile?: boolean): Binding<T>;
+export declare const DOMContainer: ContextDecorator<DOMContainer>;
 
 /**
- * Captures a binding expression along with related information and capabilities.
- *
+ * Used by the default Resolver to create instances of objects when needed.
  * @public
  */
-export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
-    evaluate: Expression<TSource, TReturn, TParent>;
-    isVolatile: boolean;
+export declare interface Factory<T extends Constructable = any> {
+    /**
+     * The concrete type this factory creates.
+     */
+    readonly Type: T;
     /**
-     * Options associated with the binding.
+     * Registers a transformer function to alter the object after instantiation but before
+     * returning the final constructed instance.
+     * @param transformer - The transformer function.
      */
-    options?: any;
+    registerTransformer(transformer: Transformer_2<T>): void;
     /**
-     * Creates a binding.
-     * @param evaluate - Evaluates the binding.
-     * @param isVolatile - Indicates whether the binding is volatile.
+     * Constructs an instance of the factory's object.
+     * @param container - The container the object is being constructor for.
+     * @param dynamicDependencies - Dynamic dependencies supplied to the constructor.
      */
-    constructor(evaluate: Expression<TSource, TReturn, TParent>, isVolatile?: boolean);
+    construct(container: Container, dynamicDependencies?: Key[]): Resolved<T>;
     /**
-     * Creates an observer capable of notifying a subscriber when the output of a binding changes.
-     * @param directive - The HTML Directive to create the observer for.
-     * @param subscriber - The subscriber to changes in the binding.
+     * Constructs an instance of the factory's object, allowing for
+     * async resolution of dependencies.
+     * @param container - The container the object is being constructor for.
+     * @param dynamicDependencies - Dynamic dependencies supplied to the constructor.
      */
-    abstract createObserver(directive: HTMLDirective, subscriber: Subscriber): ExpressionObserver<TSource, TReturn, TParent>;
+    constructAsync(container: Container, dynamicDependencies?: Key[]): Promise<Resolved<T>>;
+}
+
+/** @internal */
+export declare class FactoryImpl<T extends Constructable = any> implements Factory<T> {
+    Type: T;
+    private readonly dependencies;
+    private transformers;
+    constructor(Type: T, dependencies: Key[]);
+    constructAsync(container: Container, dynamicDependencies?: Key[]): Promise<Resolved<T>>;
+    construct(container: Container, dynamicDependencies?: Key[]): Resolved<T>;
+    private constructCore;
+    registerTransformer(transformer: (instance: any) => any): void;
 }
 
 /**
- * A {@link ValueConverter} that converts to and from `boolean` values.
- * @remarks
- * Used automatically when the `boolean` {@link AttributeMode} is selected.
+ * A Context object defines an optional initial value for a Context, as well as a name identifier for debugging purposes.
+ * The FASTContext can also be used as a decorator to declare context dependencies or as a key for DI.
  * @public
  */
-export declare const booleanConverter: ValueConverter;
-
-declare const booleanMode = "boolean";
+declare type FASTContext<T> = ContextDecorator<T> & {
+    get(target: EventTarget): T;
+    provide(target: EventTarget, value: T): void;
+    request(target: EventTarget, callback: ContextCallback<T>, multiple?: boolean): void;
+    handle(target: EventTarget, callback: (event: ContextEvent<FASTContext<T>>) => void): void;
+};
 
 /**
- * Represents a callable type such as a function or an object with a "call" method.
+ * A strategy that controls how all Context.request API calls are handled.
+ * @remarks
+ * By default this is handled via Context.dispatch, which dispatches a ContextEvent.
  * @public
  */
-export declare type Callable = typeof Function.prototype.call | {
-    call(): void;
-};
+declare type FASTContextRequestStrategy = <T extends UnknownContext>(target: EventTarget, context: T, callback: ContextCallback<ContextType<T>>, multiple: any) => void;
 
 /**
- * A marker interface used to capture types when interpolating Directive helpers
- * into templates.
+ * A decorator that tells the container not to try to inject a dependency.
+ *
  * @public
  */
-export declare interface CaptureType<TSource, TParent> {
-}
+export declare function ignore(target: Injectable, property?: string | number, descriptor?: PropertyDescriptor | number): void;
 
 /**
- * The options used to configure child list observation.
+ * A decorator that specifies what to inject into its target.
+ * @param dependencies - The dependencies to inject.
+ * @returns The decorator to be applied to the target class.
+ * @remarks
+ * The decorator can be used to decorate a class, listing all of the classes dependencies.
+ * Or it can be used to decorate a constructor paramter, indicating what to inject for that
+ * parameter.
+ * Or it can be used for a web component property, indicating what that property should resolve to.
+ *
  * @public
  */
-export declare interface ChildListDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
-}
+export declare const inject: (...dependencies: Key[]) => (target: any, key?: string | number, descriptor?: PropertyDescriptor | number) => void;
 
 /**
- * A directive that observes the `childNodes` of an element and updates a property
- * whenever they change.
- * @param propertyOrOptions - The options used to configure child node observation.
+ * A class that declares constructor injected dependencies through
+ * a static "inject" field array of keys.
  * @public
  */
-export declare function children<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
+export declare type Injectable<T = {}> = Constructable<T> & {
+    inject?: Key[];
+};
 
 /**
- * The runtime behavior for child node observation.
+ * Used to configure a dependency injection interface key.
  * @public
  */
-export declare class ChildrenDirective extends NodeObservationDirective<ChildrenDirectiveOptions> {
-    private observerProperty;
-    /**
-     * Creates an instance of ChildrenDirective.
-     * @param options - The options to use in configuring the child observation behavior.
-     */
-    constructor(options: ChildrenDirectiveOptions);
+export declare interface InterfaceConfiguration {
     /**
-     * Begins observation of the nodes.
-     * @param target - The target to observe.
+     * The friendly name for the interface. Useful for debugging.
      */
-    observe(target: any): void;
+    friendlyName?: string;
     /**
-     * Disconnects observation of the nodes.
-     * @param target - The target to unobserve.
+     * When true, the dependency will be re-resolved when FASTElement connection changes.
+     * If the resolved value changes due to connection change, a {@link @microsoft/fast-element#Observable | notification }
+     * will be emitted for the property, with the previous and next values provided to any subscriber.
      */
-    disconnect(target: any): void;
-    /**
-     * Retrieves the raw nodes that should be assigned to the source property.
-     * @param target - The target to get the node to.
-     */
-    getNodes(target: Element): Node[];
-    private handleEvent;
+    respectConnection?: boolean;
 }
 
 /**
- * The options used to configure child/subtree node observation.
+ * A key that is used to register dependencies with a dependency injection container.
  * @public
  */
-export declare type ChildrenDirectiveOptions<T = any> = ChildListDirectiveOptions<T> | SubtreeDirectiveOptions<T>;
+export declare type Key = PropertyKey | object | ContextDecorator | Constructable | Resolver;
 
 /**
- * A function capable of compiling a template from the preprocessed form produced
- * by the html template function into a result that can instantiate views.
+ * A decorator that lazily injects a dependency depending on whether the `Key` is present at the time of function call.
+ *
+ * @example
+ * You need to make your argument a function that returns the type, for example
+ * ```ts
+ * class Foo {
+ *   constructor( @lazy('random') public random: () => number )
+ * }
+ * const foo = container.get(Foo); // instanceof Foo
+ * foo.random(); // throws
+ * ```
+ * would throw an exception because you haven't registered `'random'` before calling the method.
+ * @example
+ * This, would give you a new 'Math.random()' number each time.
+ * ```ts
+ * class Foo {
+ *   constructor( @lazy('random') public random: () => random )
+ * }
+ * container.register(Registration.callback('random', Math.random ));
+ * container.get(Foo).random(); // some random number
+ * container.get(Foo).random(); // another random number
+ * ```
+ *
+ * `@lazy` does not manage the lifecycle of the underlying key. If you want a singleton, you have to register as a
+ * `singleton`, `transient` would also behave as you would expect, providing you a new instance each time.
+ *
+ * @param key - The key to lazily resolve.
+ * see {@link DI.createContext} on interactions with interfaces
+ *
  * @public
  */
-export declare type CompilationStrategy = (
-/**
- * The preprocessed HTML string or template to compile.
- */
-html: string | HTMLTemplateElement, 
-/**
- * The behavior factories used within the html that is being compiled.
- */
-factories: Record<string, ViewBehaviorFactory>) => HTMLTemplateCompilationResult;
+export declare const lazy: (key: any) => any;
 
 /**
- * Common APIs related to compilation.
+ * A decorator that indicates that a new instance should be injected scoped to the
+ * container that requested the instance.
+ * @param key - The dependency key for the new instance.
+ * @remarks
+ * This creates a resolver with an instance strategy pointing to the new instance, effectively
+ * making this a singleton, scoped to the container or DOM's subtree.
+ *
  * @public
  */
-export declare const Compiler: {
-    /**
-     * Sets the HTML trusted types policy used by the compiler.
-     * @param policy - The policy to set for HTML.
-     * @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.
-     */
-    setHTMLPolicy(policy: TrustedTypesPolicy): void;
-    /**
-     * Compiles a template and associated directives into a compilation
-     * result which can be used to create views.
-     * @param html - The html string or template element to compile.
-     * @param directives - The directives referenced by the template.
-     * @remarks
-     * The template that is provided for compilation is altered in-place
-     * and cannot be compiled again. If the original template must be preserved,
-     * it is recommended that you clone the original and pass the clone to this API.
-     * @public
-     */
-    compile<TSource = any, TParent = any>(html: string | HTMLTemplateElement, directives: Record<string, ViewBehaviorFactory>): HTMLTemplateCompilationResult<TSource, TParent>;
-    /**
-     * Sets the default compilation strategy that will be used by the ViewTemplate whenever
-     * it needs to compile a view preprocessed with the html template function.
-     * @param strategy - The compilation strategy to use when compiling templates.
-     */
-    setDefaultStrategy(strategy: CompilationStrategy): void;
-    /**
-     * Aggregates an array of strings and directives into a single directive.
-     * @param parts - A heterogeneous array of static strings interspersed with
-     * directives.
-     * @returns A single inline directive that aggregates the behavior of all the parts.
-     */
-    aggregate(parts: (string | ViewBehaviorFactory)[]): ViewBehaviorFactory;
-};
+export declare const newInstanceForScope: (key: any) => any;
 
 /**
- * Represents styles that can be composed into the ShadowDOM of a custom element.
+ * A decorator that indicates that a new instance should be injected.
+ * @param key - The dependency key for the new instance.
+ * @remarks
+ * The instance is not internally cached with a resolver as newInstanceForScope does.
+ *
  * @public
  */
-export declare type ComposableStyles = string | ElementStyles | CSSStyleSheet;
-
-declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(this: TType, nameOrDef: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
-
-declare function compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+export declare const newInstanceOf: (key: any) => any;
 
 /**
- * Allows for the creation of Constructable mixin classes.
+ * A decorator that allows you to optionally inject a dependency depending on whether the [[`Key`]] is present, for example:
+ * @example
+ * ```ts
+ * class Foo {
+ *   constructor( @inject('mystring') public str: string = 'somestring' )
+ * }
+ * container.get(Foo); // throws
+ * ```
+ * would fail
+ *
+ * @example
+ * ```ts
+ * class Foo {
+ *   constructor( @optional('mystring') public str: string = 'somestring' )
+ * }
+ * container.get(Foo).str // somestring
+ * ```
+ * if you use it without a default it will inject `undefined`, so remember to mark your input type as
+ * possibly `undefined`!
+ *
+ * @param key - The key to optionally resolve.
+ * see {@link DI.createContext} on interactions with interfaces
  *
  * @public
  */
-export declare type Constructable<T = {}> = {
-    new (...args: any[]): T;
-};
+export declare const optional: (key: any) => any;
 
 /**
- * A type that instantiates a StyleStrategy.
+ * A temporary type as a workaround for the TS compiler's erroneous built-in ParameterDecorator type.
  * @public
  */
-export declare type ConstructibleStyleStrategy = {
-    /**
-     * Creates an instance of the strategy.
-     * @param styles - The styles to initialize the strategy with.
-     */
-    new (styles: (string | CSSStyleSheet)[]): StyleStrategy;
-};
+declare type ParameterDecorator_2 = (target: Object, propertyKey: string | undefined, parameterIndex: number) => void;
 
 /**
- * A simple template that can create ContentView instances.
+ * A function capable of locating the parent container based on a container's owner.
+ * @remarks
+ * A container owner is usually an HTMLElement instance.
  * @public
  */
-export declare interface ContentTemplate {
-    /**
-     * Creates a simple content view instance.
-     */
-    create(): ContentView;
-}
+export declare type ParentLocator = (owner: any) => Container | null;
 
 /**
- * A simple View that can be interpolated into HTML content.
+ * Represents an object that can register itself.
  * @public
  */
-export declare interface ContentView {
-    readonly context: ExecutionContext;
-    /**
-     * Binds a view's behaviors to its binding source.
-     * @param source - The binding source for the view's binding behaviors.
-     * @param context - The execution context to run the view within.
-     */
-    bind(source: any, context?: ExecutionContext): void;
-    /**
-     * Unbinds a view's behaviors from its binding source and context.
-     */
-    unbind(): void;
+export declare type RegisterSelf<T extends Constructable> = {
     /**
-     * Inserts the view's DOM nodes before the referenced node.
-     * @param node - The node to insert the view's DOM before.
+     * Registers itself with the container.
+     * @param container - The container to register with.
      */
-    insertBefore(node: Node): void;
+    register(container: Container): Resolver<InstanceType<T>>;
     /**
-     * Removes the view's DOM nodes.
-     * The nodes are not disposed and the view can later be re-inserted.
+     * Indicates whether during auto registration the object should be
+     * registered in the requesting container rather than the handling container.
      */
-    remove(): void;
-}
-
-/* Excluded from this release type: createMetadataLocator */
-
-/* Excluded from this release type: createTypeRegistry */
-
-/**
- * Transforms a template literal string into styles.
- * @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.
- * @public
- */
-export declare const css: CSSTemplateTag;
+    registerInRequestor: boolean;
+};
 
 /**
- * Directive for use in {@link css}.
- *
+ * Implemented by objects that wish to register dependencies in the container
+ * by creating resolvers.
  * @public
  */
-export declare interface CSSDirective {
+export declare interface Registration<K = any> {
     /**
-     * Creates a CSS fragment to interpolate into the CSS document.
-     * @returns - the string to interpolate into CSS
+     * Creates a resolver for a desired dependency.
+     * @param container - The container to register the dependency within.
+     * @param key - The key to register dependency under, if overridden.
      */
-    createCSS(add: AddBehavior): ComposableStyles;
+    register(container: Container): Resolver<K>;
 }
 
 /**
- * Instructs the css engine to provide dynamic styles or
- * associate behaviors with styles.
+ * You can use the resulting Registration of any of the factory methods
+ * to register with the container.
+ *
+ * @example
+ * ```
+ * class Foo {}
+ * const container = DI.createContainer();
+ * container.register(Registration.instance(Foo, new Foo()));
+ * container.get(Foo);
+ * ```
+ *
  * @public
  */
-export declare const CSSDirective: Readonly<{
+export declare const Registration: Readonly<{
+    /**
+     * Allows you to pass an instance.
+     * Every time you request this {@link Key} you will get this instance back.
+     *
+     * @example
+     * ```
+     * Registration.instance(Foo, new Foo()));
+     * ```
+     *
+     * @param key - The key to register the instance under.
+     * @param value - The instance to return when the key is requested.
+     */
+    instance<T>(key: Key, value: T): Registration<T>;
+    /**
+     * Creates an instance from the class.
+     * Every time you request this {@link Key} you will get the same one back.
+     *
+     * @example
+     * ```
+     * Registration.singleton(Foo, Foo);
+     * ```
+     *
+     * @param key - The key to register the singleton under.
+     * @param value - The class to instantiate as a singleton when first requested.
+     */
+    singleton<T_1 extends Constructable<{}>>(key: Key, value: T_1): Registration<InstanceType<T_1>>;
+    /**
+     * Creates an instance from a class.
+     * Every time you request this {@link Key} you will get a new instance.
+     *
+     * @example
+     * ```
+     * Registration.instance(Foo, Foo);
+     * ```
+     *
+     * @param key - The key to register the instance type under.
+     * @param value - The class to instantiate each time the key is requested.
+     */
+    transient<T_2 extends Constructable<{}>>(key: Key, value: T_2): Registration<InstanceType<T_2>>;
     /**
-     * Gets the directive definition associated with the instance.
-     * @param instance - The directive instance to retrieve the definition for.
+     * Delegates to a callback function to provide the dependency.
+     * Every time you request this {@link Key} the callback will be invoked to provide
+     * the dependency.
+     *
+     * @example
+     * ```
+     * Registration.callback(Foo, () => new Foo());
+     * Registration.callback(Bar, (c: Container) => new Bar(c.get(Foo)));
+     * ```
+     *
+     * @param key - The key to register the callback for.
+     * @param callback - The function that is expected to return the dependency.
      */
-    getForInstance: (object: any) => CSSDirectiveDefinition<Constructable<CSSDirective>> | undefined;
+    callback<T_3>(key: Key, callback: ResolveCallback<T_3>): Registration<Resolved<T_3>>;
     /**
-     * Gets the directive definition associated with the specified type.
-     * @param type - The directive type to retrieve the definition for.
+     * Delegates to a callback function to provide the dependency and then caches the
+     * dependency for future requests.
+     *
+     * @example
+     * ```
+     * Registration.cachedCallback(Foo, () => new Foo());
+     * Registration.cachedCallback(Bar, (c: Container) => new Bar(c.get(Foo)));
+     * ```
+     *
+     * @param key - The key to register the callback for.
+     * @param callback - The function that is expected to return the dependency.
+     * @remarks
+     * If you pass the same Registration to another container, the same cached value will be used.
+     * Should all references to the resolver returned be removed, the cache will expire.
      */
-    getByType: (key: Function) => CSSDirectiveDefinition<Constructable<CSSDirective>> | undefined;
+    cachedCallback<T_4>(key: Key, callback: ResolveCallback<T_4>): Registration<Resolved<T_4>>;
     /**
-     * Defines a CSSDirective.
-     * @param type - The type to define as a directive.
+     * Creates an alternate {@link Key} to retrieve an instance by.
+     *
+     * @example
+     * ```
+     * Register.singleton(Foo, Foo)
+     * Register.aliasTo(Foo, MyFoos);
+     *
+     * container.getAll(MyFoos) // contains an instance of Foo
+     * ```
+     *
+     * @param originalKey - The original key that has been registered.
+     * @param aliasKey - The alias to the original key.
      */
-    define<TType extends Constructable<CSSDirective>>(type: any): TType;
+    aliasTo<T_5>(originalKey: T_5, aliasKey: Key): Registration<Resolved<T_5>>;
 }>;
 
 /**
- * Decorator: Defines a CSSDirective.
- * @public
- */
-export declare function cssDirective(): (type: Constructable<CSSDirective>) => void;
-
-/**
- * Defines metadata for a CSSDirective.
+ * Implemented by objects that which to register dependencies in a container.
  * @public
  */
-export declare interface CSSDirectiveDefinition<TType extends Constructable<CSSDirective> = Constructable<CSSDirective>> {
+export declare interface Registry {
     /**
-     * The type that the definition provides metadata for.
+     * Registers dependencies in the specified container.
+     * @param container - The container to register dependencies in.
+     * @param params - Parameters that affect the registration process.
+     * @remarks
+     * If this registry doubles as a Registration, it should return a Resolver
+     * for the registered dependency.
      */
-    readonly type: TType;
+    register(container: Container, ...params: unknown[]): void | Resolver;
 }
 
 /**
- * @deprecated Use css.partial instead.
+ * Represents a custom callback for resolving a request from the container.
+ * The handler is the container that is invoking the callback. The requestor
+ * is the original container that made the request. The handler and the requestor
+ * may not be the same if the request has bubbled up to a parent container in the DI hierarchy.
+ * The resolver is the instance of the resolver that stores the callback. This is provided in case
+ * the callback needs a place or key against which to store state across resolutions.
  * @public
  */
-export declare const cssPartial: (strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => CSSDirective;
+export declare type ResolveCallback<T = any> = (handler: Container, requestor: Container, resolver: Resolver<T>) => T;
 
 /**
- * Transforms a template literal string into styles.
- * @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.
- * Use the .partial method to create partial CSS fragments.
- * @public
- */
-export declare type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]) => 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(strings: TemplateStringsArray, ...values: (ComposableStyles | CSSDirective)[]): CSSDirective;
-};
-
-/**
- * Decorator: Defines a platform custom element based on `FASTElement`.
- * @param nameOrDef - The name of the element to define or a definition object
- * that describes the element to define.
+ * Represents something resolved from a service locator.
  * @public
  */
-export declare function customElement(nameOrDef: string | PartialFASTElementDefinition): (type: Constructable<HTMLElement>) => void;
+export declare type Resolved<K> = K extends ContextDecorator<infer T> ? T : K extends Constructable ? InstanceType<K> : K extends ResolverLike<any, infer T1> ? T1 extends Constructable ? InstanceType<T1> : T1 : K;
 
 /**
- * Metadata used to configure a custom attribute's behavior through a decorator.
+ * Internally, the DI system maps "keys" to "resolvers". A resolver controls
+ * how a dependency is resolved. Resolvers for transient, singleton, etc. are
+ * provided out of the box, but you can also implement Resolver yourself and supply
+ * custom logic for resolution.
  * @public
  */
-export declare type DecoratorAttributeConfiguration = Omit<AttributeConfiguration, "property">;
-
-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;
+export declare interface Resolver<K = any> extends ResolverLike<Container, K> {
+}
 
 /**
- * Provides a mechanism for releasing resources.
+ * A utility class used that constructs and registers resolvers for a dependency
+ * injection container. Supports a standard set of object lifetimes.
  * @public
  */
-export declare interface Disposable {
+export declare class ResolverBuilder<K> {
+    private container;
+    private key;
     /**
-     * Disposes the resources.
+     *
+     * @param container - The container to create resolvers for.
+     * @param key - The key to register resolvers under.
      */
-    dispose(): void;
-}
-
-/**
- * Common DOM APIs.
- * @public
- */
-export declare const DOM: Readonly<{
+    constructor(container: Container, key: Key);
     /**
-     * @deprecated
-     * Use Updates.enqueue().
+     * Creates a resolver for an existing object instance.
+     * @param value - The instance to resolve.
+     * @returns The resolver.
      */
-    queueUpdate: (callable: Callable) => void;
+    instance(value: K): Resolver<K>;
     /**
-     * @deprecated
-     * Use Updates.next()
+     * Creates a resolver that enforces a singleton lifetime.
+     * @param value - The type to create and cache the singleton for.
+     * @returns The resolver.
      */
-    nextUpdate: () => Promise<void>;
+    singleton(value: Constructable): Resolver<K>;
     /**
-     * @deprecated
-     * Use Updates.process()
+     * Creates a resolver that creates a new instance for every dependency request.
+     * @param value - The type to create instances of.
+     * @returns - The resolver.
      */
-    processUpdates: () => void;
+    transient(value: Constructable): Resolver<K>;
     /**
-     * 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.
+     * Creates a resolver that invokes a callback function for every dependency resolution
+     * request, allowing custom logic to return the dependency.
+     * @param value - The callback to call during resolution.
+     * @returns The resolver.
      */
-    setAttribute(element: HTMLElement, attributeName: string, value: any): void;
+    callback(value: ResolveCallback<K>): Resolver<K>;
     /**
-     * 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.
+     * Creates a resolver that invokes a callback function the first time that a dependency
+     * resolution is requested. The returned value is then cached and provided for all
+     * subsequent requests.
+     * @param value - The callback to call during the first resolution.
+     * @returns The resolver.
      */
-    setBooleanAttribute(element: HTMLElement, attributeName: string, value: boolean): void;
-}>;
+    cachedCallback(value: ResolveCallback<K>): Resolver<K>;
+    /**
+     * Aliases the current key to a different key.
+     * @param destinationKey - The key to point the alias to.
+     * @returns The resolver.
+     */
+    aliasTo(destinationKey: Key): Resolver<K>;
+    private registerResolver;
+}
+
+/** @internal */
+export declare class ResolverImpl implements Resolver, Registration {
+    key: Key;
+    strategy: ResolverStrategy;
+    state: any;
+    constructor(key: Key, strategy: ResolverStrategy, state: any);
+    get $isResolver(): true;
+    private resolving;
+    register(container: Container): Resolver;
+    resolveAsync(handler: Container, requestor: Container): Promise<any>;
+    resolve(handler: Container, requestor: Container): any;
+    getFactory(container: Container): Factory | null;
+}
+
+declare interface ResolverLike<C, K = any> {
+    readonly $isResolver: true;
+    resolve(handler: C, requestor: C): Resolved<K>;
+    resolveAsync(handler: C, requestor: C): Promise<Resolved<K>>;
+    getFactory?(container: C): (K extends Constructable ? Factory<K> : never) | null;
+}
+
+/** @internal */
+export declare const enum ResolverStrategy {
+    instance = 0,
+    singleton = 1,
+    transient = 2,
+    callback = 3,
+    array = 4,
+    alias = 5
+}
 
 /**
- * Controls the lifecycle and rendering of a `FASTElement`.
+ * Implemented by objects capable of resolving services and other dependencies.
  * @public
  */
-export declare class ElementController<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier implements HostController<TElement> {
-    private boundObservables;
-    private needsInitialization;
-    private hasExistingShadowRoot;
-    private _template;
-    private _isConnected;
-    private behaviors;
-    private _mainStyles;
-    /**
-     * This allows Observable.getNotifier(...) to return the Controller
-     * when the notifier for the Controller itself is being requested. The
-     * result is that the Observable system does not need to create a separate
-     * instance of Notifier for observables on the Controller. The component and
-     * the controller will now share the same notifier, removing one-object construct
-     * per web component instance.
-     */
-    private readonly $fastController;
+export declare interface ServiceLocator {
     /**
-     * The element being controlled by this controller.
+     * Determines whether the locator has the ability to provide an implementation
+     * for the requested key.
+     * @param key - The dependency key to lookup.
+     * @param searchAncestors - Indicates whether to search the entire hierarchy of service locators.
      */
-    readonly source: TElement;
+    has<K extends Key>(key: K | Key, searchAncestors: boolean): boolean;
     /**
-     * The element definition that instructs this controller
-     * in how to handle rendering and other platform integrations.
+     * Gets a dependency by key.
+     * @param key - The key to lookup.
      */
-    readonly definition: FASTElementDefinition;
+    get<K extends Key>(key: K): Resolved<K>;
     /**
-     * The view associated with the custom element.
-     * @remarks
-     * If `null` then the element is managing its own rendering.
-     */
-    readonly view: ElementView<TElement> | null;
-    /**
-     * Indicates whether or not the custom element has been
-     * connected to the document.
-     */
-    get isConnected(): boolean;
-    private setIsConnected;
-    /**
-     * Gets/sets the template used to render the component.
-     * @remarks
-     * This value can only be accurately read after connect but can be set at any time.
-     */
-    get template(): ElementViewTemplate<TElement> | null;
-    set template(value: ElementViewTemplate<TElement> | null);
-    /**
-     * The main set of styles used for the component, independent
-     * of any dynamically added styles.
+     * Gets a dependency by key.
+     * @param key - The key to lookup.
      */
-    get mainStyles(): ElementStyles | null;
-    set mainStyles(value: ElementStyles | null);
-    /* Excluded from this release type: __constructor */
+    get<K extends Key>(key: Key): Resolved<K>;
     /**
-     * Adds the behavior to the component.
-     * @param behavior - The behavior to add.
+     * Gets a dependency by key.
+     * @param key - The key to lookup.
      */
-    addBehavior(behavior: HostBehavior<TElement>): void;
+    get<K extends Key>(key: K | Key): Resolved<K>;
     /**
-     * Removes the behavior from the component.
-     * @param behavior - The behavior to remove.
-     * @param force - Forces removal even if this behavior was added more than once.
+     * Gets a dependency by key, allowing for asynchronously
+     * resolved dependencies.
+     * @param key - The key to lookup.
      */
-    removeBehavior(behavior: HostBehavior<TElement>, force?: boolean): void;
+    getAsync<K extends Key>(key: K): Promise<Resolved<K>>;
     /**
-     * Adds styles to this element. Providing an HTMLStyleElement will attach the element instance to the shadowRoot.
-     * @param styles - The styles to add.
+     * Gets a dependency by key, allowing for asynchronously
+     * resolved dependencies.
+     * @param key - The key to lookup.
      */
-    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    getAsync<K extends Key>(key: Key): Promise<Resolved<K>>;
     /**
-     * Removes styles from this element. Providing an HTMLStyleElement will detach the element instance from the shadowRoot.
-     * @param styles - the styles to remove.
+     * Gets a dependency by key, allowing for asynchronously
+     * resolved dependencies.
+     * @param key - The key to lookup.
      */
-    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
+    getAsync<K extends Key>(key: K | Key): Promise<Resolved<K>>;
     /**
-     * Runs connected lifecycle behavior on the associated element.
+     * Gets an array of all dependencies by key.
+     * @param key - The key to lookup.
+     * @param searchAncestors - Indicates whether to search the entire hierarchy of service locators.
      */
-    connect(): void;
+    getAll<K extends Key>(key: K, searchAncestors?: boolean): readonly Resolved<K>[];
     /**
-     * Runs disconnected lifecycle behavior on the associated element.
+     * Gets an array of all dependencies by key.
+     * @param key - The key to lookup.
+     * @param searchAncestors - Indicates whether to search the entire hierarchy of service locators.
      */
-    disconnect(): void;
+    getAll<K extends Key>(key: Key, searchAncestors?: boolean): readonly Resolved<K>[];
     /**
-     * Runs the attribute changed callback for the associated element.
-     * @param name - The name of the attribute that changed.
-     * @param oldValue - The previous value of the attribute.
-     * @param newValue - The new value of the attribute.
+     * Gets an array of all dependencies by key.
+     * @param key - The key to lookup.
+     * @param searchAncestors - Indicates whether to search the entire hierarchy of service locators.
      */
-    onAttributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-    /**
-     * Emits a custom HTML event.
-     * @param type - The type name of the event.
-     * @param detail - The event detail object to send with the event.
-     * @param options - The event options. By default bubbles and composed.
-     * @remarks
-     * Only emits events if connected.
-     */
-    emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
-    private finishInitialization;
-    private renderTemplate;
-    /**
-     * Locates or creates a controller for the specified element.
-     * @param element - The element to return the controller for.
-     * @remarks
-     * The specified element must have a {@link FASTElementDefinition}
-     * registered either through the use of the {@link customElement}
-     * decorator or a call to `FASTElement.define`.
-     */
-    static forCustomElement(element: HTMLElement): ElementController;
+    getAll<K extends Key>(key: K | Key, searchAncestors?: boolean): readonly Resolved<K>[];
 }
 
 /**
- * Creates a function that can be used to filter a Node array, selecting only elements.
- * @param selector - An optional selector to restrict the filter to.
+ * The key that resolves the ServiceLocator itself.
  * @public
  */
-export declare const elements: (selector?: string) => ElementsFilter;
+export declare const ServiceLocator: ContextDecorator<ServiceLocator>;
 
 /**
- * Elements filter function type.
+ * Registers the decorated class as a singleton dependency; the class will only be created once. Each
+ * consecutive time the dependency is resolved, the same instance will be returned.
+ *
+ * @example
+ * ```ts
+ * @singleton()
+ * class Foo { }
+ * ```
  *
  * @public
  */
-export declare type ElementsFilter = (value: Node, index?: number, array?: Node[]) => boolean;
+export declare function singleton<T extends Constructable>(): typeof singletonDecorator;
 
 /**
- * Represents styles that can be applied to a custom element.
  * @public
  */
-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.
-     */
-    get strategy(): StyleStrategy;
-    /**
-     * Creates an instance of ElementStyles.
-     * @param styles - The styles that will be associated with elements.
-     */
-    constructor(styles: ReadonlyArray<ComposableStyles>);
-    /* Excluded from this release type: addStylesTo */
-    /* Excluded from this release type: removeStylesFrom */
-    /* Excluded from this release type: isAttachedTo */
-    /**
-     * 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.
-     */
-    withStrategy(Strategy: ConstructibleStyleStrategy): this;
-    /**
-     * Sets the default strategy type to use when creating style strategies.
-     * @param Strategy - The strategy type to construct.
-     */
-    static setDefaultStrategy(Strategy: ConstructibleStyleStrategy): void;
-    /**
-     * Normalizes a set of composable style options.
-     * @param styles - The style options to normalize.
-     * @returns A singular ElementStyles instance or undefined.
-     */
-    static normalize(styles: ComposableStyles | ComposableStyles[] | undefined): ElementStyles | undefined;
-    /**
-     * Indicates whether the DOM supports the adoptedStyleSheets feature.
-     */
-    static readonly supportsAdoptedStyleSheets: boolean;
-}
+export declare function singleton<T extends Constructable>(options?: SingletonOptions): typeof singletonDecorator;
 
 /**
- * A View representing DOM nodes specifically for rendering the view of a custom element.
- * @public
- */
-export declare interface ElementView<TSource = any, TParent = any> extends View<TSource, TParent> {
-    /**
-     * Appends the view's DOM nodes to the referenced node.
-     * @param node - The parent node to append the view's DOM nodes to.
-     */
-    appendTo(node: Node): void;
-}
-
-/**
- * A template capable of creating views specifically for rendering custom elements.
- * @public
- */
-export declare interface ElementViewTemplate<TSource = any, TParent = any> {
-    /**
-     * Creates an ElementView instance based on this template definition.
-     * @param hostBindingTarget - The element that host behaviors will be bound to.
-     */
-    create(hostBindingTarget: Element): ElementView<TSource, TParent>;
-    /**
-     * Creates an HTMLView from this template, binds it to the source, and then appends it to the host.
-     * @param source - The data source to bind the template to.
-     * @param host - The Element where the template will be rendered.
-     * @param hostBindingTarget - An HTML element to target the host bindings at if different from the
-     * host that the template is being attached to.
-     */
-    render(source: TSource, host: Node, hostBindingTarget?: Element): ElementView<TSource, TParent>;
-}
-
-/**
- * A readonly, empty array.
- * @remarks
- * Typically returned by APIs that return arrays when there are
- * no actual items to return.
- * @public
- */
-export declare const emptyArray: readonly never[];
-
-/**
- * Provides additional contextual information available to behaviors and expressions.
- * @public
- */
-export declare interface ExecutionContext<TParent = any> {
-    /**
-     * The index of the current item within a repeat context.
-     */
-    index: number;
-    /**
-     * The length of the current collection within a repeat context.
-     */
-    length: number;
-    /**
-     * The parent data source within a nested context.
-     */
-    parent: TParent;
-    /**
-     * The parent execution context when in nested context scenarios.
-     */
-    parentContext: ExecutionContext<TParent>;
-    /**
-     * The current event within an event handler.
-     */
-    readonly event: Event;
-    /**
-     * Indicates whether the current item within a repeat context
-     * has an even index.
-     */
-    readonly isEven: boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * has an odd index.
-     */
-    readonly isOdd: boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * is the first item in the collection.
-     */
-    readonly isFirst: boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * is somewhere in the middle of the collection.
-     */
-    readonly isInMiddle: boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * is the last item in the collection.
-     */
-    readonly isLast: boolean;
-    /**
-     * Returns the typed event detail of a custom event.
-     */
-    eventDetail<TDetail>(): TDetail;
-    /**
-     * Returns the typed event target of the event.
-     */
-    eventTarget<TTarget extends EventTarget>(): TTarget;
-}
-
-/**
- * Provides additional contextual information available to behaviors and expressions.
- * @public
- */
-export declare const ExecutionContext: Readonly<{
-    /**
-     * A default execution context.
-     */
-    default: ExecutionContext<any>;
-    /**
-     * Gets the current event.
-     * @returns An event object.
-     */
-    getEvent(): Event | null;
-    /**
-     * Sets the current event.
-     * @param event - An event object.
-     */
-    setEvent(event: Event | null): void;
-}>;
-
-/**
- * The signature of an arrow function capable of being evaluated
- * against source data and within an execution context.
- * @public
- */
-export declare type Expression<TSource = any, TReturn = any, TParent = any> = (source: TSource, context: ExecutionContext<TParent>) => TReturn;
-
-/**
- * Controls the lifecycle of an expression and provides relevant context.
- * @public
- */
-export declare interface ExpressionController<TSource = any, TParent = any> {
-    /**
-     * The source the expression is evaluated against.
-     */
-    readonly source: TSource;
-    /**
-     * Indicates how the source's lifetime relates to the controller's lifetime.
-     */
-    readonly sourceLifetime?: SourceLifetime;
-    /**
-     * The context the expression is evaluated against.
-     */
-    readonly context: ExecutionContext<TParent>;
-    /**
-     * Indicates whether the controller is bound.
-     */
-    readonly isBound: boolean;
-    /**
-     * Registers an unbind handler with the controller.
-     * @param behavior - An object to call when the controller unbinds.
-     */
-    onUnbind(behavior: {
-        unbind(controller: ExpressionController<TSource, TParent>): any;
-    }): void;
-}
-
-/**
- * Enables evaluation of and subscription to a binding.
- * @public
- */
-export declare interface ExpressionNotifier<TSource = any, TReturn = any, TParent = any> extends Notifier, ExpressionObserver<TSource, TReturn, TParent>, Disposable {
-    /**
-     * Observes the expression.
-     * @param source - The source for the expression.
-     * @param context - The context for the expression.
-     */
-    observe(source: TSource, context?: ExecutionContext): TReturn;
-    /**
-     * Gets {@link ObservationRecord|ObservationRecords} that the {@link ExpressionNotifier}
-     * is observing.
-     */
-    records(): IterableIterator<ObservationRecord>;
-    /**
-     * Sets the update mode used by the observer.
-     * @param isAsync - Indicates whether updates should be asynchronous.
-     * @remarks
-     * By default, the update mode is asynchronous, since that provides the best
-     * performance for template rendering scenarios. Passing false to setMode will
-     * instead cause the observer to notify subscribers immediately when changes occur.
-     */
-    setMode(isAsync: boolean): void;
-}
-
-/**
- * Observes an expression for changes.
- * @public
- */
-export declare interface ExpressionObserver<TSource = any, TReturn = any, TParent = any> {
-    /**
-     * Binds the expression to the source.
-     * @param controller - The controller that manages the lifecycle and related
-     * context for the expression.
-     */
-    bind(controller: ExpressionController<TSource, TParent>): TReturn;
-}
-
-/* Excluded from this release type: FAST */
-
-/**
- * Represents a custom element based on the FASTElement infrastructure.
- * @public
- */
-export declare interface FASTElement extends HTMLElement {
-    /**
-     * The underlying controller that handles the lifecycle and rendering of
-     * this FASTElement.
-     */
-    readonly $fastController: ElementController;
-    /**
-     * Emits a custom HTML event.
-     * @param type - The type name of the event.
-     * @param detail - The event detail object to send with the event.
-     * @param options - The event options. By default bubbles and composed.
-     * @remarks
-     * Only emits events if the element is connected.
-     */
-    $emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): boolean | void;
-    /**
-     * The connected callback for this FASTElement.
-     * @remarks
-     * This method is invoked by the platform whenever this FASTElement
-     * becomes connected to the document.
-     */
-    connectedCallback(): void;
-    /**
-     * The disconnected callback for this FASTElement.
-     * @remarks
-     * This method is invoked by the platform whenever this FASTElement
-     * becomes disconnected from the document.
-     */
-    disconnectedCallback(): void;
-    /**
-     * The attribute changed callback for this FASTElement.
-     * @param name - The name of the attribute that changed.
-     * @param oldValue - The previous value of the attribute.
-     * @param newValue - The new value of the attribute.
-     * @remarks
-     * This method is invoked by the platform whenever an observed
-     * attribute of FASTElement has a value change.
-     */
-    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
-}
-
-/**
- * A minimal base class for FASTElements that also provides
- * static helpers for working with FASTElements.
- * @public
- */
-export declare const FASTElement: {
-    new (): FASTElement;
-    define: typeof define;
-    compose: typeof compose;
-    from: typeof from;
-};
-
-/**
- * Defines metadata for a FASTElement.
- * @public
- */
-export declare class FASTElementDefinition<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>> {
-    private platformDefined;
-    /**
-     * The type this element definition describes.
-     */
-    readonly type: TType;
-    /**
-     * Indicates if this element has been defined in at least one registry.
-     */
-    get isDefined(): boolean;
-    /**
-     * The name of the custom element.
-     */
-    readonly name: string;
-    /**
-     * The custom attributes of the custom element.
-     */
-    readonly attributes: ReadonlyArray<AttributeDefinition>;
-    /**
-     * A map enabling lookup of attribute by associated property name.
-     */
-    readonly propertyLookup: Record<string, AttributeDefinition>;
-    /**
-     * A map enabling lookup of property by associated attribute name.
-     */
-    readonly attributeLookup: Record<string, AttributeDefinition>;
-    /**
-     * The template to render for the custom element.
-     */
-    readonly template?: ElementViewTemplate;
-    /**
-     * The styles to associate with the custom element.
-     */
-    readonly styles?: ElementStyles;
-    /**
-     * Options controlling the creation of the custom element's shadow DOM.
-     */
-    readonly shadowOptions?: ShadowRootOptions;
-    /**
-     * Options controlling how the custom element is defined with the platform.
-     */
-    readonly elementOptions: ElementDefinitionOptions;
-    /**
-     * The registry to register this component in by default.
-     */
-    readonly registry: CustomElementRegistry;
-    private constructor();
-    /**
-     * Defines a custom element based on this definition.
-     * @param registry - The element registry to define the element in.
-     * @remarks
-     * This operation is idempotent per registry.
-     */
-    define(registry?: CustomElementRegistry): 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>;
-    /**
-     * Gets the element definition associated with the specified type.
-     * @param type - The custom element type to retrieve the definition for.
-     */
-    static readonly getByType: (key: Function) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
-    /**
-     * Gets the element definition associated with the instance.
-     * @param instance - The custom element instance to retrieve the definition for.
-     */
-    static readonly getForInstance: (object: any) => FASTElementDefinition<Constructable<HTMLElement>> | undefined;
-}
-
-/* Excluded from this release type: FASTGlobal */
-
-declare function from<TBase extends typeof HTMLElement>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
-
-/**
- * Represents an object that can contribute behavior to a host.
- * @public
- */
-export declare interface HostBehavior<TSource = any> {
-    /**
-     * Executed when this behavior is attached to a controller.
-     * @param controller - Controls the behavior lifecycle.
-     */
-    addedCallback?(controller: HostController<TSource>): void;
-    /**
-     * Executed when this behavior is detached from a controller.
-     * @param controller - Controls the behavior lifecycle.
-     */
-    removedCallback?(controller: HostController<TSource>): void;
-    /**
-     * Executed when this behavior's host is connected.
-     * @param controller - Controls the behavior lifecycle.
-     */
-    connectedCallback?(controller: HostController<TSource>): void;
-    /**
-     * Executed when this behavior's host is disconnected.
-     * @param controller - Controls the behavior lifecycle.
-     */
-    disconnectedCallback?(controller: HostController<TSource>): void;
-}
-
-/**
- * Controls the lifecycle and context of behaviors and styles
- * associated with a component host.
- * @public
- */
-export declare interface HostController<TSource = any> {
-    /**
-     * The component source.
-     */
-    readonly source: TSource;
-    /**
-     * Indicates whether the host is connected or not.
-     */
-    readonly isConnected: boolean;
-    /**
-     * The main set of styles used for the component, independent
-     * of any behavior-specific styles.
-     */
-    mainStyles: ElementStyles | null;
-    /**
-     * Adds the behavior to the component.
-     * @param behavior - The behavior to add.
-     */
-    addBehavior(behavior: HostBehavior<TSource>): void;
-    /**
-     * Removes the behavior from the component.
-     * @param behavior - The behavior to remove.
-     * @param force - Forces removal even if this behavior was added more than once.
-     */
-    removeBehavior(behavior: HostBehavior<TSource>, force?: boolean): void;
-    /**
-     * Adds styles to this element. Providing an HTMLStyleElement will attach the element instance to the shadowRoot.
-     * @param styles - The styles to add.
-     */
-    addStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-    /**
-     * Removes styles from this element. Providing an HTMLStyleElement will detach the element instance from the shadowRoot.
-     * @param styles - the styles to remove.
-     */
-    removeStyles(styles: ElementStyles | HTMLStyleElement | null | undefined): void;
-}
-
-/**
- * Transforms a template literal string into a ViewTemplate.
- * @param strings - The string fragments that are interpolated with the values.
- * @param values - The values that are interpolated with the string fragments.
- * @remarks
- * The html helper supports interpolation of strings, numbers, binding expressions,
- * other template instances, and Directive instances.
- * @public
- */
-export declare function html<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: TemplateValue<TSource, TParent>[]): ViewTemplate<TSource, TParent>;
-
-/**
- * A directive that applies bindings.
- * @public
- */
-export declare class HTMLBindingDirective implements HTMLDirective, ViewBehaviorFactory, ViewBehavior, Aspected {
-    dataBinding: Binding;
-    private data;
-    private updateTarget;
-    /**
-     * The unique id of the factory.
-     */
-    id: string;
-    /**
-     * The structural id of the DOM node to which the created behavior will apply.
-     */
-    nodeId: string;
-    /**
-     * The original source aspect exactly as represented in markup.
-     */
-    sourceAspect: string;
-    /**
-     * The evaluated target aspect, determined after processing the source.
-     */
-    targetAspect: string;
-    /**
-     * The type of aspect to target.
-     */
-    aspectType: Aspect;
-    /**
-     * Creates an instance of HTMLBindingDirective.
-     * @param dataBinding - The binding configuration to apply.
-     */
-    constructor(dataBinding: Binding);
-    /**
-     * Creates HTML to be used within a template.
-     * @param add - Can be used to add  behavior factories to a template.
-     */
-    createHTML(add: AddViewBehaviorFactory): string;
-    /**
-     * Creates a behavior.
-     */
-    createBehavior(): ViewBehavior;
-    /* Excluded from this release type: bindDefault */
-    /* Excluded from this release type: bind */
-    /* Excluded from this release type: bindContent */
-    /* Excluded from this release type: bindEvent */
-    /* Excluded from this release type: unbind */
-    /* Excluded from this release type: handleEvent */
-    /* Excluded from this release type: handleChange */
-}
-
-/**
- * Instructs the template engine to apply behavior to a node.
- * @public
- */
-export declare interface HTMLDirective {
-    /**
-     * Creates HTML to be used within a template.
-     * @param add - Can be used to add  behavior factories to a template.
-     */
-    createHTML(add: AddViewBehaviorFactory): string;
-}
-
-/**
- * Instructs the template engine to apply behavior to a node.
- * @public
- */
-export declare const HTMLDirective: Readonly<{
-    /**
-     * Gets the directive definition associated with the instance.
-     * @param instance - The directive instance to retrieve the definition for.
-     */
-    getForInstance: (object: any) => HTMLDirectiveDefinition<Constructable<HTMLDirective>> | undefined;
-    /**
-     * Gets the directive definition associated with the specified type.
-     * @param type - The directive type to retrieve the definition for.
-     */
-    getByType: (key: Function) => HTMLDirectiveDefinition<Constructable<HTMLDirective>> | undefined;
-    /**
-     * Defines an HTMLDirective based on the options.
-     * @param type - The type to define as a directive.
-     * @param options - Options that specify the directive's application.
-     */
-    define<TType extends Constructable<HTMLDirective>>(type: TType, options?: PartialHTMLDirectiveDefinition): TType;
-}>;
-
-/**
- * Decorator: Defines an HTMLDirective.
- * @param options - Provides options that specify the directive's application.
- * @public
- */
-export declare function htmlDirective(options?: PartialHTMLDirectiveDefinition): (type: Constructable<HTMLDirective>) => void;
-
-/**
- * Defines metadata for an HTMLDirective.
- * @public
- */
-export declare interface HTMLDirectiveDefinition<TType extends Constructable<HTMLDirective> = Constructable<HTMLDirective>> extends Required<PartialHTMLDirectiveDefinition> {
-    /**
-     * The type that the definition provides metadata for.
-     */
-    readonly type: TType;
-}
-
-/**
- * The result of a template compilation operation.
- * @public
- */
-export declare interface HTMLTemplateCompilationResult<TSource = any, TParent = any> {
-    /**
-     * Creates a view instance.
-     * @param hostBindingTarget - The host binding target for the view.
-     */
-    createView(hostBindingTarget?: Element): HTMLView<TSource, TParent>;
-}
-
-/**
- * The standard View implementation, which also implements ElementView and SyntheticView.
- * @public
- */
-export declare class HTMLView<TSource = any, TParent = any> implements ElementView<TSource, TParent>, SyntheticView<TSource, TParent>, ExecutionContext<TParent> {
-    private fragment;
-    private factories;
-    readonly targets: ViewBehaviorTargets;
-    private behaviors;
-    private unbindables;
-    /**
-     * The data that the view is bound to.
-     */
-    source: TSource | null;
-    /**
-     * Indicates whether the controller is bound.
-     */
-    isBound: boolean;
-    /**
-     * Indicates how the source's lifetime relates to the controller's lifetime.
-     */
-    readonly sourceLifetime: SourceLifetime;
-    /**
-     * The execution context the view is running within.
-     */
-    context: ExecutionContext<TParent>;
-    /**
-     * The index of the current item within a repeat context.
-     */
-    index: number;
-    /**
-     * The length of the current collection within a repeat context.
-     */
-    length: number;
-    /**
-     * The parent data source within a nested context.
-     */
-    readonly parent: TParent;
-    /**
-     * The parent execution context when in nested context scenarios.
-     */
-    readonly parentContext: ExecutionContext<TParent>;
-    /**
-     * The current event within an event handler.
-     */
-    get event(): Event;
-    /**
-     * Indicates whether the current item within a repeat context
-     * has an even index.
-     */
-    get isEven(): boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * has an odd index.
-     */
-    get isOdd(): boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * is the first item in the collection.
-     */
-    get isFirst(): boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * is somewhere in the middle of the collection.
-     */
-    get isInMiddle(): boolean;
-    /**
-     * Indicates whether the current item within a repeat context
-     * is the last item in the collection.
-     */
-    get isLast(): boolean;
-    /**
-     * Returns the typed event detail of a custom event.
-     */
-    eventDetail<TDetail>(): TDetail;
-    /**
-     * Returns the typed event target of the event.
-     */
-    eventTarget<TTarget extends EventTarget>(): TTarget;
-    /**
-     * The first DOM node in the range of nodes that make up the view.
-     */
-    firstChild: Node;
-    /**
-     * The last DOM node in the range of nodes that make up the view.
-     */
-    lastChild: Node;
-    /**
-     * Constructs an instance of HTMLView.
-     * @param fragment - The html fragment that contains the nodes for this view.
-     * @param behaviors - The behaviors to be applied to this view.
-     */
-    constructor(fragment: DocumentFragment, factories: ReadonlyArray<ViewBehaviorFactory>, targets: ViewBehaviorTargets);
-    /**
-     * Appends the view's DOM nodes to the referenced node.
-     * @param node - The parent node to append the view's DOM nodes to.
-     */
-    appendTo(node: Node): void;
-    /**
-     * Inserts the view's DOM nodes before the referenced node.
-     * @param node - The node to insert the view's DOM before.
-     */
-    insertBefore(node: Node): void;
-    /**
-     * Removes the view's DOM nodes.
-     * The nodes are not disposed and the view can later be re-inserted.
-     */
-    remove(): 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>): any;
-    }): void;
-    /**
-     * Binds a view's behaviors to its binding source.
-     * @param source - The binding source for the view's binding behaviors.
-     * @param context - The execution context to run the behaviors within.
-     */
-    bind(source: TSource, context?: ExecutionContext<TParent>): void;
-    /**
-     * Unbinds a view's behaviors from its binding source.
-     */
-    unbind(): void;
-    private evaluateUnbindables;
-    /**
-     * 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;
-}
-
-/**
- * Observes array lengths.
- * @public
- */
-export declare interface LengthObserver extends Subscriber {
-    /**
-     * The length of the observed array.
-     */
-    length: number;
-}
-
-/**
- * Enables observing the length of an array.
- * @param array - The array to observe the length of.
- * @returns The length of the array.
- * @public
- */
-export declare function lengthOf<T>(array: readonly T[]): number;
-
-/**
- * Creates an event listener binding.
- * @param binding - The binding to invoke when the event is raised.
- * @param options - Event listener options.
- * @returns A binding configuration.
- * @public
- */
-export declare function listener<T = any>(binding: Expression<T>, options?: AddEventListenerOptions): Binding<T>;
-
-/**
- * Common APIs related to markup generation.
- * @public
- */
-export declare const Markup: Readonly<{
-    /**
-     * Creates a placeholder string suitable for marking out a location *within*
-     * an attribute value or HTML content.
-     * @param index - The directive index to create the placeholder for.
-     * @remarks
-     * Used internally by binding directives.
-     */
-    interpolation: (id: string) => string;
-    /**
-     * Creates a placeholder that manifests itself as an attribute on an
-     * element.
-     * @param attributeName - The name of the custom attribute.
-     * @param index - The directive index to create the placeholder for.
-     * @remarks
-     * Used internally by attribute directives such as `ref`, `slotted`, and `children`.
-     */
-    attribute: (id: string) => string;
-    /**
-     * Creates a placeholder that manifests itself as a marker within the DOM structure.
-     * @param index - The directive index to create the placeholder for.
-     * @remarks
-     * Used internally by structural directives such as `repeat`.
-     */
-    comment: (id: string) => string;
-}>;
-
-/* Excluded from this release type: Mutable */
-
-/**
- * Options for configuring node observation behavior.
- * @public
- */
-export declare interface NodeBehaviorOptions<T = any> {
-    /**
-     * The property to assign the observed nodes to.
-     */
-    property: T;
-    /**
-     * Filters nodes that are synced with the property.
-     * Called one time for each element in the array.
-     * @param value - The Node that is being inspected.
-     * @param index - The index of the node within the array.
-     * @param array - The Node array that is being filtered.
-     */
-    filter?: ElementsFilter;
-}
-
-/**
- * A base class for node observation.
- * @public
- * @remarks
- * Internally used by the SlottedDirective and the ChildrenDirective.
- */
-export declare abstract class NodeObservationDirective<T extends NodeBehaviorOptions> extends StatelessAttachedAttributeDirective<T> {
-    private sourceProperty;
-    /**
-     * Bind this behavior to the source.
-     * @param source - The source to bind to.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    bind(controller: ViewController): void;
-    /**
-     * Unbinds this behavior from the source.
-     * @param source - The source to unbind from.
-     * @param context - The execution context that the binding is operating within.
-     * @param targets - The targets that behaviors in a view can attach to.
-     */
-    unbind(controller: ViewController): void;
-    /**
-     * Gets the data source for the target.
-     * @param target - The target to get the source for.
-     * @returns The source.
-     */
-    protected getSource(target: Node): any;
-    /**
-     * Updates the source property with the computed nodes.
-     * @param source - The source object to assign the nodes property to.
-     * @param value - The nodes to assign to the source object property.
-     */
-    protected updateTarget(source: any, value: ReadonlyArray<any>): void;
-    /**
-     * Computes the set of nodes that should be assigned to the source property.
-     * @param target - The target to compute the nodes for.
-     * @returns The computed nodes.
-     * @remarks
-     * Applies filters if provided.
-     */
-    protected computeNodes(target: any): Node[];
-    /**
-     * Begins observation of the nodes.
-     * @param target - The target to observe.
-     */
-    protected abstract observe(target: any): void;
-    /**
-     * Disconnects observation of the nodes.
-     * @param target - The target to unobserve.
-     */
-    protected abstract disconnect(target: any): void;
-    /**
-     * Retrieves the raw nodes that should be assigned to the source property.
-     * @param target - The target to get the node to.
-     */
-    protected abstract getNodes(target: any): Node[];
-}
-
-/**
- * Normalizes the input value into a binding.
- * @param value - The value to create the default binding for.
- * @returns A binding configuration for the provided value.
- * @public
- */
-export declare function normalizeBinding<TSource = any, TReturn = any, TParent = any>(value: Expression<TSource, TReturn, TParent> | Binding<TSource, TReturn, TParent> | {}): Binding<TSource, TReturn, TParent>;
-
-/**
- * Provides change notifications for an observed subject.
- * @public
- */
-export declare interface Notifier {
-    /**
-     * The object that subscribers will receive notifications for.
-     */
-    readonly subject: any;
-    /**
-     * Notifies all subscribers, based on the args.
-     * @param args - Data passed along to subscribers during notification.
-     * @remarks
-     * In some implementations, the args may be used to target specific subscribers.
-     * This is usually in the case where a propertyName was passed during subscription.
-     */
-    notify(args: any): void;
-    /**
-     * Subscribes to notification of changes in an object's state.
-     * @param subscriber - The object that is subscribing for change notification.
-     * @param propertyToWatch - The name of the property that the subscriber is interested in watching for changes.
-     * @remarks
-     * Some implementation may or may not require the propertyToWatch.
-     */
-    subscribe(subscriber: Subscriber, propertyToWatch?: any): void;
-    /**
-     * Unsubscribes from notification of changes in an object's state.
-     * @param subscriber - The object that is unsubscribing from change notification.
-     * @param propertyToUnwatch - The name of the property that the subscriber is no longer interested in watching.
-     * @remarks
-     * Some implementation may or may not require the propertyToUnwatch.
-     */
-    unsubscribe(subscriber: Subscriber, propertyToUnwatch?: any): void;
-}
-
-/**
- * A {@link ValueConverter} that converts to and from `number` values.
- * @remarks
- * This converter allows for nullable numbers, returning `null` if the
- * input was `null`, `undefined`, or `NaN`.
- * @public
- */
-export declare const nullableNumberConverter: ValueConverter;
-
-/**
- * Common Observable APIs.
- * @public
- */
-export declare const Observable: Readonly<{
-    /* Excluded from this release type: setArrayObserverFactory */
-    /**
-     * Gets a notifier for an object or Array.
-     * @param source - The object or Array to get the notifier for.
-     */
-    getNotifier: <T extends Notifier = Notifier>(source: any) => T;
-    /**
-     * Records a property change for a source object.
-     * @param source - The object to record the change against.
-     * @param propertyName - The property to track as changed.
-     */
-    track(source: unknown, propertyName: string): void;
-    /**
-     * Notifies watchers that the currently executing property getter or function is volatile
-     * with respect to its observable dependencies.
-     */
-    trackVolatile(): void;
-    /**
-     * Notifies subscribers of a source object of changes.
-     * @param source - the object to notify of changes.
-     * @param args - The change args to pass to subscribers.
-     */
-    notify(source: unknown, args: any): void;
-    /**
-     * Defines an observable property on an object or prototype.
-     * @param target - The target object to define the observable on.
-     * @param nameOrAccessor - The name of the property to define as observable;
-     * or a custom accessor that specifies the property name and accessor implementation.
-     */
-    defineProperty(target: {}, nameOrAccessor: string | Accessor): void;
-    /**
-     * Finds all the observable accessors defined on the target,
-     * including its prototype chain.
-     * @param target - The target object to search for accessor on.
-     */
-    getAccessors: (target: {}) => Accessor[];
-    /**
-     * Creates a {@link ExpressionNotifier} that can watch the
-     * provided {@link Expression} for changes.
-     * @param binding - 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>;
-    /**
-     * 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.
-     */
-    isVolatileBinding<TSource_1 = any, TReturn_1 = any>(binding: Expression<TSource_1, TReturn_1, any>): boolean;
-}>;
-
-/**
- * Decorator: Defines an observable property on the target.
- * @param target - The target to define the observable on.
- * @param nameOrAccessor - The property name or accessor to define the observable as.
- * @public
- */
-export declare function observable(target: {}, nameOrAccessor: string | Accessor): void;
-
-/**
- * A record of observable property access.
- * @public
- */
-export declare interface ObservationRecord {
-    /**
-     * The source object with an observable property that was accessed.
-     */
-    propertySource: any;
-    /**
-     * The name of the observable property on {@link ObservationRecord.propertySource} that was accessed.
-     */
-    propertyName: string;
-}
-
-/**
- * Creates a one time binding
- * @param binding - The binding to refresh when signaled.
- * @returns A binding configuration.
- * @public
- */
-export declare function oneTime<T = any>(binding: Expression<T>): Binding<T>;
-
-/**
- * Common APIs related to content parsing.
- * @public
- */
-export declare const Parser: Readonly<{
-    /**
-     * Parses text content or HTML attribute content, separating out the static strings
-     * from the directives.
-     * @param value - The content or attribute string to parse.
-     * @param factories - A list of directives to search for in the string.
-     * @returns A heterogeneous array of static strings interspersed with
-     * directives or null if no directives are found in the string.
-     */
-    parse(value: string, factories: Record<string, ViewBehaviorFactory>): (string | ViewBehaviorFactory)[] | null;
-}>;
-
-/**
- * Represents metadata configuration for a custom element.
- * @public
- */
-export declare interface PartialFASTElementDefinition {
-    /**
-     * The name of the custom element.
-     */
-    readonly name: string;
-    /**
-     * The template to render for the custom element.
-     */
-    readonly template?: ElementViewTemplate;
-    /**
-     * The styles to associate with the custom element.
-     */
-    readonly styles?: ComposableStyles | ComposableStyles[];
-    /**
-     * The custom attributes of the custom element.
-     */
-    readonly attributes?: (AttributeConfiguration | string)[];
-    /**
-     * Options controlling the creation of the custom element's shadow DOM.
-     * @remarks
-     * If not provided, defaults to an open shadow root. Provide null
-     * to render to the associated template to the light DOM instead.
-     */
-    readonly shadowOptions?: Partial<ShadowRootOptions> | null;
-    /**
-     * Options controlling how the custom element is defined with the platform.
-     */
-    readonly elementOptions?: ElementDefinitionOptions;
-    /**
-     * The registry to register this component in by default.
-     * @remarks
-     * If not provided, defaults to the global registry.
-     */
-    readonly registry?: CustomElementRegistry;
-}
-
-/**
- * Represents metadata configuration for an HTMLDirective.
- * @public
- */
-export declare interface PartialHTMLDirectiveDefinition {
-    /**
-     * Indicates whether the directive needs access to template contextual information
-     * such as the sourceAspect, targetAspect, and aspectType.
-     */
-    aspected?: boolean;
-}
-
-/**
- * An implementation of Notifier that allows subscribers to be notified
- * of individual property changes on an object.
- * @public
- */
-export declare class PropertyChangeNotifier implements Notifier {
-    private subscribers;
-    private subjectSubscribers;
-    /**
-     * The subject that property changes are being notified for.
-     */
-    readonly subject: any;
-    /**
-     * Creates an instance of PropertyChangeNotifier for the specified subject.
-     * @param subject - The object that subscribers will receive notifications for.
-     */
-    constructor(subject: any);
-    /**
-     * Notifies all subscribers, based on the specified property.
-     * @param propertyName - The property name, passed along to subscribers during notification.
-     */
-    notify(propertyName: string): void;
-    /**
-     * Subscribes to notification of changes in an object's state.
-     * @param subscriber - The object that is subscribing for change notification.
-     * @param propertyToWatch - The name of the property that the subscriber is interested in watching for changes.
-     */
-    subscribe(subscriber: Subscriber, propertyToWatch?: string): void;
-    /**
-     * Unsubscribes from notification of changes in an object's state.
-     * @param subscriber - The object that is unsubscribing from change notification.
-     * @param propertyToUnwatch - The name of the property that the subscriber is no longer interested in watching.
-     */
-    unsubscribe(subscriber: Subscriber, propertyToUnwatch?: string): void;
-}
-
-/**
- * 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.
- * @public
- */
-export declare const ref: <TSource = any, TParent = any>(propertyName: keyof TSource & string) => CaptureType<TSource, TParent>;
-
-/**
- * The runtime behavior for template references.
- * @public
- */
-export declare class RefDirective extends StatelessAttachedAttributeDirective<string> {
-    /**
-     * Bind this behavior.
-     * @param controller - The view controller that manages the lifecycle of this behavior.
-     */
-    bind(controller: ViewController): void;
-}
-
-declare const reflectMode = "reflect";
-
-/**
- * A directive that enables list rendering.
- * @param items - The array to render.
- * @param template - The template or a template binding used obtain a template
- * to render for each item in the array.
- * @param options - Options used to turn on special repeat features.
- * @public
- */
-export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>, TParent = any>(items: Expression<TSource, TArray, TParent> | Binding<TSource, TArray, TParent> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate<any, TSource>> | Binding<TSource, ViewTemplate<any, TSource>> | ViewTemplate<any, TSource>, options?: RepeatOptions): CaptureType<TSource, TParent>;
-
-/**
- * A behavior that renders a template for each item in an array.
- * @public
- */
-export declare class RepeatBehavior<TSource = any> implements ViewBehavior, Subscriber {
-    private directive;
-    private location;
-    private controller;
-    private views;
-    private template;
-    private templateBindingObserver;
-    private items;
-    private itemsObserver;
-    private itemsBindingObserver;
-    private bindView;
-    /**
-     * Creates an instance of RepeatBehavior.
-     * @param location - The location in the DOM to render the repeat.
-     * @param dataBinding - The array to render.
-     * @param isItemsBindingVolatile - Indicates whether the items binding has volatile dependencies.
-     * @param templateBinding - The template to render for each item.
-     * @param isTemplateBindingVolatile - Indicates whether the template binding has volatile dependencies.
-     * @param options - Options used to turn on special repeat features.
-     */
-    constructor(directive: RepeatDirective);
-    /**
-     * Bind this behavior.
-     * @param controller - The view controller that manages the lifecycle of this behavior.
-     */
-    bind(controller: ViewController): void;
-    /**
-     * Unbinds this behavior.
-     */
-    unbind(): void;
-    /**
-     * Handles changes in the array, its items, and the repeat template.
-     * @param source - The source of the change.
-     * @param args - The details about what was changed.
-     */
-    handleChange(source: any, args: Splice[] | ExpressionObserver): void;
-    private observeItems;
-    private updateViews;
-    private refreshAllViews;
-    private unbindAllViews;
-}
-
-/**
- * A directive that configures list rendering.
- * @public
- */
-export declare class RepeatDirective<TSource = any> implements HTMLDirective, ViewBehaviorFactory {
-    readonly dataBinding: Binding<TSource>;
-    readonly templateBinding: Binding<TSource, SyntheticViewTemplate>;
-    readonly options: RepeatOptions;
-    /**
-     * The unique id of the factory.
-     */
-    id: string;
-    /**
-     * The structural id of the DOM node to which the created behavior will apply.
-     */
-    nodeId: string;
-    /**
-     * Creates a placeholder string based on the directive's index within the template.
-     * @param index - The index of the directive within the template.
-     */
-    createHTML(add: AddViewBehaviorFactory): string;
-    /**
-     * Creates an instance of RepeatDirective.
-     * @param dataBinding - The binding that provides the array to render.
-     * @param templateBinding - The template binding used to obtain a template to render for each item in the array.
-     * @param options - Options used to turn on special repeat features.
-     */
-    constructor(dataBinding: Binding<TSource>, templateBinding: Binding<TSource, SyntheticViewTemplate>, options: RepeatOptions);
-    /**
-     * Creates a behavior for the provided target node.
-     * @param target - The node instance to create the behavior for.
-     */
-    createBehavior(): RepeatBehavior<TSource>;
-}
-
-/**
- * Options for configuring repeat behavior.
- * @public
- */
-export declare interface RepeatOptions {
-    /**
-     * Enables index, length, and dependent positioning updates in item templates.
-     */
-    positioning?: boolean;
-    /**
-     * Enables view recycling
-     */
-    recycle?: boolean;
-}
-
-/**
- * Shadow root initialization options.
- * @public
- */
-export declare interface ShadowRootOptions extends ShadowRootInit {
-    /**
-     * A registry that provides the custom elements visible
-     * from within this shadow root.
-     * @beta
-     */
-    registry?: CustomElementRegistry;
-}
-
-/**
- * A directive that observes the `assignedNodes()` of a slot and updates a property
- * whenever they change.
- * @param propertyOrOptions - The options used to configure slotted node observation.
- * @public
- */
-export declare function slotted<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | SlottedDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
-
-/**
- * The runtime behavior for slotted node observation.
- * @public
- */
-export declare class SlottedDirective extends NodeObservationDirective<SlottedDirectiveOptions> {
-    /**
-     * Begins observation of the nodes.
-     * @param target - The target to observe.
-     */
-    observe(target: EventSource): void;
-    /**
-     * Disconnects observation of the nodes.
-     * @param target - The target to unobserve.
-     */
-    disconnect(target: EventSource): void;
-    /**
-     * Retrieves the raw nodes that should be assigned to the source property.
-     * @param target - The target to get the node to.
-     */
-    getNodes(target: HTMLSlotElement): Node[];
-    /* Excluded from this release type: handleEvent */
-}
-
-/**
- * The options used to configure slotted node observation.
- * @public
- */
-export declare interface SlottedDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, AssignedNodesOptions {
-}
-
-/**
- * Describes how the source's lifetime relates to its controller's lifetime.
- * @public
- */
-export declare const SourceLifetime: Readonly<{
-    /**
-     * The source to controller lifetime relationship is unknown.
-     */
-    readonly unknown: undefined;
-    /**
-     * The source and controller lifetimes are coupled to one another.
-     * They can/will be GC'd together.
-     */
-    readonly coupled: 1;
-}>;
-
-/**
- * Describes how the source's lifetime relates to its controller's lifetime.
- * @public
- */
-export declare type SourceLifetime = typeof SourceLifetime[keyof typeof SourceLifetime];
-
-/**
- * A splice map is a representation of how a previous array of items
- * was transformed into a new array of items. Conceptually it is a list of
- * tuples of
- *
- *   (index, removed, addedCount)
- *
- * which are kept in ascending index order of. The tuple represents that at
- * the |index|, |removed| sequence of items were removed, and counting forward
- * from |index|, |addedCount| items were added.
- * @public
- */
-export declare class Splice {
-    index: number;
-    removed: any[];
-    addedCount: number;
-    /**
-     * Indicates that this splice represents a complete array reset.
-     */
-    reset?: boolean;
-    /**
-     * Creates a splice.
-     * @param index - The index that the splice occurs at.
-     * @param removed - The items that were removed.
-     * @param addedCount - The  number of items that were added.
-     */
-    constructor(index: number, removed: any[], addedCount: number);
-    /**
-     * Adjusts the splice index based on the provided array.
-     * @param array - The array to adjust to.
-     * @returns The same splice, mutated based on the reference array.
-     */
-    adjustTo(array: any[]): this;
-}
-
-/**
- * An approach to tracking changes in an array.
- * @public
- */
-export declare interface SpliceStrategy {
-    /**
-     * The level of feature support the splice strategy provides.
-     */
-    readonly support: SpliceStrategySupport;
-    /**
-     * Normalizes the splices before delivery to array change subscribers.
-     * @param previous - The previous version of the array if a reset has taken place.
-     * @param current - The current version of the array.
-     * @param changes - The set of changes tracked against the array.
-     */
-    normalize(previous: unknown[] | undefined, current: unknown[], changes: Splice[] | undefined): readonly Splice[];
-    /**
-     * Performs and tracks a pop operation on an array.
-     * @param array - The array to track the change for.
-     * @param observer - The observer to register the change with.
-     * @param pop - The operation to perform.
-     * @param args - The arguments for the operation.
-     */
-    pop(array: any[], observer: ArrayObserver, pop: typeof Array.prototype.pop, args: any[]): any;
-    /**
-     * Performs and tracks a push operation on an array.
-     * @param array - The array to track the change for.
-     * @param observer - The observer to register the change with.
-     * @param push - The operation to perform.
-     * @param args - The arguments for the operation.
-     */
-    push(array: any[], observer: ArrayObserver, push: typeof Array.prototype.push, args: any[]): any;
-    /**
-     * Performs and tracks a reverse operation on an array.
-     * @param array - The array to track the change for.
-     * @param observer - The observer to register the change with.
-     * @param reverse - The operation to perform.
-     * @param args - The arguments for the operation.
-     */
-    reverse(array: any[], observer: ArrayObserver, reverse: typeof Array.prototype.reverse, args: any[]): any;
-    /**
-     * Performs and tracks a shift operation on an array.
-     * @param array - The array to track the change for.
-     * @param observer - The observer to register the change with.
-     * @param shift - The operation to perform.
-     * @param args - The arguments for the operation.
-     */
-    shift(array: any[], observer: ArrayObserver, shift: typeof Array.prototype.shift, args: any[]): any;
-    /**
-     * Performs and tracks a sort operation on an array.
-     * @param array - The array to track the change for.
-     * @param observer - The observer to register the change with.
-     * @param sort - The operation to perform.
-     * @param args - The arguments for the operation.
-     */
-    sort(array: any[], observer: ArrayObserver, sort: typeof Array.prototype.sort, args: any[]): any[];
-    /**
-     * Performs and tracks a splice operation on an array.
-     * @param array - The array to track the change for.
-     * @param observer - The observer to register the change with.
-     * @param splice - The operation to perform.
-     * @param args - The arguments for the operation.
-     */
-    splice(array: any[], observer: ArrayObserver, splice: typeof Array.prototype.splice, args: any[]): any;
-    /**
-     * Performs and tracks an unshift operation on an array.
-     * @param array - The array to track the change for.
-     * @param observer - The observer to register the change with.
-     * @param unshift - The operation to perform.
-     * @param args - The arguments for the operation.
-     */
-    unshift(array: any[], observer: ArrayObserver, unshift: typeof Array.prototype.unshift, args: any[]): any[];
-}
-
-/**
- * Functionality related to tracking changes in arrays.
- * @public
- */
-export declare const SpliceStrategy: Readonly<{
-    /**
-     * A set of changes that represent a full array reset.
-     */
-    readonly reset: Splice[];
-    /**
-     * Sets the default strategy to use for array observers.
-     * @param strategy - The splice strategy to use.
-     */
-    readonly setDefaultStrategy: (strategy: SpliceStrategy) => void;
-}>;
-
-/**
- * Indicates what level of feature support the splice
- * strategy provides.
- * @public
- */
-export declare const SpliceStrategySupport: Readonly<{
-    /**
-     * Only supports resets.
-     */
-    readonly reset: 1;
-    /**
-     * Supports tracking splices and resets.
-     */
-    readonly splice: 2;
-    /**
-     * Supports tracking splices and resets, while applying some form
-     * of optimization, such as merging, to the splices.
-     */
-    readonly optimized: 3;
-}>;
-
-/**
- * The available values for SpliceStrategySupport.
- * @public
- */
-export declare type SpliceStrategySupport = typeof SpliceStrategySupport[keyof typeof SpliceStrategySupport];
-
-/**
- * A base class used for attribute directives that don't need internal state.
- * @public
- */
-export declare abstract class StatelessAttachedAttributeDirective<TOptions> implements HTMLDirective, ViewBehaviorFactory, ViewBehavior {
-    protected options: TOptions;
-    /**
-     * The unique id of the factory.
-     */
-    id: string;
-    /**
-     * The structural id of the DOM node to which the created behavior will apply.
-     */
-    nodeId: string;
-    /**
-     * Creates an instance of RefDirective.
-     * @param options - The options to use in configuring the directive.
-     */
-    constructor(options: TOptions);
-    /**
-     * Creates a placeholder string based on the directive's index within the template.
-     * @param index - The index of the directive within the template.
-     * @remarks
-     * Creates a custom attribute placeholder.
-     */
-    createHTML(add: AddViewBehaviorFactory): string;
-    /**
-     * Creates a behavior.
-     * @param targets - The targets available for behaviors to be attached to.
-     */
-    createBehavior(): ViewBehavior;
-    /**
-     * Bind this behavior.
-     * @param controller - The view controller that manages the lifecycle of this behavior.
-     */
-    abstract bind(controller: ViewController): void;
-}
-
-/**
- * Implemented to provide specific behavior when adding/removing styles
- * for elements.
- * @public
- */
-export declare 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;
-}
-
-/**
- * A node that can be targeted by styles.
- * @public
- */
-export declare 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 by objects that are interested in change notifications.
- * @public
- */
-export declare interface Subscriber {
-    /**
-     * 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.
-     */
-    handleChange(subject: any, args: any): void;
-}
-
-/**
- * An implementation of {@link Notifier} that efficiently keeps track of
- * subscribers interested in a specific change notification on an
- * observable subject.
+ * Registers the `target` class as a singleton dependency; the class will only be created once. Each
+ * consecutive time the dependency is resolved, the same instance will be returned.
+ *
+ * @param target - The class / constructor function to register as a singleton.
+ *
+ * @example
+ * ```ts
+ * @singleton()
+ * class Foo { }
+ * ```
  *
- * @remarks
- * This set is optimized for the most common scenario of 1 or 2 subscribers.
- * With this in mind, it can store a subscriber in an internal field, allowing it to avoid Array#push operations.
- * If the set ever exceeds two subscribers, it upgrades to an array automatically.
- * @public
- */
-export declare class SubscriberSet implements Notifier {
-    private sub1;
-    private sub2;
-    private spillover;
-    /**
-     * The object that subscribers will receive notifications for.
-     */
-    readonly subject: any;
-    /**
-     * Creates an instance of SubscriberSet for the specified subject.
-     * @param subject - The subject that subscribers will receive notifications from.
-     * @param initialSubscriber - An initial subscriber to changes.
-     */
-    constructor(subject: any, initialSubscriber?: Subscriber);
-    /**
-     * Checks whether the provided subscriber has been added to this set.
-     * @param subscriber - The subscriber to test for inclusion in this set.
-     */
-    has(subscriber: Subscriber): boolean;
-    /**
-     * Subscribes to notification of changes in an object's state.
-     * @param subscriber - The object that is subscribing for change notification.
-     */
-    subscribe(subscriber: Subscriber): void;
-    /**
-     * Unsubscribes from notification of changes in an object's state.
-     * @param subscriber - The object that is unsubscribing from change notification.
-     */
-    unsubscribe(subscriber: Subscriber): void;
-    /**
-     * Notifies all subscribers.
-     * @param args - Data passed along to subscribers during notification.
-     */
-    notify(args: any): void;
-}
-
-/**
- * The options used to configure subtree observation.
- * @public
- */
-export declare interface SubtreeDirectiveOptions<T = any> extends NodeBehaviorOptions<T>, Omit<MutationObserverInit, "subtree" | "childList"> {
-    /**
-     * Indicates that child subtrees should be observed for changes.
-     */
-    subtree: boolean;
-    /**
-     * When subtrees are observed, a query selector is required to indicate
-     * which of potentially many nodes should be assigned to the property.
-     */
-    selector: string;
-}
-
-/**
- * A view representing a range of DOM nodes which can be added/removed ad hoc.
- * @public
- */
-export declare interface SyntheticView<TSource = any, TParent = any> extends View<TSource, TParent> {
-    /**
-     * The first DOM node in the range of nodes that make up the view.
-     */
-    readonly firstChild: Node;
-    /**
-     * The last DOM node in the range of nodes that make up the view.
-     */
-    readonly lastChild: Node;
-    /**
-     * Inserts the view's DOM nodes before the referenced node.
-     * @param node - The node to insert the view's DOM before.
-     */
-    insertBefore(node: Node): void;
-    /**
-     * Removes the view's DOM nodes.
-     * The nodes are not disposed and the view can later be re-inserted.
-     */
-    remove(): void;
-}
-
-/**
- * A template capable of rendering views not specifically connected to custom elements.
- * @public
- */
-export declare interface SyntheticViewTemplate<TSource = any, TParent = any> {
-    /**
-     * Creates a SyntheticView instance based on this template definition.
-     */
-    create(): SyntheticView<TSource, TParent>;
-}
-
-/**
- * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export declare type TemplateValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | HTMLDirective | CaptureType<TSource, TParent>;
+export declare function singleton<T extends Constructable>(target: T & Partial<RegisterSelf<T>>): T & RegisterSelf<T>;
 
-/**
- * Enables working with trusted types.
- * @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;
-};
+declare function singletonDecorator<T extends Constructable>(target: T & Partial<RegisterSelf<T>>): T & RegisterSelf<T>;
 
-/**
- * A policy for use with the standard trustedTypes platform API.
- * @public
- */
-export declare type TrustedTypesPolicy = {
-    /**
-     * Creates trusted HTML.
-     * @param html - The HTML to clear as trustworthy.
-     */
-    createHTML(html: string): string;
+declare type SingletonOptions = {
+    scoped: boolean;
 };
 
-/* Excluded from this release type: TypeDefinition */
-
-/* Excluded from this release type: TypeRegistry */
-
-/**
- * A work queue used to synchronize writes to the DOM.
- * @public
- */
-export declare interface UpdateQueue {
-    /**
-     * Schedules DOM update work in the next batch.
-     * @param callable - The callable function or object to queue.
-     */
-    enqueue(callable: Callable): void;
-    /**
-     * Resolves with the next DOM update.
-     */
-    next(): Promise<void>;
-    /**
-     * Immediately processes all work previously scheduled
-     * through enqueue.
-     * @remarks
-     * This also forces next() promises
-     * to resolve.
-     */
-    process(): void;
-    /**
-     * Sets the update mode used by enqueue.
-     * @param isAsync - Indicates whether DOM updates should be asynchronous.
-     * @remarks
-     * By default, the update mode is asynchronous, since that provides the best
-     * performance in the browser. Passing false to setMode will instead cause
-     * the queue to be immediately processed for each call to enqueue. However,
-     * ordering will still be preserved so that nested tasks do not run until
-     * after parent tasks complete.
-     */
-    setMode(isAsync: boolean): void;
-}
-
-/**
- * The default UpdateQueue.
- * @public
- */
-export declare const Updates: UpdateQueue;
-
-/**
- * Represents objects that can convert values to and from
- * view or model representations.
- * @public
- */
-export declare interface ValueConverter {
-    /**
-     * Converts a value from its representation in the model, to a representation for the view.
-     * @param value - The value to convert to a view representation.
-     */
-    toView(value: any): any;
-    /**
-     * Converts a value from its representation in the view, to a representation for the model.
-     * @param value - The value to convert to a model representation.
-     */
-    fromView(value: any): any;
-}
-
-/**
- * Represents a collection of DOM nodes which can be bound to a data source.
- * @public
- */
-export declare interface View<TSource = any, TParent = any> extends Disposable {
-    /**
-     * The execution context the view is running within.
-     */
-    readonly context: ExecutionContext<TParent>;
-    /**
-     * The data that the view is bound to.
-     */
-    readonly source: TSource | null;
-    /**
-     * Binds a view's behaviors to its binding source.
-     * @param source - The binding source for the view's binding behaviors.
-     */
-    bind(source: TSource, context?: ExecutionContext<TParent>): void;
-    /**
-     * Unbinds a view's behaviors from its binding source and context.
-     */
-    unbind(): void;
-}
-
-/**
- * Represents an object that can contribute behavior to a view.
- * @public
- */
-export declare interface ViewBehavior<TSource = any, TParent = any> {
-    /**
-     * Bind this behavior.
-     * @param controller - The view controller that manages the lifecycle of this behavior.
-     */
-    bind(controller: ViewController<TSource, TParent>): void;
-}
-
-/**
- * A factory that can create a {@link ViewBehavior} associated with a particular
- * location within a DOM fragment.
- * @public
- */
-export declare interface ViewBehaviorFactory {
-    /**
-     * The unique id of the factory.
-     */
-    id: string;
-    /**
-     * The structural id of the DOM node to which the created behavior will apply.
-     */
-    nodeId: string;
-    /**
-     * Creates a behavior.
-     */
-    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.
+ * Transforms an object after it is created but before it is returned
+ * to the requestor.
  * @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>;
-}>;
+declare type Transformer_2<K> = (instance: Resolved<K>) => Resolved<K>;
+export { Transformer_2 as Transformer }
 
 /**
- * The target nodes available to a behavior.
+ * Registers the decorated class as a transient dependency; each time the dependency is resolved
+ * a new instance will be created.
+ *
+ * @example
+ * ```ts
+ * @transient()
+ * class Foo { }
+ * ```
+ *
  * @public
  */
-export declare type ViewBehaviorTargets = {
-    [id: string]: Node;
-};
+export declare function transient<T extends Constructable>(): typeof transientDecorator;
 
 /**
- * Controls the lifecycle of a view and provides relevant context.
+ * Registers the `target` class as a transient dependency; each time the dependency is resolved
+ * a new instance will be created.
+ *
+ * @param target - The class / constructor function to register as transient.
+ *
+ * @example
+ * ```ts
+ * @transient()
+ * class Foo { }
+ * ```
+ *
  * @public
  */
-export declare interface ViewController<TSource = any, TParent = any> extends ExpressionController<TSource, TParent> {
-    /**
-     * The parts of the view that are targeted by view behaviors.
-     */
-    readonly targets: ViewBehaviorTargets;
-}
+export declare function transient<T extends Constructable>(target: T & Partial<RegisterSelf<T>>): T & RegisterSelf<T>;
 
-/**
- * A template capable of creating HTMLView instances or rendering directly to DOM.
- * @public
- */
-export declare class ViewTemplate<TSource = any, TParent = any> implements ElementViewTemplate<TSource, TParent>, SyntheticViewTemplate<TSource, TParent> {
-    private result;
-    /**
-     * The html representing what this template will
-     * instantiate, including placeholders for directives.
-     */
-    readonly html: string | HTMLTemplateElement;
-    /**
-     * The directives that will be connected to placeholders in the html.
-     */
-    readonly factories: Record<string, ViewBehaviorFactory>;
-    /**
-     * Creates an instance of ViewTemplate.
-     * @param html - The html representing what this template will instantiate, including placeholders for directives.
-     * @param factories - The directives that will be connected to placeholders in the html.
-     */
-    constructor(html: string | HTMLTemplateElement, factories: Record<string, ViewBehaviorFactory>);
-    /**
-     * 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>;
-    /**
-     * Creates an HTMLView from this template, binds it to the source, and then appends it to the host.
-     * @param source - The data source to bind the template to.
-     * @param host - The Element where the template will be rendered.
-     * @param hostBindingTarget - An HTML element to target the host bindings at if different from the
-     * host that the template is being attached to.
-     */
-    render(source: TSource, host: Node, hostBindingTarget?: Element): HTMLView<TSource, TParent>;
-}
+declare function transientDecorator<T extends Constructable>(target: T & Partial<RegisterSelf<T>>): T & RegisterSelf<T>;
 
 /**
- * Decorator: Marks a property getter as having volatile observable dependencies.
- * @param target - The target that the property is defined on.
- * @param name - The property name.
- * @param name - The existing descriptor.
+ * An unknown context type.
  * @public
  */
-export declare function volatile(target: {}, name: string | Accessor, descriptor: PropertyDescriptor): PropertyDescriptor;
+declare type UnknownContext = Context<unknown>;
 
-/**
- * A directive that enables basic conditional rendering in a template.
- * @param condition - The condition to test for rendering.
- * @param templateOrTemplateBinding - The template or a binding that gets
- * the template to render when the condition is true.
- * @public
- */
-export declare function when<TSource = any, TReturn = any, TParent = any>(condition: Expression<TSource, TReturn, TParent> | boolean, templateOrTemplateBinding: SyntheticViewTemplate<TSource, TParent> | Expression<TSource, SyntheticViewTemplate<TSource, TParent>, TParent>): CaptureType<TSource, TParent>;
+/** @internal */
+export declare function validateKey(key: any): void;
 
 export { }