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

package/dist/dts/binding/binding.d.ts

@@ -0,0 +1,49 @@
+import type { DOMAspect, DOMPolicy } from "../dom.js";
+import type { Subscriber } from "../observation/notifier.js";
+import type { Expression, ExpressionObserver } from "../observation/observable.js";
+/**
+ * The directive from which a binding originates.
+ *
+ * @public
+ */
+export interface BindingDirective {
+    /**
+     * The binding.
+     */
+    readonly dataBinding: Binding;
+    /**
+     * The evaluated target aspect.
+     */
+    readonly targetAspect?: string;
+    /**
+     * The type of aspect to target.
+     */
+    readonly aspectType?: DOMAspect;
+}
+/**
+ * Captures a binding expression along with related information and capabilities.
+ *
+ * @public
+ */
+export declare abstract class Binding<TSource = any, TReturn = any, TParent = any> {
+    evaluate: Expression<TSource, TReturn, TParent>;
+    policy?: DOMPolicy | undefined;
+    isVolatile: boolean;
+    /**
+     * Options associated with the binding.
+     */
+    options?: any;
+    /**
+     * Creates a binding.
+     * @param evaluate - Evaluates the binding.
+     * @param policy - The security policy to associate with this binding.
+     * @param isVolatile - Indicates whether the binding is volatile.
+     */
+    constructor(evaluate: Expression<TSource, TReturn, TParent>, policy?: DOMPolicy | undefined, isVolatile?: boolean);
+    /**
+     * Creates an observer capable of notifying a subscriber when the output of a binding changes.
+     * @param subscriber - The subscriber to changes in the binding.
+     * @param directive - The Binding directive to create the observer for.
+     */
+    abstract createObserver(subscriber: Subscriber, directive: BindingDirective): ExpressionObserver<TSource, TReturn, TParent>;
+}

package/dist/dts/binding/normalize.d.ts

@@ -0,0 +1,9 @@
+import type { Expression } from "../observation/observable.js";
+import { Binding } from "./binding.js";
+/**
+ * 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>;

package/dist/dts/binding/one-time.d.ts

@@ -0,0 +1,11 @@
+import type { DOMPolicy } from "../dom.js";
+import type { Expression } from "../observation/observable.js";
+import { Binding } from "./binding.js";
+/**
+ * Creates a one time binding
+ * @param expression - The binding to refresh when signaled.
+ * @param policy - The security policy to associate with th binding.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function oneTime<T = any>(expression: Expression<T>, policy?: DOMPolicy): Binding<T>;

package/dist/dts/binding/one-way.d.ts

@@ -0,0 +1,20 @@
+import type { DOMPolicy } from "../dom.js";
+import { Expression } from "../observation/observable.js";
+import { Binding } from "./binding.js";
+/**
+ * Creates an standard binding.
+ * @param expression - The binding to refresh when changed.
+ * @param policy - The security policy to associate with th binding.
+ * @param isVolatile - Indicates whether the binding is volatile or not.
+ * @returns A binding configuration.
+ * @public
+ */
+export declare function oneWay<T = any>(expression: Expression<T>, policy?: DOMPolicy, isVolatile?: boolean): Binding<T>;
+/**
+ * Creates an event listener binding.
+ * @param expression - 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>(expression: Expression<T>, options?: AddEventListenerOptions): Binding<T>;

package/dist/dts/{templating/binding-signal.d.ts → binding/signal.d.ts}

@@ -1,13 +1,27 @@
 import type { Expression } from "../observation/observable.js";
 import type { Subscriber } from "../observation/notifier.js";
-import { Binding } from "./html-directive.js";
+import type { DOMPolicy } from "../dom.js";
+import { Binding } from "./binding.js";
+/**
+ * The gateway to signal APIs.
+ * @public
+ */
 export declare const Signal: Readonly<{
+    /**
+     * Subscribes to a signal.
+     * @param signal The signal to subscribe to.
+     * @param subscriber The subscriber.
+     */
     subscribe(signal: string, subscriber: Subscriber): void;
+    /**
+     * Unsubscribes from the signal.
+     * @param signal The signal to unsubscribe from.
+     * @param subscriber The subscriber.
+     */
     unsubscribe(signal: string, subscriber: Subscriber): void;
     /**
-     * Sends the specified signal to signaled bindings.
+     * Sends the specified signal to subscribers.
      * @param signal - The signal to send.
-     * @public
      */
     send(signal: string): void;
 }>;
