@odx/angular 12.26.1 → 13.0.1

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

@@ -1,88 +0,0 @@
-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/date-input/lib/date.config.d.ts

@@ -1,48 +0,0 @@
-import { InputDateOrder } from './models/input-date-order';
-export interface DateConfig {
-    /**
-     * Date's order ('DMY' | 'MDY' | 'YMD').
-     * @default InputDateOrder.DMY
-     */
-    inputDateOrder: InputDateOrder;
-    /**
-     * Single-character date's separator (dot, slash etc.).
-     * @default '.'
-     */
-    inputDateSeparator: string;
-}
-/**
- * Tools for injecting and providing the date configuration with default configuration for the date.
- *
- * @example
- * // Providing custom date configuration.
- * ```ts
- * @Component({
- *   providers: [provideDateConfig({ inputDateOrder: InputDateOrder.MDY, inputDateSeparator: '/'})]
- * })
- * export class MyComponent {}
- *
- * // Injecting the date configuration.
- * ```ts
- * @Component({})
- * export class MyComponent {
- *  constructor(@Inject(injectDateConfig()) private readonly dateConfig: DateConfig) {}
- * }
- * ```
- */
-export declare const DateConfig: import("@angular/core").InjectionToken<Partial<{
-    inputDateOrder: string;
-    inputDateSeparator: string;
-}>>, DateDefaultConfig: {
-    inputDateOrder: string;
-    inputDateSeparator: string;
-}, injectDateConfig: () => {
-    inputDateOrder: string;
-    inputDateSeparator: string;
-}, provideDateConfig: <D extends import("@odx/angular/utils").ConfigDependencies = import("@odx/angular/utils").ConfigDependencies<Partial<{
-    inputDateOrder: string;
-    inputDateSeparator: string;
-}>>>(config: import("@odx/angular/utils").ConfigProvider<Partial<{
-    inputDateOrder: string;
-    inputDateSeparator: string;
-}>, D>) => import("@angular/core").FactoryProvider | import("@angular/core").ValueProvider;

package/cdk/date-input/lib/models/input-date-order.d.ts

@@ -1,17 +0,0 @@
-export type InputDateOrder = (typeof InputDateOrder)[keyof typeof InputDateOrder];
-export declare const InputDateOrder: {
-    DMY: string;
-    MDY: string;
-    YMD: string;
-};
-export type DateInputPattern = typeof DateInputFormat | typeof DateInputMask;
-export declare const DateInputFormat: {
-    DAYS: string;
-    MONTH: string;
-    YEAR: string;
-};
-export declare const DateInputMask: {
-    DAYS: string;
-    MONTH: string;
-    YEAR: string;
-};

package/cdk/date-input/lib/utils/get-date-input-pattern.d.ts

@@ -1,5 +0,0 @@
-import { DateConfig } from '../date.config';
-/** @internal */
-export declare function getDateInputFormat(config: DateConfig): string;
-/** @internal */
-export declare function getDateInputMask(config: DateConfig): string;

package/cdk/date-input/lib/utils/get-input-value-as-date.d.ts

@@ -1,3 +0,0 @@
-import { DateConfig } from '../date.config';
-/** @internal */
-export declare function getDateInputValueAsDate(config: DateConfig, value: string): Date | null;

package/cdk/date-input/lib/utils/ngx-mask-init.d.ts

@@ -1,3 +0,0 @@
-import { NgxMaskConfig, NgxMaskDirective } from 'ngx-mask';
-export declare function initNgxMask(ngxMask: NgxMaskDirective | undefined, mask: string): void;
-export declare const ngxMaskProviderConfig: Partial<NgxMaskConfig>;

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

@@ -1,12 +0,0 @@
-import { OnDestroy } from '@angular/core';
-import { DynamicTextContent } from './facade';
-import * as i0 from "@angular/core";
-export declare class DynamicViewComponent implements OnDestroy {
-    private readonly element;
-    private currentSubscription;
-    set content(value: DynamicTextContent);
-    ngOnDestroy(): void;
-    private setContent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicViewComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicViewComponent, "odx-dynamic-view", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, true, never>;
-}

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

@@ -1,55 +0,0 @@
-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.
-     *
-     * @type {T | DynamicViewRef<T> | null}
-     * @default null
-     */
-    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.
-     *
-     * @type {Injector | undefined}
-     */
-    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.
-     *
-     * @type {GetDynamicViewContext<T> | undefined}
-     */
-    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;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicViewDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DynamicViewDirective<any>, "ng-template[odxDynamicView]", never, { "content": { "alias": "odxDynamicView"; "required": false; }; "injector": { "alias": "odxDynamicViewInjector"; "required": false; }; "context": { "alias": "odxDynamicViewContext"; "required": false; }; }, {}, never, never, true, never>;
-}

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

