@odx/angular 5.7.4 → 6.0.1

package/cdk/connected-overlay/lib/connected-overlay.service.d.ts

@@ -2,8 +2,52 @@ import { VirtualElement } from '@floating-ui/dom';
 import { DynamicViewRenderingOptions } from '@odx/angular/cdk/dynamic-view';
 import { ConnectedOverlayOptions, ConnectedOverlayRef } from './models';
 import * as i0 from "@angular/core";
+/**
+ * Service for creating and managing connected overlays. These overlays are UI elements such as popovers, tooltips,
+ * or dropdown menus that are positioned relative to a reference element in the DOM. This service leverages the `DynamicViewService`
+ * for dynamic component rendering and provides a streamlined API for creating overlays with custom positioning and options.
+ *
+ * Use the `ConnectedOverlayService` to dynamically create an overlay next to a specific element in your Angular application.
+ * This example demonstrates creating a connected overlay next to a button element when the button is clicked.
+ *
+ * @example
+ * ```ts
+ * import { Component, ElementRef, ViewChild } from '@angular/core';
+ * import { ConnectedOverlayService, ConnectedOverlayOptions } from '@odx/angular/cdk/connected-overlay';
+ *
+ * @Component({
+ *   selector: 'app-example',
+ *   template: `<button #triggerElement>Click me</button>`,
+ * })
+ * class AppComponent {
+ *   @ViewChild('triggerElement') triggerElementRef!: ElementRef;
+ *
+ *   constructor(private connectedOverlayService: ConnectedOverlayService) {}
+ *
+ *   showOverlay(): void {
+ *     const options: Partial<ConnectedOverlayOptions> = {
+ *       position: 'bottom-start',
+ *       showArrow: true,
+ *       content: 'Hello, world!',
+ *     };
+ *
+ *     this.connectedOverlayService.createOverlay(this.triggerElementRef.nativeElement, options);
+ *   }
+ * }
+ * ```
+ *
+ * This service simplifies the process of creating dynamic, positionally aware overlays that enhance the interactivity
+ * and visual appeal of Angular applications.
+ */
 export declare class ConnectedOverlayService {
     private readonly dynamicViewService;
+    /**
+     * Creates a connected overlay.
+     * @param referenceElement - The reference element to which the overlay will be connected.
+     * @param options - Optional configuration for the connected overlay.
+     * @param renderingOptions - Optional rendering options for the connected overlay.
+     * @returns {ConnectedOverlayRef} The created Connected Overlay reference instance.
+     */
     createOverlay(referenceElement: VirtualElement, options?: Partial<ConnectedOverlayOptions>, renderingOptions?: Partial<DynamicViewRenderingOptions>): ConnectedOverlayRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<ConnectedOverlayService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ConnectedOverlayService>;

package/cdk/connected-overlay/lib/helpers/compute-overlay-position.d.ts

@@ -1,3 +1,13 @@
 import { ComputePositionReturn, VirtualElement } from '@floating-ui/dom';
 import { ConnectedOverlayOptions } from '../models';
+/**
+ * Computes the position of an overlay element relative to a reference element.
+ *
+ * @param referenceElement - The reference element to position the overlay relative to.
+ * @param overlayElement - The overlay element to be positioned.
+ * @param contentElement - The content element within the overlay.
+ * @param arrowElement - The arrow element within the overlay.
+ * @param options - The options for positioning the overlay.
+ * @returns A promise that resolves to the computed position of the overlay.
+ */
 export declare function computeOverlayPosition(referenceElement: VirtualElement, overlayElement: HTMLElement, contentElement: HTMLElement, arrowElement: HTMLElement, options: ConnectedOverlayOptions): Promise<ComputePositionReturn>;

package/cdk/connected-overlay/lib/models/connected-overlay-ref.d.ts

@@ -2,11 +2,60 @@ import { DynamicViewRef } from '@odx/angular/cdk/dynamic-view';
 import { Observable } from 'rxjs';
 import { ConnectedOverlayComponent } from '../connected-overlay.component';
 import { ConnectedOverlayOptions } from './connected-overlay-options';
+/**
+ * A reference to a connected overlay created by the `ConnectedOverlayService`. This class provides methods to interact
+ * with the overlay, such as updating its options or closing it. It encapsulates the `DynamicViewRef` for the overlay's instance,
+ * allowing for direct manipulation of the overlay's state and behavior.
+ *
+ * This example demonstrates how to use a `ConnectedOverlayRef` to update and close a connected overlay in response
+ * to user interactions.
+ *
+ * @example
+ * ```ts
+ * class MyComponent {
+ *   private overlayRef?: ConnectedOverlayRef;
+ *
+ *   constructor(private overlayService: ConnectedOverlayService) {}
+ *
+ *   openOverlay() {
+ *     this.overlayRef = this.overlayService.createOverlay(this.someElementRef.nativeElement, { position: 'bottom' });
+ *   }
+ *
+ *   updateOverlayPosition() {
+ *     if (this.overlayRef) {
+ *       this.overlayRef.update({ position: 'top' });
+ *     }
+ *   }
+ *
+ *   closeOverlay() {
+ *     this.overlayRef?.close();
+ *   }
+ * }
+ * ```
+ *
+ * In this example, `MyComponent` uses the `ConnectedOverlayService` to create an overlay. It stores a reference to
+ * the created overlay in `overlayRef`, allowing it to update the overlay's position or close it when necessary.
+ */
 export declare class ConnectedOverlayRef {
     private readonly dynamicViewRef;
     readonly element: Element;
+    /**
+     * An Observable that emits when the overlay is closed.
+     *
+     * @emits {void} - Emits when the overlay is closed.
+     */
     readonly onClose$: Observable<void>;
     constructor(dynamicViewRef: DynamicViewRef<typeof ConnectedOverlayComponent>);
+    /**
+     * Updates the connected overlay with new options.
+     *
+     * @param options - The new options to be applied to the connected overlay.
+     */
     update(options: Partial<ConnectedOverlayOptions>): void;
+    /**
+     * Closes the connected overlay.
+     *
+     * @returns {void}
+     */
     close(): void;
 }

package/cdk/custom-form-control/lib/custom-form-control.d.ts

@@ -2,6 +2,17 @@ import { ControlValueAccessor, NgControl, ValidatorFn } from '@angular/forms';
 import { Controller, DisabledController, ReadonlyController } from '@odx/angular';
 import { ControlDirective } from './control.directive';
 import * as i0 from "@angular/core";
+/**
+ * An abstract directive that serves as a base for custom form controls, integrating seamlessly with Angular Forms.
+ * It incorporates common form control behaviors such as handling disabled and readonly states, validation, and more.
+ *
+ * This approach allows the creation of highly reusable and consistent form controls within Angular applications,
+ * simplifying the integration with Angular Forms and the handling of common form behaviors.
+ *
+ * Extends Controller to provide a consistent API for managing state changes and subscriptions.
+ *
+ * @see {Controller}
+ */
 export declare abstract class CustomFormControl<T> extends Controller implements ControlValueAccessor {
     private static CURRENT_INDEX;
     private readonly requiredValidator;
@@ -9,24 +20,121 @@ export declare abstract class CustomFormControl<T> extends Controller implements
     protected readonly disabledController: DisabledController | null;
     protected readonly readonlyController: ReadonlyController | null;
     protected readonly ngControl: NgControl | null;
+    /**
+     * A unique identifier for the custom form control. If not provided, a unique ID is generated automatically.
+     * This can be useful for associating form control with a label.
+     *
+     * @type {string}
+     */
     id: string | null;
+    /**
+     * The name attribute for the custom form control. Defaults to a unique name if not provided.
+     * This is useful when the form control is part of a form and needs to be identified.
+     *
+     * @type {string}
+     */
     name: string;
+    /**
+     * The tabindex attribute for the custom form control. Can be used to control the order of focus navigation.
+     *
+     * @type {string | null}
+     */
     tabindex: string | null;
+    /**
+     * An array of error codes to ignore. If an error code is included in this array, the form control will not
+     * consider it as an error state. Useful for ignoring specific validation errors.
+     *
+     * @type {string[]}
+     */
     ignoreErrors: string[];
+    /**
+     * The current value of the form control. Setting this value updates the internal state and marks the control
+     * for checking changes. Getting this value returns the current internal value of the control.
+     *
+     * @example
+     * ```ts
+     * this.customInputControl.value = 'newValue'; // Sets the value
+     * const currentValue = this.customInputControl.value; // Gets the current value
+     * ```
+     */
     set value(value: T);
+    /**
+     * Gets the value of the custom form control.
+     *
+     * @returns {T} - The value of the custom form control.
+     */
     get value(): T;
+    /**
+     * Indicates whether the form control currently has an error. This takes into account any ignored errors.
+     *
+     * @returns {boolean} - True if the form control has an error, false otherwise.
+     *
+     * @example
+     * ```ts
+     * if (this.customInputControl.hasError) { ... }
+     * ```
+     */
     get hasError(): boolean;
+    /**
+     * Indicates whether the form control is currently disabled.
+     *
+     * @returns {boolean} - True if the form control is disabled, false otherwise.
+     *
+     * @example
+     * ```ts
+     * if (this.customInputControl.isDisabled) { ... }
+     * ```
+     */
     get isDisabled(): boolean;
+    /**
+     * Indicates whether the form control is currently in a readonly state.
+     *
+     * @returns {boolean} - True if the form control is readonly, false otherwise.
+     *
+     * @example
+     * ```ts
+     * if (this.customInputControl.isReadonly) { ... }
+     * ```
+     */
     get isReadonly(): boolean;
+    /**
+     * Indicates whether the form control is marked as required, either through Validators.required, Validators.requiredTrue,
+     * or by a required attribute on a parent form field.
+     *
+     * @returns {boolean} - True if the form control is required, false otherwise.
+     *
+     * @example
+     * ````ts
+     * if (this.customInputControl.isRequired) { ... }
+     * ````
+     */
     get isRequired(): boolean;
+    /**
+     * A reference to the `ControlDirective` if it exists within the same host. This allows for direct interaction
+     * with the underlying form control directive.
+     *
+     * @type {ControlDirective | null}
+     *
+     * @example
+     * ```ts
+     * this.customInputControl.control?.focus();
+     * ```
+     */
     readonly control: ControlDirective | null;
     constructor(initialValue: T);
+    /** @internal */
     onTouched(): void;
+    /** @internal */
     onChange(_value: T): void;
+    /** @internal */
     registerOnChange(fn: (value: T) => void): void;
+    /** @internal */
     registerOnTouched(fn: () => void): void;
+    /** @internal */
     setDisabledState(isDisabled: boolean): void;
+    /** @internal */
     writeValue(value: T): void;
+    /** @internal */
     updateValue(value: T): void;
     protected hasValidator(validator: ValidatorFn): boolean;
     private hasNonIgnoredError;

package/cdk/custom-form-control/lib/input-control.directive.d.ts

@@ -1,12 +1,87 @@
 import * as i0 from "@angular/core";
+/**
+ * An abstract directive that facilitates handling input changes, focusing, and blurring programmatically for input elements.
+ * It provides a reactive `valueChange$` observable to subscribe to input changes.
+ * This directive can be extended to create more specific input handlers.
+ *
+ * @example
+ * Extending InputControlDirective in a custom directive:
+ * ```ts
+ * @Directive({
+ *   selector: '[appCustomInput]',
+ *   standalone: true,
+ * })
+ * export class CustomInputDirective extends InputControlDirective {
+ *   // Custom logic here
+ * }
+ * ```
+ *
+ * Using the directive in a component template:
+ * ```html
+ * <input appCustomInput type="text" />
+ * ```
+ *
+ * Subscribing to input changes in the component:
+ * ```ts
+ * @Component({...})
+ * export class MyComponent implements AfterViewInit {
+ *   @ViewChild(CustomInputDirective) customInputDirective!: CustomInputDirective;
+ *
+ *   ngAfterViewInit(): void {
+ *     this.customInputDirective.valueChange$.subscribe(value => {
+ *       console.log('Input value changed to:', value);
+ *     });
+ *   }
+ * }
+ *
+ * // Focusing the input programmatically
+ * this.customInputDirective.focus();
+ *
+ * // Blurring the input programmatically
+ * this.customInputDirective.blur();
+ *
+ * // Resetting the input value programmatically
+ * this.customInputDirective.reset();
+ * ```
+ */
 export declare abstract class InputControlDirective {
     protected readonly takeUntilDestroyed: <T>() => import("rxjs").MonoTypeOperatorFunction<T>;
     readonly element: import("@angular/core").ElementRef<HTMLInputElement>;
+    /**
+     * Represents an observable stream of value changes for the input control.
+     *
+     * @emits {string} input value changes.
+     */
     valueChange$: import("rxjs").Observable<string>;
+    /**
+     * Gets the current value of the input element.
+     *
+     * @type {string} The current value of the input element.
+     */
     get nativeElementValue(): string;
+    /**
+     * Sets the value of the input element.
+     *
+     * @param {string} value - The value to set.
+     */
     set nativeElementValue(value: string);
+    /**
+     * Sets focus on the input element.
+     *
+     * @returns {void}
+     */
     focus(): void;
+    /**
+     * Removes focus from the input element.
+     *
+     * @returns {void}
+     */
     blur(): void;
+    /**
+     * Resets the input element value to an empty string.
+     *
+     * @returns {void}
+     */
     reset(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<InputControlDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<InputControlDirective, never, never, {}, {}, never, never, true, never>;

package/cdk/dynamic-view/lib/dynamic-view.directive.d.ts

@@ -2,18 +2,43 @@ import { Injector, OnChanges, OnDestroy, OnInit } from '@angular/core';
 import { NgChanges } from '@odx/angular/utils';
 import { DynamicContent, DynamicViewRef, GetDynamicViewContext } from './facade';
 import * as i0 from "@angular/core";
+/**
+ * A directive that dynamically renders content based on the provided input. It supports rendering
+ * Angular components, templates, and text content, allowing for dynamic and flexible content
+ * management within Angular applications.
+ *
+ * @template T - A type parameter that extends `DynamicContent<unknown>`, representing the type of content to be dynamically rendered.
+ */
 export declare class DynamicViewDirective<T extends DynamicContent<unknown> = DynamicContent<unknown>> implements OnDestroy, OnInit, OnChanges {
     private readonly dynamicViewService;
     private readonly viewContainer;
     private readonly template;
     private viewRef;
     private contentViewRef;
+    /**
+     * The content to be dynamically rendered. This can be a component, template reference, or text content.
+     * The content is wrapped in a `DynamicViewRef`, providing additional control over the dynamically rendered view.
+     */
     content?: T | DynamicViewRef<T> | null;
+    /**
+     * An optional injector to be used for dynamically created components. This allows for custom dependency injection
+     * into dynamically rendered components.
+     */
     injector?: Injector;
+    /**
+     * An optional context providing function for dynamically created views. This function returns the context
+     * object to be passed to the dynamically rendered content, allowing for dynamic interaction with the content.
+     */
     context?: GetDynamicViewContext<T>;
     ngOnInit(): void;
     ngOnChanges(changes: NgChanges<DynamicViewDirective<DynamicContent>>): void;
     ngOnDestroy(): void;
+    /**
+     * Retrieves the current `DynamicViewRef` associated with the rendered content, providing access
+     * to the view reference for additional operations like updating context or manual destruction.
+     *
+     * @returns {DynamicViewRef<T> | null} The current view reference for the dynamically rendered content, if available.
+     */
     getView(): DynamicViewRef<T> | null;
     private render;
     private destroy;

package/cdk/dynamic-view/lib/dynamic-view.service.d.ts

@@ -1,9 +1,39 @@
 import { DynamicContent, DynamicViewRef } from './facade';
 import { DynamicViewOptions } from './models';
 import * as i0 from "@angular/core";
+/**
+ * A service for creating and managing dynamic views in an Angular application.
+ * It supports rendering Angular components, templates, and text content dynamically,
+ * allowing for flexible and dynamic content composition.
+ */
 export declare class DynamicViewService {
     private readonly injector;
     private readonly defaultHost;
+    /**
+     * Creates and returns a reference to a dynamic view based on the provided content and options.
+     * The method supports dynamic creation of components, template references, and text content,
+     * providing a unified API for dynamic content rendering.
+     *
+     * @template T - The type of the content to be dynamically rendered.
+     * @param {T} content - The content to be rendered dynamically. This can be a component class,
+     * a template reference, or text content.
+     * @param {Partial<DynamicViewOptions<T>>} [options={}] - Optional configuration for the dynamic view creation,
+     * including a custom injector, context, host element, and additional providers for the dynamic component's injector.
+     * @returns {DynamicViewRef<T>} A reference to the dynamically created view, encapsulating the rendered content
+     * and providing methods for interaction and management.
+     * @throws {Error} Throws an error if the content type is not supported.
+     * @example
+     * ```ts
+     * // Create a dynamic view for a component
+     * const componentRef = dynamicViewService.createView(MyComponent, { context: { ... } });
+     *
+     * // Create a dynamic view for a template reference
+     * const templateRef = dynamicViewService.createView(myTemplate, { context: { ... } });
+     *
+     * // Create a dynamic view for text content
+     * const textRef = dynamicViewService.createView('Dynamic text content', {});
+     * ```
+     */
     createView<T extends DynamicContent>(content: T, options?: Partial<DynamicViewOptions<T>>): DynamicViewRef<T>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicViewService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DynamicViewService>;

package/cdk/dynamic-view/lib/helpers/create-projectable-nodes.d.ts

@@ -1,2 +1,24 @@
 import { Type } from '@angular/core';
+/**
+ * Prepares an array of node arrays suitable for projection into the `<ng-content>` slots
+ * of a dynamically created Angular component based on its content selectors.
+ *
+ * The function inspects the component's content selectors and aligns the provided nodes
+ * for projection according to these selectors. A selector of '*' indicates that the nodes
+ * should be projected into this slot. If a content selector does not match '*', an empty
+ * array is returned for that slot, indicating no nodes are projected into it.
+ *
+ * @param {Type<unknown>} component - The component class for which the projectable nodes are being prepared.
+ * @param {Node[]} nodes - The nodes intended for projection into the component's `<ng-content>` slots.
+ * @returns {Node[][]} An array of node arrays, each corresponding to a `<ng-content>` slot in the component.
+ * Each sub-array contains nodes to be projected into the respective `<ng-content>` slot, based on the component's content selectors.
+ *
+ * @example
+ * ```ts
+ * // Given a component with two `<ng-content>` slots, the first without a selector and the second with the selector `<ng-content select=".selector-class">`,
+ * const nodes = [document.createTextNode('Hello'), document.createElement('div')];
+ * const projectableNodes = createProjectableNodes(MyComponent, nodes);
+ * // projectableNodes would be `[[TextNode, DivElement], []]` for a component with selectors ['*', '.selector-class']
+ * ```
+ */
 export declare function createProjectableNodes(component: Type<unknown>, nodes: Node[]): Node[][];

package/cdk/dynamic-view/lib/helpers/is-dynamic-text-content.d.ts

@@ -1,2 +1,24 @@
 import { DynamicTextContent } from '../facade';
+/**
+ * Type guard function to check if a given value is considered dynamic text content.
+ * Dynamic text content can either be a plain string or an Observable. This function
+ * facilitates type-safe handling of dynamic text content by checking the type of the value.
+ *
+ * @param {unknown} value - The value to be checked.
+ * @returns {value is DynamicTextContent} Returns `true` if the value is a string or an Observable,
+ * indicating it can be used as dynamic text content; otherwise, returns `false`.
+ *
+ * @example
+ * ```ts
+ * // Example usage of the isDynamicTextContent function
+ * const textValue: unknown = getTextValue(); // This function may return either string or Observable
+ *
+ * if (isDynamicTextContent(textValue)) {
+ *   // The type of textValue is now narrowed to DynamicTextContent (string | Observable)
+ *   console.log('The value can be used as dynamic text content.');
+ * } else {
+ *   console.log('The value is not suitable as dynamic text content.');
+ * }
+ * ```
+ */
 export declare function isDynamicTextContent(value: unknown): value is DynamicTextContent;

package/cdk/dynamic-view/lib/helpers/is-dynamic-view.d.ts

@@ -1,2 +1,24 @@
 import { DynamicContent, DynamicViewRef } from '../facade';
+/**
+ * Type guard function to check if a given value is a reference to a dynamically created view.
+ * This helps in distinguishing between dynamic view references (`DynamicComponentRef` or `DynamicTemplateRef`)
+ * and other types of values, facilitating type-safe operations on dynamic views.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is DynamicViewRef<DynamicContent>} `true` if the value is an instance of `DynamicComponentRef`
+ * or `DynamicTemplateRef`, indicating it is a dynamic view reference; otherwise, `false`.
+ *
+ * @example
+ * ```ts
+ * // Given a value that could be a dynamic view reference or something else
+ * const value: unknown = getSomeValue();
+ *
+ * if (isDynamicView(value)) {
+ *   // TypeScript now knows `value` is a dynamic view reference, so you can access its methods safely
+ *   value.detectChanges();
+ * } else {
+ *   console.log('Value is not a dynamic view reference');
+ * }
+ * ```
+ */
 export declare function isDynamicView(value: unknown): value is DynamicViewRef<DynamicContent>;

package/cdk/dynamic-view/lib/models/dynamic-component-ref.d.ts

@@ -5,16 +5,55 @@ import { DynamicViewOptions } from './dynamic-view-options';
 export interface DynamicComponentOptions<T extends Type<unknown>> extends DynamicViewOptions<T> {
     component: T;
 }
+/**
+ * The DynamicComponentRef class is a powerful utility for dynamically creating and managing
+ * Angular components at runtime. It encapsulates the logic for component creation, input handling,
+ * and lifecycle management, making it easier to work with dynamic components in complex applications.
+ *
+ * A reference to a dynamically created component, providing methods to manage its lifecycle,
+ * detect changes, and update its inputs based on a context.
+ *
+ * @template T - The type of the component being managed.
+ * @template C - The type of the context used to update the component's inputs.
+ */
 export declare class DynamicComponentRef<T extends Type<unknown>, C extends GetDynamicViewContext<T>> implements DynamicViewRef<T> {
     private readonly options;
     private readonly application;
     private componentRef;
     private componentInputs;
     constructor(options: DynamicComponentOptions<T>);
+    /**
+     * Triggers change detection for the dynamically created component, ensuring that any updates to inputs
+     * or internal state are reflected in the view.
+     */
     detectChanges(): void;
+    /**
+     * Destroys the dynamically created component, cleaning up resources and detaching it from the application view.
+     */
     destroy(): void;
+    /**
+     * Retrieves the native element associated with the dynamically created component's host view.
+     *
+     * @returns {Element} The native DOM element of the component.
+     */
     getElement(): Element;
+    /**
+     * Updates the component's inputs based on the provided context. Merges the new context with the existing
+     * context and applies the combined context as inputs to the component.
+     *
+     * @param {C} context - The context containing new values for the component's inputs.
+     */
     update(context: C): void;
+    /**
+     * Retrieves the current context used for the component's inputs.
+     *
+     * @returns {GetDynamicViewContext<T>} The current context object.
+     */
     getContext(): GetDynamicViewContext<T>;
+    /**
+     * Retrieves the view reference associated with the dynamically created component.
+     *
+     * @returns {ViewRef | null} The view reference, or null if the component has not been created or has been destroyed.
+     */
     getView(): ViewRef | null;
 }

package/cdk/dynamic-view/lib/models/dynamic-template-ref.d.ts

@@ -4,16 +4,52 @@ import { DynamicViewOptions } from './dynamic-view-options';
 export interface DynamicTemplateOptions<T extends NgTemplateRef<unknown>> extends DynamicViewOptions<T> {
     template: T;
 }
+/**
+ * A reference to a dynamically created template, offering methods to manage its lifecycle,
+ * detect changes, and update its context. It encapsulates the logic for creating and manipulating
+ * an `EmbeddedViewRef` from a given `TemplateRef`.
+ *
+ * @template T - The type of the `NgTemplateRef` being managed.
+ */
 export declare class DynamicTemplateRef<T extends NgTemplateRef<unknown> = NgTemplateRef<unknown>> implements DynamicViewRef<T> {
     private readonly options;
     private readonly application;
     private embeddedViewRef;
     constructor(options: DynamicTemplateOptions<T>);
+    /**
+     * Triggers change detection on the embedded view created from the template, ensuring that any updates
+     * to the context or internal state are reflected in the view.
+     */
     detectChanges(): void;
+    /**
+     * Destroys the embedded view associated with the template, cleaning up resources and detaching it from the
+     * application view if necessary.
+     */
     destroy(): void;
+    /**
+     * Retrieves the native element associated with the template's embedded view's root node.
+     *
+     * @returns {Element} The native DOM element of the embedded view's root node, if available.
+     */
     getElement(): Element;
+    /**
+     * Updates the context of the embedded view based on the provided context object. Merges the new context
+     * with the existing one and applies the combined context to the embedded view.
+     *
+     * @param {GetDynamicViewContext<T>} context - The context containing new values for the template's view.
+     */
     update(context: GetDynamicViewContext<T>): void;
+    /**
+     * Retrieves the current context used for the template's view.
+     *
+     * @returns {GetDynamicViewContext<T>} The current context object.
+     */
     getContext(): GetDynamicViewContext<T>;
+    /**
+     * Retrieves the view reference (`ViewRef`) associated with the dynamically created template's embedded view.
+     *
+     * @returns {ViewRef | null} The view reference, or null if the template has not been instantiated or has been destroyed.
+     */
     getView(): ViewRef | null;
     private create;
 }

package/cdk/event-plugins/lib/event-plugins.config.d.ts

@@ -1,3 +1,38 @@
 import { EnvironmentProviders, Provider } from '@angular/core';
 export declare const EVENT_PLUGINS: Provider[];
+/**
+ * Provides a set of custom event plugins to Angular's event handling system. This function
+ * registers custom event plugins like `DebounceEventPlugin` and `DeferEventPlugin`, enhancing
+ * the capabilities of Angular's native event management. By using `EVENT_MANAGER_PLUGINS`, these
+ * plugins are integrated into Angular's event system and can be utilized in templates and components
+ * to handle events with custom behaviors such as debouncing or deferring event execution.
+ *
+ * @example
+ * Registering the event plugins in an Angular module:
+ * ```ts
+ * @NgModule({
+ *   imports: [
+ *     BrowserModule,
+ *     BrowserAnimationsModule,
+ *     // other imports...
+ *   ],
+ *   declarations: [AppComponent],
+ *   providers: [
+ *     provideEventPlugins(),
+ *   ],
+ *   bootstrap: [AppComponent],
+ * })
+ * export class AppModule {}
+ * ```
+ * Assuming `DebounceEventPlugin` modifies event names with a `.debounce` modifier:
+ * ```html
+ * <button (click.debounce)="handleDebouncedClick($event)">Click Me</button>
+ *  ```
+ * Assuming `DeferEventPlugin` modifies event names with a `.defer` modifier:
+ * ```html
+ * <div (mouseenter.defer)="handleDeferredMouseEnter($event)"></div>
+ * ```
+ *
+ * @returns {EnvironmentProviders} - A configuration object for Angular's DI system, to be used with `makeEnvironmentProviders`.
+ */
 export declare function provideEventPlugins(): EnvironmentProviders;