@@ -15,7 +29,8 @@ export declare const Signal: Readonly<{
  * Creates a signal binding configuration with the supplied options.
  * @param expression - The binding to refresh when signaled.
  * @param options - The signal name or a binding to use to retrieve the signal name.
+ * @param policy - The security policy to associate with th binding.
  * @returns A binding configuration.
  * @public
  */
-export declare function signal<T = any>(expression: Expression<T>, options: string | Expression<T>): Binding<T>;
+export declare function signal<T = any>(expression: Expression<T>, options: string | Expression<T>, policy?: DOMPolicy): Binding<T>;

package/dist/dts/{templating/binding-two-way.d.ts → binding/two-way.d.ts}

@@ -1,6 +1,6 @@
+import type { DOMPolicy } from "../dom.js";
 import { Expression } from "../observation/observable.js";
-import type { HTMLBindingDirective } from "./binding.js";
-import { Binding } from "./html-directive.js";
+import { Binding, BindingDirective } from "./binding.js";
 /**
  * The twoWay binding options.
  * @public
@@ -16,11 +16,14 @@ export declare type TwoWayBindingOptions = {
 export interface TwoWaySettings {
     /**
      * Determines which event to listen to, to detect changes in the view.
-     * @param directive - The directive to determine the change event for.
+     * @param bindingSource - The directive to determine the change event for.
      * @param target - The target element to determine the change event for.
      */
-    determineChangeEvent(directive: HTMLBindingDirective, target: HTMLElement): string;
+    determineChangeEvent(bindingSource: BindingDirective, target: HTMLElement): string;
 }
