@odx/angular 12.26.0 → 13.0.0

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

@@ -1,3 +1,243 @@
-export * from './lib/control.directive';
-export * from './lib/custom-form-control';
-export * from './lib/input-control.directive';
+import * as i0 from '@angular/core';
+import { ControlValueAccessor, NgControl, ValidatorFn } from '@angular/forms';
+import { Controller, DisabledController, ReadonlyController } from '@odx/angular';
+import * as rxjs from 'rxjs';
+
+declare class ControlDirective {
+    readonly element: i0.ElementRef<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ControlDirective, "[odxControl]", ["odxControl"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * 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}
+ */
+declare abstract class CustomFormControl<T> extends Controller implements ControlValueAccessor {
+    private static CURRENT_INDEX;
+    private readonly requiredValidator;
+    private internalValue;
+    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[];
+    required: boolean;
+    /**
+     * 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CustomFormControl<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomFormControl<any>, never, never, { "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "ignoreErrors": { "alias": "ignoreErrors"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_ignoreErrors: string | string[];
+    static ngAcceptInputType_required: unknown;
+}
+
+/**
+ * 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();
+ * ```
+ */
+declare abstract class InputControlDirective {
+    protected readonly takeUntilDestroyed: <T>() => rxjs.MonoTypeOperatorFunction<T>;
+    readonly element: i0.ElementRef<HTMLInputElement>;
+    /**
+     * Represents an observable stream of value changes for the input control.
+     *
+     * @emits {string} input value changes.
+     */
+    valueChange$: 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>;
+}
+
+export { ControlDirective, CustomFormControl, InputControlDirective };

package/cdk/date-input/index.d.ts

@@ -1,5 +1,86 @@
-export * from './lib/date.config';
-export * from './lib/models/input-date-order';
-export * from './lib/utils/get-date-input-pattern';
-export * from './lib/utils/get-input-value-as-date';
-export * from './lib/utils/ngx-mask-init';
+import * as _odx_angular_utils from '@odx/angular/utils';
+import * as _angular_core from '@angular/core';
+import { NgxMaskDirective, NgxMaskConfig } from 'ngx-mask';
+
+type InputDateOrder = (typeof InputDateOrder)[keyof typeof InputDateOrder];
+declare const InputDateOrder: {
+    DMY: string;
+    MDY: string;
+    YMD: string;
+};
+type DateInputPattern = typeof DateInputFormat | typeof DateInputMask;
+declare const DateInputFormat: {
+    DAYS: string;
+    MONTH: string;
+    YEAR: string;
+};
+declare const DateInputMask: {
+    DAYS: string;
+    MONTH: string;
+    YEAR: string;
+};
+
+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) {}
+ * }
+ * ```
+ */
+declare const DateConfig: _angular_core.InjectionToken<Partial<{
+    inputDateOrder: string;
+    inputDateSeparator: string;
+}>>;
+declare const DateDefaultConfig: {
+    inputDateOrder: string;
+    inputDateSeparator: string;
+};
+declare const injectDateConfig: () => {
+    inputDateOrder: string;
+    inputDateSeparator: string;
+};
+declare const provideDateConfig: <D extends _odx_angular_utils.ConfigDependencies = _odx_angular_utils.ConfigDependencies<Partial<{
+    inputDateOrder: string;
+    inputDateSeparator: string;
+}>>>(config: _odx_angular_utils.ConfigProvider<Partial<{
+    inputDateOrder: string;
+    inputDateSeparator: string;
+}>, D>) => _angular_core.FactoryProvider | _angular_core.ValueProvider;
+
+/** @internal */
+declare function getDateInputFormat(config: DateConfig): string;
+/** @internal */
+declare function getDateInputMask(config: DateConfig): string;
+
+/** @internal */
+declare function getDateInputValueAsDate(config: DateConfig, value: string): Date | null;
+
+declare function initNgxMask(ngxMask: NgxMaskDirective | undefined, mask: string): void;
+declare const ngxMaskProviderConfig: Partial<NgxMaskConfig>;
+
+export { DateConfig, DateDefaultConfig, DateInputFormat, DateInputMask, InputDateOrder, getDateInputFormat, getDateInputMask, getDateInputValueAsDate, initNgxMask, injectDateConfig, ngxMaskProviderConfig, provideDateConfig };
+export type { DateInputPattern };

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

@@ -1,7 +1,335 @@
-export * from './lib/dynamic-view.component';
-export * from './lib/dynamic-view.directive';
-export * from './lib/dynamic-view.service';
-export * from './lib/facade';
-export * from './lib/helpers';
-export * from './lib/models';
-export * from './lib/tokens';
+import * as i0 from '@angular/core';
+import { TemplateRef, Type, ViewRef, OnDestroy, OnInit, OnChanges, Injector, StaticProvider, ViewContainerRef, InjectionToken } from '@angular/core';
+import { GetProperties, NgChanges } from '@odx/angular/utils';
+import { Observable } from 'rxjs';
+
+type DynamicTextContent = string | Observable<string>;
+type DynamicContent<C = unknown> = DynamicTextContent | TemplateRef<C> | Type<C>;
+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>;
+
+interface DynamicViewRef<T extends DynamicContent> {
+    detectChanges(): void;
+    destroy(): void;
+    getElement(): Element;
+    update(context: GetDynamicViewContext<T>): void;
+    getContext(): GetDynamicViewContext<T>;
+    getView(): ViewRef | null;
+}
+
+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>;
+}
+
+/**
+ * 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.
+ */
+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>;
+}
+
+interface DynamicViewRenderingOptions {
+    injector: Injector;
+    providers?: StaticProvider[];
+    host?: ViewContainerRef | Element | null;
+}
+interface DynamicViewOptions<T extends DynamicContent> extends DynamicViewRenderingOptions {
+    context?: GetDynamicViewContext<T>;
+    projectableNodes?: Node[][];
+}
+
+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.
+ */
+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;
+}
+
+interface DynamicTemplateOptions<T extends TemplateRef<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.
+ */
+declare class DynamicTemplateRef<T extends TemplateRef<unknown> = TemplateRef<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;
+}
+
+/**
+ * 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.
+ */
+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>;
+}
+
+/**
+ * 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']
+ * ```
+ */
+declare function createProjectableNodes(component: Type<unknown>, nodes: Node[]): Node[][];
+
+/**
+ * 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.');
+ * }
+ * ```
+ */
+declare function isDynamicTextContent(value: unknown): value is DynamicTextContent;
+
+/**
+ * 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');
+ * }
+ * ```
+ */
+declare function isDynamicView(value: unknown): value is DynamicViewRef<DynamicContent>;
+
+interface DynamicViewContextWithImplicitTemplate<T = unknown> {
+    $implicit: TemplateRef<T>;
+}
+/**
+ * @internal
+ * Injection token for the dynamic view context.
+ */
+declare const DYNAMIC_VIEW_CONTEXT: InjectionToken<unknown>;
+
+/**
+ * @internal
+ * Injection token for the default host element for dynamic views.
+ */
+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.
+ */
+declare function getDynamicViewDefaultHost(): Element;
+
+export { DYNAMIC_VIEW_CONTEXT, DynamicComponentRef, DynamicTemplateRef, DynamicViewComponent, DynamicViewDirective, DynamicViewService, ODX_DYNAMIC_VIEW_DEFAULT_HOST, createProjectableNodes, getDynamicViewDefaultHost, isDynamicTextContent, isDynamicView };
+export type { DynamicComponentOptions, DynamicContent, DynamicTemplateOptions, DynamicTextContent, DynamicViewContextWithImplicitTemplate, DynamicViewOptions, DynamicViewRef, DynamicViewRenderingOptions, GetDynamicViewContext };