@@ -1,40 +0,0 @@
-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/facade/dynamic-content.d.ts

@@ -1,8 +0,0 @@
-import { TemplateRef, Type } from '@angular/core';
-import { GetProperties } from '@odx/angular/utils';
-import { Observable } from 'rxjs';
-export type DynamicTextContent = string | Observable<string>;
-export type DynamicContent<C = unknown> = DynamicTextContent | TemplateRef<C> | Type<C>;
-export type GetDynamicViewContext<T extends DynamicContent> = Partial<T extends DynamicContent<infer C> ? (T extends Type<C> ? GetProperties<C> : T extends TemplateRef<C> ? C : {
-    content: T;
-}) : never>;

package/cdk/dynamic-view/lib/facade/dynamic-view-ref.d.ts

@@ -1,10 +0,0 @@
-import { ViewRef } from '@angular/core';
-import { DynamicContent, GetDynamicViewContext } from './dynamic-content';
-export interface DynamicViewRef<T extends DynamicContent> {
-    detectChanges(): void;
-    destroy(): void;
-    getElement(): Element;
-    update(context: GetDynamicViewContext<T>): void;
-    getContext(): GetDynamicViewContext<T>;
-    getView(): ViewRef | null;
-}

package/cdk/dynamic-view/lib/facade/index.d.ts

@@ -1,2 +0,0 @@
-export * from './dynamic-content';
-export * from './dynamic-view-ref';

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

@@ -1,24 +0,0 @@
-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/index.d.ts

@@ -1,3 +0,0 @@
-export * from './create-projectable-nodes';
-export * from './is-dynamic-text-content';
-export * from './is-dynamic-view';

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

@@ -1,24 +0,0 @@
-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,24 +0,0 @@
-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

@@ -1,59 +0,0 @@
-import { Type, ViewRef } from '@angular/core';
-import { GetDynamicViewContext } from '../facade';
-import { DynamicViewRef } from '../facade/dynamic-view-ref';
-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

@@ -1,55 +0,0 @@
-import { TemplateRef as NgTemplateRef, ViewRef } from '@angular/core';
-import { DynamicViewRef, GetDynamicViewContext } from '../facade';
-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/dynamic-view/lib/models/dynamic-view-options.d.ts

@@ -1,11 +0,0 @@
-import { Injector, StaticProvider, ViewContainerRef } from '@angular/core';
-import { DynamicContent, GetDynamicViewContext } from '../facade';
-export interface DynamicViewRenderingOptions {
-    injector: Injector;
-    providers?: StaticProvider[];
-    host?: ViewContainerRef | Element | null;
-}
-export interface DynamicViewOptions<T extends DynamicContent> extends DynamicViewRenderingOptions {
-    context?: GetDynamicViewContext<T>;
-    projectableNodes?: Node[][];
-}

package/cdk/dynamic-view/lib/models/index.d.ts

@@ -1,3 +0,0 @@
-export * from './dynamic-component-ref';
-export * from './dynamic-template-ref';
-export * from './dynamic-view-options';

package/cdk/dynamic-view/lib/tokens/dynamic-view-context.d.ts

@@ -1,9 +0,0 @@
-import { InjectionToken, TemplateRef } from '@angular/core';
-export interface DynamicViewContextWithImplicitTemplate<T = unknown> {
-    $implicit: TemplateRef<T>;
-}
-/**
- * @internal
- * Injection token for the dynamic view context.
- */
-export declare const DYNAMIC_VIEW_CONTEXT: InjectionToken<unknown>;

package/cdk/dynamic-view/lib/tokens/dynamic-view-default-host.d.ts

@@ -1,13 +0,0 @@
-import { InjectionToken } from '@angular/core';
-/**
- * @internal
- * Injection token for the default host element for dynamic views.
- */
-export declare const ODX_DYNAMIC_VIEW_DEFAULT_HOST: InjectionToken<Element>;
-/**
- * @internal
- * Retrieves the default host for dynamic views.
- *
- * @returns {Element} The default host element for dynamic views.
- */
-export declare function getDynamicViewDefaultHost(): Element;

package/cdk/dynamic-view/lib/tokens/index.d.ts

@@ -1,2 +0,0 @@
-export * from './dynamic-view-context';
-export * from './dynamic-view-default-host';

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

@@ -1,38 +0,0 @@
-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;