+/**
+ * Enables configuring two-way binding settings.
+ */
 export declare const TwoWaySettings: Readonly<{
     /**
      * Configures two-way binding.
@@ -32,8 +35,9 @@ export declare const TwoWaySettings: Readonly<{
  * Creates a default binding.
  * @param expression - The binding to refresh when changed.
  * @param optionsOrChangeEvent - The binding options or the name of the change event to use.
+ * @param policy - The security policy to associate with the binding.
  * @param isBindingVolatile - Indicates whether the binding is volatile or not.
  * @returns A binding.
  * @public
  */
-export declare function twoWay<T = any>(expression: Expression<T>, optionsOrChangeEvent?: TwoWayBindingOptions | string, isBindingVolatile?: boolean): Binding<T>;
+export declare function twoWay<T = any>(expression: Expression<T>, optionsOrChangeEvent?: TwoWayBindingOptions | string, policy?: DOMPolicy, isBindingVolatile?: boolean): Binding<T>;

package/dist/dts/components/attributes.d.ts

@@ -62,6 +62,12 @@ export declare type DecoratorAttributeConfiguration = Omit<AttributeConfiguratio
  * @public
  */
 export declare const booleanConverter: ValueConverter;
+/**
+ * A {@link ValueConverter} that converts to and from `boolean` values. `null`, `undefined`, `""`,
+ * and `void` values are converted to `null`.
+ * @public
+ */
+export declare const nullableBooleanConverter: ValueConverter;
 /**
  * A {@link ValueConverter} that converts to and from `number` values.
  * @remarks

package/dist/dts/components/element-controller.d.ts

@@ -1,20 +1,46 @@
-import type { HostBehavior, HostController } from "../styles/host.js";
 import { PropertyChangeNotifier } from "../observation/notifier.js";
+import { ExecutionContext, ExpressionController, SourceLifetime } from "../observation/observable.js";
+import { ElementStyles } from "../styles/element-styles.js";
+import type { HostBehavior, HostController } from "../styles/host.js";
+import type { StyleStrategy, StyleTarget } from "../styles/style-strategy.js";
 import type { ElementViewTemplate } from "../templating/template.js";
 import type { ElementView } from "../templating/view.js";
-import type { ElementStyles } from "../styles/element-styles.js";
 import { FASTElementDefinition } from "./fast-definitions.js";
+/**
+ * A type that instantiates an ElementController
+ * @public
+ */
+export interface ElementControllerStrategy {
+    new (element: HTMLElement, definition: FASTElementDefinition): ElementController;
+}
+declare const enum Stages {
+    connecting = 0,
+    connected = 1,
+    disconnecting = 2,
+    disconnected = 3
+}
 /**
  * Controls the lifecycle and rendering of a `FASTElement`.
  * @public
  */
 export declare class ElementController<TElement extends HTMLElement = HTMLElement> extends PropertyChangeNotifier implements HostController<TElement> {
     private boundObservables;
-    private needsInitialization;
+    protected needsInitialization: boolean;
     private hasExistingShadowRoot;
     private _template;
-    private _isConnected;
-    private behaviors;
+    protected stage: Stages;
+    /**
+     * A guard against connecting behaviors multiple times
+     * during connect in scenarios where a behavior adds
+     * another behavior during it's connectedCallback
+     */
+    private guardBehaviorConnection;
+    protected behaviors: Map<HostBehavior<TElement>, number> | null;
+    /**
+     * Tracks whether behaviors are connected so that
+     * behaviors cant be connected multiple times
+     */
+    private behaviorsConnected;
     private _mainStyles;
     /**
      * This allows Observable.getNotifier(...) to return the Controller
@@ -45,7 +71,18 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * connected to the document.
      */
     get isConnected(): boolean;
-    private setIsConnected;
+    /**
+     * The context the expression is evaluated against.
+     */
+    get context(): ExecutionContext;
+    /**
+     * Indicates whether the controller is bound.
+     */
+    get isBound(): boolean;
+    /**
+     * Indicates how the source's lifetime relates to the controller's lifetime.
+     */
+    get sourceLifetime(): SourceLifetime | undefined;
     /**
      * Gets/sets the template used to render the component.
      * @remarks
@@ -67,6 +104,13 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * @internal
      */
     constructor(element: TElement, definition: FASTElementDefinition);
+    /**
+     * Registers an unbind handler with the controller.
+     * @param behavior - An object to call when the controller unbinds.
+     */
+    onUnbind(behavior: {
+        unbind(controller: ExpressionController<TElement>): any;
+    }): void;
     /**
      * Adds the behavior to the component.
      * @param behavior - The behavior to add.
@@ -92,6 +136,9 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * Runs connected lifecycle behavior on the associated element.
      */
     connect(): void;
+    protected bindObservables(): void;
+    protected connectBehaviors(): void;
+    protected disconnectBehaviors(): void;
     /**
      * Runs disconnected lifecycle behavior on the associated element.
      */
@@ -112,8 +159,7 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * Only emits events if connected.
      */
     emit(type: string, detail?: any, options?: Omit<CustomEventInit, "detail">): void | boolean;
-    private finishInitialization;
-    private renderTemplate;
+    protected renderTemplate(template: ElementViewTemplate | null | undefined): void;
     /**
      * Locates or creates a controller for the specified element.
      * @param element - The element to return the controller for.
@@ -123,4 +169,54 @@ export declare class ElementController<TElement extends HTMLElement = HTMLElemen
      * decorator or a call to `FASTElement.define`.
      */
     static forCustomElement(element: HTMLElement): ElementController;
+    /**
+     * Sets the strategy that ElementController.forCustomElement uses to construct
+     * ElementController instances for an element.
+     * @param strategy - The strategy to use.
+     */
+    static setStrategy(strategy: ElementControllerStrategy): void;
+}
+/**
+ * https://wicg.github.io/construct-stylesheets/
+ * https://developers.google.com/web/updates/2019/02/constructable-stylesheets
+ *
+ * @internal
+ */
+export declare class AdoptedStyleSheetsStrategy implements StyleStrategy {
+    private static styleSheetCache;
+    /** @internal */
+    readonly sheets: CSSStyleSheet[];
+    constructor(styles: (string | CSSStyleSheet)[]);
+    addStylesTo(target: StyleTarget): void;
+    removeStylesFrom(target: StyleTarget): void;
+}
+/**
+ * @internal
+ */
+export declare class StyleElementStrategy implements StyleStrategy {
+    private readonly styles;
+    private readonly styleClass;
+    constructor(styles: string[]);
+    addStylesTo(target: StyleTarget): void;
+    removeStylesFrom(target: StyleTarget): void;
+}
+/**
+ * An ElementController capable of hydrating FAST elements from
+ * Declarative Shadow DOM.
+ *
+ * @beta
+ */
+export declare class HydratableElementController<TElement extends HTMLElement = HTMLElement> extends ElementController<TElement> {
+    /**
+     * Controls whether the controller will hydrate during the connect() method.
+     * Initialized during the first connect() call to true when the `needs-hydration`
+     * attribute is present on the element.
+     */
+    protected needsHydration?: boolean;
+    private static hydrationObserver;
+    private static hydrationObserverHandler;
+    connect(): void;
+    disconnect(): void;
+    static install(): void;
 }
+export {};

package/dist/dts/components/element-hydration.d.ts

@@ -0,0 +1,2 @@
+export { HydratableElementController } from "./element-controller.js";
+export * from "./hydration.js";

package/dist/dts/components/fast-definitions.d.ts

@@ -118,6 +118,12 @@ export declare class FASTElementDefinition<TType extends Constructable<HTMLEleme
      * that describes the element to define.
      */
     static compose<TType extends Constructable<HTMLElement> = Constructable<HTMLElement>>(type: TType, nameOrDef?: string | PartialFASTElementDefinition): FASTElementDefinition<TType>;
+    /**
+     * Registers a FASTElement base type.
+     * @param type - The type to register as a base type.
+     * @internal
+     */
+    static registerBaseType(type: Function): void;
     /**
      * Gets the element definition associated with the specified type.
      * @param type - The custom element type to retrieve the definition for.

package/dist/dts/components/hydration.d.ts

@@ -0,0 +1,56 @@
+import type { ContentTemplate, HydratableContentTemplate } from "../templating/html-binding-directive.js";
+import type { ViewController } from "../templating/html-directive.js";
+import type { ElementViewTemplate, HydratableElementViewTemplate, HydratableSyntheticViewTemplate, SyntheticViewTemplate } from "../templating/template.js";
+import type { HydrationView } from "../templating/view.js";
+/**
+ * Markup utilities to aid in template hydration.
+ * @internal
+ */
+export declare const HydrationMarkup: Readonly<{
+    attributeMarkerName: "data-fe-b";
+    attributeBindingSeparator: " ";
+    contentBindingStartMarker(index: number, uniqueId: string): string;
+    contentBindingEndMarker(index: number, uniqueId: string): string;
+    repeatStartMarker(index: number): string;
+    repeatEndMarker(index: number): string;
+    isContentBindingStartMarker(content: string): boolean;
+    isContentBindingEndMarker(content: string): boolean;
+    isRepeatViewStartMarker(content: string): boolean;
+    isRepeatViewEndMarker(content: string): boolean;
+    isElementBoundaryStartMarker(node: Node): boolean;
+    isElementBoundaryEndMarker(node: Node): boolean;
+    /**
+     * Returns the indexes of the ViewBehaviorFactories affecting
+     * attributes for the element, or null if no factories were found.
+     */
+    parseAttributeBinding(node: Element): null | number[];
+    /**
+     * Parses the ViewBehaviorFactory index from string data. Returns
+     * the binding index or null if the index cannot be retrieved.
+     */
+    parseContentBindingStartMarker(content: string): null | [index: number, id: string];
+    parseContentBindingEndMarker(content: string): null | [index: number, id: string];
+    /**
+     * Parses the index of a repeat directive from a content string.
+     */
+    parseRepeatStartMarker(content: string): null | number;
+    parseRepeatEndMarker(content: string): null | number;
+    /**
+     * Parses element Id from element boundary markers
+     */
+    parseElementBoundaryStartMarker(content: string): null | string;
+    parseElementBoundaryEndMarker(content: string): null | string;
+}>;
+/**
+ * @internal
+ */
+export declare const Hydratable: unique symbol;
+/**
+ * Tests if a template or ViewController is hydratable.
+ *
+ * @beta
+ */
+export declare function isHydratable(view: ViewController): view is HydrationView;
+export declare function isHydratable<TSource = any, TParent = any>(template: SyntheticViewTemplate<TSource, TParent>): template is HydratableSyntheticViewTemplate<TSource, TParent>;
+export declare function isHydratable<TSource = any, TParent = any>(template: ElementViewTemplate<TSource, TParent>): template is HydratableElementViewTemplate<TSource, TParent>;
+export declare function isHydratable(template: ContentTemplate): template is HydratableContentTemplate;

package/dist/dts/components/install-hydration.d.ts

@@ -0,0 +1 @@
+import "../templating/install-hydratable-view-templates.js";

package/dist/dts/context.d.ts

@@ -1,4 +1,4 @@
-import { Constructable } from "./interfaces.js";
+import { Constructable, ParameterDecorator } from "./interfaces.js";
 /**
  * A Context object defines an optional initial value for a Context, as well as a name identifier for debugging purposes.
  * @public
@@ -11,44 +11,52 @@ export declare type Context<T> = {
  * 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.
- * @beta
+ * @public
  */
 export declare type ContextDecorator<T = any> = Readonly<Context<T>> & PropertyDecorator & ParameterDecorator;
 /**
  * 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.
- * @beta
+ * @public
  */
 export 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): any;
+    handle(target: EventTarget, callback: (event: ContextEvent<FASTContext<T>>) => void): void;
 };
 /**
  * A strategy that controls how all Context.request API calls are handled.
  * @remarks
- * By default this is handled via Context.dispatch, which dispatched a ContextEvent.
- * @beta
+ * By default this is handled via Context.dispatch, which dispatches a ContextEvent.
+ * @public
  */
 export declare type FASTContextRequestStrategy = <T extends UnknownContext>(target: EventTarget, context: T, callback: ContextCallback<ContextType<T>>, multiple: any) => void;
 declare const contextEventType = "context-request";
 /**
- * Enables using the {@link https://github.com/webcomponents-cg/community-protocols/blob/main/proposals/context.md | W3C Community Context protocol.}
- * @beta
+ * Enables using:
+ * {@link https://github.com/webcomponents-cg/community-protocols/blob/main/proposals/context.md | W3C Community Context protocol.}
+ * @public
  */
 export declare const Context: Readonly<{
     /**
      * The event type used for W3C Context Protocol requests.
      */
     eventType: "context-request";
+    /**
+     * 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.
+     */
+    for<T = unknown>(name: string): FASTContext<T>;
     /**
      * 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.
      */
-    create<T = unknown>(name: string, initialValue?: T | undefined): FASTContext<T>;
+    create<T_1 = unknown>(name: string, initialValue?: T_1 | undefined): FASTContext<T_1>;
     /**
      * Sets the strategy used by all FAST-specific context requests made through the
      * Context.request, Context.get, Context.defineProperty, and ContextDecorator APIs.
@@ -65,7 +73,7 @@ export declare const Context: Readonly<{
      * Uses the default request strategy to locate the context. If no context is found
      * then the initial value of the context is returned.
      */
-    get<T_1 extends UnknownContext>(target: EventTarget, context: T_1): ContextType<T_1>;
+    get<T_2 extends UnknownContext>(target: EventTarget, context: T_2): ContextType<T_2>;
     /**
      * Requests the context value for the target node.
      * @param target - The target to request the context for.
@@ -76,7 +84,7 @@ export declare const Context: Readonly<{
      * @remarks
      * Uses the default request strategy to locate the context.
      */
-    request<T_2 extends UnknownContext>(target: EventTarget, context: T_2, callback: ContextCallback<ContextType<T_2>>, multiple?: boolean): void;
+    request<T_3 extends UnknownContext>(target: EventTarget, context: T_3, callback: ContextCallback<ContextType<T_3>>, multiple?: boolean): void;
     /**
      *
      * @param target - The target to dispatch the context event on.
@@ -88,8 +96,14 @@ export declare const Context: Readonly<{
      * This API does NOT use the default request strategy. It always dispatches
      * an event through the DOM.
      */
-    dispatch<T_3 extends UnknownContext>(target: EventTarget, context: T_3, callback: ContextCallback<ContextType<T_3>>, multiple?: boolean): void;
-    provide<T_4 extends UnknownContext>(target: EventTarget, context: T_4, value: ContextType<T_4>): void;
+    dispatch<T_4 extends UnknownContext>(target: EventTarget, context: T_4, callback: ContextCallback<ContextType<T_4>>, multiple?: boolean): void;
+    /**
+     * 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.
+     */
+    provide<T_5 extends UnknownContext>(target: EventTarget, context: T_5, value: ContextType<T_5>): void;
     /**
      *
      * @param target - The target on which to handle context requests.
@@ -99,7 +113,7 @@ export declare const Context: Readonly<{
      * If a context is not provided then the callback will be invoked for all context
      * requests that are received on the target.
      */
-    handle<T_5 extends UnknownContext>(target: EventTarget, callback: (event: ContextEvent<T_5>) => void, context?: T_5 | undefined): void;
+    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.
@@ -110,7 +124,7 @@ export declare const Context: Readonly<{
      * Uses the default request strategy to locate the context and will return the
      * initialValue if the context isn't handled.
      */
-    defineProperty<T_6 extends UnknownContext>(target: Constructable<EventTarget> | EventTarget, propertyName: string, context: T_6): void;
+    defineProperty<T_7 extends UnknownContext>(target: Constructable<EventTarget> | EventTarget, propertyName: string, context: T_7): void;
 }>;
 /**
  * An unknown context type.

package/dist/dts/di/di.d.ts

@@ -477,11 +477,6 @@ export declare const DI: Readonly<{
      * in addition to its standard use in an inject array or through direct container APIs.
      */
     createContext: typeof createContext;
-    /**
-     * @deprecated
-     * Use DI.createContext instead.
-     */
-    createInterface: typeof createContext;
     /**
      * A decorator that specifies what to inject into its target.
      * @param dependencies - The dependencies to inject.

package/dist/dts/dom-policy.d.ts

@@ -0,0 +1,83 @@
+import { DOMAspect, DOMPolicy, DOMSink } from "./dom.js";
+import { TrustedTypesPolicy } from "./interfaces.js";
+/**
+ * A specific DOM sink guard for a node aspect.
+ * @public
+ */
+export declare type DOMSinkGuards = Record<string, (tagName: string | null, aspect: DOMAspect, aspectName: string, sink: DOMSink) => DOMSink>;
+/**
+ * Aspect-specific guards for a DOM Policy.
+ * @public
+ */
+export declare type DOMAspectGuards = {
+    /**
+     * Guards for attributes.
+     */
+    [DOMAspect.attribute]?: DOMSinkGuards;
+    /**
+     * Guards for boolean attributes.
+     */
+    [DOMAspect.booleanAttribute]?: DOMSinkGuards;
+    /**
+     * Guards for properties.
+     */
+    [DOMAspect.property]?: DOMSinkGuards;
+    /**
+     * Guards for content.
+     */
+    [DOMAspect.content]?: DOMSinkGuards;
+    /**
+     * Guards for token list manipulation.
+     */
+    [DOMAspect.tokenList]?: DOMSinkGuards;
+    /**
+     * Guards for events.
+     */
+    [DOMAspect.event]?: DOMSinkGuards;
+};
+/**
+ * Element-specific guards for a DOM Policy.
+ * @public
+ */
+export declare type DOMElementGuards = Record<string, DOMAspectGuards>;
+/**
+ * Guard configuration for a DOM Policy.
+ * @public
+ */
+export declare type DOMGuards = {
+    /**
+     * Guards for specific elements.
+     */
+    elements: DOMElementGuards;
+    /**
+     * General aspect guards independent of the element type.
+     */
+    aspects: DOMAspectGuards;
+};
+/**
+ * Options for creating a DOM Policy.
+ * @public
+ */
+export declare type DOMPolicyOptions = {
+    /**
+     * The trusted type to use for HTML creation.
+     */
+    trustedType?: TrustedTypesPolicy;
+    /**
+     * The DOM guards used to override or extend the defaults.
+     */
+    guards?: Partial<DOMGuards>;
+};
+/**
+ * A helper for creating DOM policies.
+ * @public
+ */
+declare const DOMPolicy: Readonly<{
+    /**
+     * Creates a new DOM Policy object.
+     * @param options The options to use in creating the policy.
+     * @returns The newly created DOMPolicy.
+     */
+    create(options?: DOMPolicyOptions): Readonly<DOMPolicy>;
+}>;
+export { DOMPolicy };