ngx-lift 1.10.3 → 19.0.0

package/index.d.ts

@@ -1,5 +1,1640 @@
+import { HttpErrorResponse, HttpClient } from '@angular/common/http';
+import * as rxjs from 'rxjs';
+import { Observable, TapObserver, UnaryFunction, OperatorFunction, ObservableInput } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Signal, PipeTransform, Injector, CreateComputedOptions, ModuleWithProviders } from '@angular/core';
+import { Params } from '@angular/router';
+import { AbstractControl, ValidatorFn, AsyncValidatorFn, ValidationErrors } from '@angular/forms';
+
 /**
- * Generated bundle index. Do not edit.
+ * Represents the state of an asynchronous operation, including loading, error, and data.
+ * @template T - The type of the data in the response.
+ * @template E - The type of the error response, defaulting to `HttpErrorResponse`.
  */
-/// <amd-module name="ngx-lift" />
-export * from './public-api';
+interface AsyncState<T, E = HttpErrorResponse> {
+    /**
+     * Indicates whether the asynchronous operation is in progress.
+     */
+    loading: boolean;
+    /**
+     * Represents any error that occurred during the asynchronous operation.
+     * Null if no error occurred.
+     */
+    error: E | null;
+    /**
+     * The data resulting from the asynchronous operation.
+     * Null if the operation has not completed successfully.
+     */
+    data: T | null;
+}
+
+/**
+ * Represents the metadata of a Kubernetes object.
+ * Based on the Kubernetes API v1.23 ObjectMeta specification.
+ *
+ * @see {@link https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.23/#objectmeta-v1-meta | Kubernetes ObjectMeta API Reference}
+ */
+interface KubernetesObjectMetaV1 {
+    /**
+     * The name of the object. Must be unique within a namespace.
+     */
+    name: string;
+    /**
+     * The namespace in which the object exists.
+     * Can be undefined for cluster-scoped resources.
+     */
+    namespace?: string;
+    /**
+     * A URL representing this object. Populated by the system.
+     */
+    selfLink?: string;
+    /**
+     * A unique identifier for the object. Generated by the system.
+     */
+    uid?: string;
+    /**
+     * An opaque value that represents the internal version of this object.
+     * Used for optimistic concurrency control and watch operations.
+     */
+    resourceVersion?: string;
+    /**
+     * A sequence number representing a specific generation of the desired state.
+     * Populated by the system. Read-only.
+     */
+    generation?: number;
+    /**
+     * The timestamp when the object was created.
+     * Format: RFC3339 date-time string.
+     */
+    creationTimestamp?: string;
+    /**
+     * The timestamp when the object was marked for deletion.
+     * Only present if the object is being deleted.
+     * Format: RFC3339 date-time string.
+     */
+    deletionTimestamp?: string;
+    /**
+     * The grace period in seconds before the object will be permanently deleted.
+     * Only present if the object is being deleted.
+     */
+    deletionGracePeriodSeconds?: number;
+    /**
+     * Map of string keys and values that can be used to organize and categorize objects.
+     */
+    labels?: Record<string, string>;
+    /**
+     * Map of string keys and values that can be used to store arbitrary metadata.
+     */
+    annotations?: Record<string, string>;
+    /**
+     * List of objects that own this object.
+     * Used for garbage collection and cascading deletions.
+     */
+    ownerReferences?: OwnerReference[];
+    /**
+     * List of finalizers that must be executed before the object can be deleted.
+     */
+    finalizers?: string[];
+    /**
+     * The name of the cluster where the object exists.
+     * Only present for objects in a cluster.
+     */
+    clusterName?: string;
+    /**
+     * ManagedFields maps workflow-id and version to the set of fields
+     * that are managed by that workflow.
+     */
+    managedFields?: ManagedField[];
+}
+/**
+ * Represents a reference to another Kubernetes object that owns this object.
+ */
+interface OwnerReference {
+    /**
+     * The API version of the owner object.
+     */
+    apiVersion: string;
+    /**
+     * The kind of the owner object.
+     */
+    kind: string;
+    /**
+     * The name of the owner object.
+     */
+    name: string;
+    /**
+     * The UID of the owner object.
+     */
+    uid: string;
+    /**
+     * If true, this reference points to the managing controller.
+     */
+    controller: boolean;
+    /**
+     * If true, and the owner has the "foregroundDeletion" finalizer,
+     * then the owner cannot be deleted from the key-value store until
+     * this reference is removed.
+     */
+    blockOwnerDeletion?: boolean;
+}
+/**
+ * Represents a managed field entry in the object metadata.
+ */
+interface ManagedField {
+    /**
+     * The API version of the field manager.
+     */
+    apiVersion: string;
+    /**
+     * The type of fields being managed.
+     */
+    fieldsType: string;
+    /**
+     * The fields in JSON format.
+     */
+    fieldsV1: Record<string, unknown>;
+    /**
+     * The name of the manager that manages these fields.
+     */
+    manager: string;
+    /**
+     * The operation type (e.g., "Apply", "Update").
+     */
+    operation: string;
+    /**
+     * The subresource name, if applicable.
+     */
+    subresource?: string;
+    /**
+     * The timestamp when the field was last modified.
+     * Format: RFC3339 date-time string.
+     */
+    time: string;
+}
+
+/**
+ * Represents a Kubernetes object with standard API structure.
+ * This interface defines the common structure for all Kubernetes resources.
+ *
+ * @template T - The type of the spec object (optional).
+ * @template S - The type of the status object (optional).
+ */
+interface KubernetesObject {
+    /**
+     * The API version of the Kubernetes object.
+     * Example: "v1", "apps/v1", "networking.k8s.io/v1"
+     */
+    apiVersion: string;
+    /**
+     * The kind of the Kubernetes object.
+     * Example: "Pod", "Deployment", "Service"
+     */
+    kind: string;
+    /**
+     * Metadata about the Kubernetes object, including name, namespace, labels, etc.
+     */
+    metadata: KubernetesObjectMetaV1;
+    /**
+     * The desired state of the object.
+     * The structure depends on the specific Kubernetes resource type.
+     */
+    spec?: any;
+    /**
+     * The current state of the object.
+     * The structure depends on the specific Kubernetes resource type.
+     */
+    status?: any;
+}
+
+/**
+ * Represents a list of Kubernetes objects, typically returned from list/watch API endpoints.
+ *
+ * @template T - The type of Kubernetes objects in the list. Must extend `KubernetesObject`.
+ */
+interface KubernetesList<T extends KubernetesObject> {
+    /**
+     * The API version of the Kubernetes list object.
+     * Example: "v1", "apps/v1"
+     */
+    apiVersion: string;
+    /**
+     * Metadata about the list, including pagination information.
+     */
+    metadata: {
+        /**
+         * A token that can be used to retrieve the next page of results.
+         * Empty string if there are no more results.
+         */
+        continue: string;
+        /**
+         * The resource version of the list.
+         * Used for optimistic concurrency control and watch operations.
+         */
+        resourceVersion: string;
+    };
+    /**
+     * The kind of the list object.
+     * Typically the plural form of the object kind, e.g., "PodList", "DeploymentList"
+     */
+    kind: string;
+    /**
+     * The array of Kubernetes objects in the list.
+     */
+    items: T[];
+}
+
+/**
+ * Represents a condition of a Kubernetes object.
+ * Conditions provide a standard way to represent the status of an object and its components.
+ *
+ * @template T - The type of the condition type (e.g., 'Ready', 'Available', 'Progressing').
+ * @template R - The type of the reason string (e.g., 'PodScheduled', 'ContainersReady').
+ *
+ * @example
+ * ```typescript
+ * const condition: KubernetesObjectCondition = {
+ *   type: 'Ready',
+ *   status: 'True',
+ *   reason: 'PodReady',
+ *   message: 'Pod is ready',
+ *   lastTransitionTime: '2024-01-01T00:00:00Z'
+ * };
+ * ```
+ */
+interface KubernetesObjectCondition<T = string, R = string> {
+    /**
+     * lastTransitionTime is a string representing the last time the condition transitioned from one status to another.
+     * If the underlying condition change is unknown, the time when the API field changed is used.
+     */
+    lastTransitionTime: string;
+    /**
+     * message is a string providing a human - readable message about the transition. It can be an empty string.
+     */
+    message: string;
+    /**
+     * reason is a string containing a programmatic identifier indicating the reason for the condition's last transition.
+     * Producers of specific condition types may define expected values and meanings for this field.
+     */
+    reason: R;
+    /**
+     * status is an enum with possible values 'True', 'False', or 'Unknown' representing the current status of the condition.
+     */
+    status: 'True' | 'False' | 'Unknown';
+    /**
+     * type is a string representing the type of condition in CamelCase or in foo.example.com/CamelCase format.
+     */
+    type: T;
+    /**
+     * observedGeneration is an integer representing the.metadata.generation that the condition was set based upon.
+     */
+    observedGeneration?: number;
+}
+
+declare function combineLatestEager<T extends Observable<unknown>[]>(sources: T, startWithNullForAll?: boolean): Observable<{
+    [K in keyof T]: T[K] extends Observable<infer U> ? U | null : never;
+}>;
+declare function combineLatestEager<T extends Record<string, Observable<unknown>>>(sources: T, startWithNullForAll?: boolean): Observable<{
+    [K in keyof T]: T[K] extends Observable<infer U> ? U | null : never;
+}>;
+
+/**
+ * createAsyncState transforms an Observable of type T into an Observable of AsyncState<T>.
+ * AsyncState<T> represents the loading, error, and data states for asynchronous operations.
+ *
+ * @template T - The type of the data in the observable.
+ * @template E - The type of the error that can occur.
+ *
+ * @param {Partial<Observer<T>> | ((value: T) => void)} [observerOrNextForOrigin] -
+ *   An optional parameter that can be a partial TapObserver<T> or a function to handle the next value or error in the original Observable.
+ *
+ * @returns {UnaryFunction<Observable<T>, Observable<AsyncState<T, E>>>} -
+ *   A function that transforms an observable stream into an asynchronous state.
+ *
+ * @example
+ * Usage 1: Simple request
+ * data$ = this.shopService.products$.pipe(
+ *   createAsyncState({
+ *    next: res => console.log('Side effect if success: ' + res),
+ *    error: error => console.error('Side effect if error: ' + error.message)
+ *   })
+ * );
+ *
+ * Usage 2: Dependent requests
+ * data$ = firstCall$.pipe(
+ *   switchMap(() => this.shopService.products$),
+ *   createAsyncState()
+ * );
+ *
+ * Another implementation thought when refreshing the data: instead of startWith, `merge of` emit as the trigger
+ *
+ * subject.pipe(
+ *   switchMap(() => merge(
+ *     of({ loading: true, error: null, data: null }),
+ *     this.service.apiCall().pipe(
+ *       map(data => ({ loading: false, error: null, data })),
+ *       tap({
+ *         next: res => callback?.(res.data),
+ *         error: err => errorCallback?.(err),
+ *       }),
+ *       catchError(error => of({ loading: false, error, data: null })),
+ *     ),
+ *   ))
+ * )
+ *
+ * Usage 3: provide initialValue
+ *
+ * import {createAsyncState} from 'ngx-lift';
+ * import {noop} from 'rxjs';
+ *
+ * private userService = inject(UserService);
+ * private location = inject(Location);
+ *
+ * userState$ = this.userService
+ *   .getUserById(1)
+ *   .pipe(createAsyncState<User>(noop, {loading: false, error: null, data: this.location.getState()}));
+ */
+declare function createAsyncState<T, E = HttpErrorResponse>(observerOrNextForOrigin?: Partial<TapObserver<T>> | ((value: T) => void), initialValue?: {
+    loading: boolean;
+    error: E | null;
+    data: T | null;
+}): UnaryFunction<Observable<T>, Observable<AsyncState<T, E>>>;
+
+/**
+ * Creates an operator function for RxJS Observables that filters out consecutive
+ * values that are considered equal according to a provided comparator function,
+ * and invokes a callback when a distinct value is encountered.
+ *
+ * @template T - The type of elements emitted by the observable.
+ * @param {(previousValue: T, currentValue: T) => void} onChangeCallback
+ *   A callback function that will be invoked when a distinct value is encountered.
+ *   It receives the previous distinct value and the current value.
+ * @param {(previousValue: T, currentValue: T) => boolean} [comparator]
+ *   A function that determines if two values are considered equal.
+ *   Defaults to a function that performs strict equality (===) comparison.
+ * @returns {OperatorFunction<T, T>} - The RxJS operator function.
+ *
+ * @example
+ * Example 1:
+ * const source$ = new Observable<number>((observer) => {
+ *   observer.next(1);
+ *   observer.next(2);
+ *   observer.next(2);
+ *   observer.next(3);
+ *   observer.next(3);
+ *   observer.next(4);
+ *   observer.next(5);
+ *   observer.complete();
+ * });
+ *
+ * const distinctOnChange$ = source$.pipe(
+ *   distinctOnChange(
+ *     (prev, curr) => console.log(`Value changed from ${prev} to: ${curr}`),
+ *     (prev, curr) => prev === curr,
+ *   ),
+ * );
+ * distinctOnChange$.subscribe((res) => console.log(res));
+ *
+ *
+ * Example 2:
+ * distinctOnChange<RDEValue<OseInstance>[]>(
+ *   () => {
+ *     this.store.dispatch(
+ *       addToast({
+ *         toast: {
+ *           type: ToastType.SUCCESS,
+ *           title: this.l10nService.getMessage('STATUS_CHANGE'),
+ *           description: this.l10nService.getMessage('STATUS_CHANGE_DESC'),
+ *         },
+ *       }),
+ *     );
+ *   },
+ *   (prev, current) =>
+ *     prev.every((prevInstance, index) => instanceComparator(prevInstance.entity, current[index].entity)),
+ * );
+ */
+declare function distinctOnChange<T>(onChangeCallback: (previousValue: T, currentValue: T) => void, comparator?: (previousValue: T, currentValue: T) => boolean): OperatorFunction<T, T>;
+
+/**
+ * Creates an RxJS operator that fetches paginated Kubernetes resources by continually making requests
+ * until all pages have been retrieved, and aggregates the items from all pages into a single KubernetesList.
+ *
+ * This operator uses Kubernetes' pagination mechanism with the `continue` token. It:
+ * - Starts with the initial request
+ * - Checks for a `continue` token in the response metadata
+ * - Makes subsequent requests with the `continue` token until no more pages exist
+ * - Aggregates all items from all pages into a single KubernetesList
+ *
+ * @template T - The type of Kubernetes objects in the list. Must extend `KubernetesObject`.
+ * @param http - The HttpClient instance used to make the HTTP requests.
+ * @param endpoint - The API endpoint to fetch the resources from.
+ * @param initialParams - Optional initial parameters to include in the request.
+ *   Can include query parameters like filters and pagination settings.
+ *   Note: `limit` and `continue` are Kubernetes-specific pagination parameters.
+ * @returns An RxJS operator function that transforms a source Observable into an Observable
+ *   that emits a single KubernetesList containing all aggregated items from all pages.
+ *
+ * @example
+ * ```typescript
+ * // Use as an operator
+ * this.http.get<KubernetesList<Pod>>('/api/v1/pods')
+ *   .pipe(
+ *     aggregatePaginatedKubernetesResources(this.http, '/api/v1/pods', { limit: 100 })
+ *   )
+ *   .subscribe(list => {
+ *     console.log(`Total pods: ${list.items.length}`);
+ *   });
+ * ```
+ */
+declare function aggregatePaginatedKubernetesResources<T extends KubernetesObject>(http: HttpClient, endpoint: string, initialParams?: Record<string, string | number | boolean | (string | number | boolean)[]>): OperatorFunction<KubernetesList<T>, KubernetesList<T>>;
+/**
+ * Fetches paginated Kubernetes resources by continually making requests until all pages have been retrieved.
+ *
+ * This function is a convenience wrapper that combines the initial HTTP request with pagination handling.
+ * It automatically handles Kubernetes pagination using the `continue` token mechanism.
+ *
+ * Unlike `aggregatePaginatedKubernetesResources`, this function makes the initial request itself
+ * rather than being used as an operator on an existing Observable.
+ *
+ * @template T - The type of Kubernetes objects in the list. Must extend `KubernetesObject`.
+ * @param http - The HttpClient instance used to make the HTTP requests.
+ * @param endpoint - The API endpoint to fetch the resources from.
+ * @param initialParams - Optional initial parameters to include in the request.
+ *   Can include query parameters like filters and pagination settings.
+ *   Note: `limit` and `continue` are Kubernetes-specific pagination parameters.
+ * @returns An Observable that emits a single KubernetesList containing all aggregated items from all pages.
+ *
+ * @example
+ * ```typescript
+ * // Fetch all pods across all pages
+ * fetchPaginatedKubernetesResources<Pod>(
+ *   this.http,
+ *   '/api/v1/pods',
+ *   { limit: 100 }
+ * ).subscribe(list => {
+ *   console.log(`Total pods: ${list.items.length}`);
+ * });
+ * ```
+ */
+declare function fetchPaginatedKubernetesResources<T extends KubernetesObject>(http: HttpClient, endpoint: string, initialParams?: Record<string, string | number | boolean | (string | number | boolean)[]>): Observable<KubernetesList<T>>;
+
+type LoggerType = 'count' | 'debug' | 'dir' | 'log' | 'table';
+/**
+ * RxJS operator that logs values emitted by an observable using various console methods.
+ * Useful for debugging and monitoring observable streams during development.
+ *
+ * @template T - The type of values emitted by the observable.
+ * @param loggerType - The type of logger to be used. Options:
+ *   - `'log'`: Standard console.log (default)
+ *   - `'debug'`: Console.debug for debug messages
+ *   - `'dir'`: Console.dir for object inspection
+ *   - `'count'`: Console.count for counting emissions
+ *   - `'table'`: Console.table for tabular data display
+ * @returns An RxJS operator function that logs values using the specified console function.
+ *
+ * @example
+ * ```typescript
+ * // Log all values
+ * source$.pipe(logger()).subscribe();
+ *
+ * // Use debug logger
+ * source$.pipe(logger('debug')).subscribe();
+ *
+ * // Display objects in table format
+ * users$.pipe(logger('table')).subscribe();
+ * ```
+ */
+declare const logger: <T>(loggerType?: LoggerType) => OperatorFunction<T, T>;
+
+/**
+ * Polls data at a specified interval and can be triggered manually, returning an observable that
+ * emits the result of each poll as an `AsyncState` object.
+ *
+ * This operator is useful for periodically fetching data from an API or checking for updates.
+ * It supports:
+ * - Automatic polling at a specified interval
+ * - Manual refresh triggers via Observable or Signal
+ * - Parameter building for dynamic polling requests
+ * - Initial values and delayed start
+ *
+ * The polling function can return an Observable, Promise, or synchronous value.
+ * The operator uses `exhaustMap` internally, which means if a poll is in progress when a new
+ * trigger arrives, the new trigger will be ignored until the current poll completes.
+ *
+ * @template Data - The type of the data emitted by the polling function.
+ * @template Input - The type of the input parameter used to build polling parameters (when using `forceRefresh`).
+ *
+ * @param options - Configuration options for polling:
+ *   - `interval`: The interval in milliseconds between each automatic poll.
+ *   - `pollingFn`: A function that returns an Observable, Promise, or primitive value to poll.
+ *     When `forceRefresh` is provided, this function receives the parameter value.
+ *   - `forceRefresh`: Optional Observable or Signal that triggers a manual refresh.
+ *     The emitted value can be used as a parameter for `pollingFn` or transformed via `paramsBuilder`.
+ *   - `paramsBuilder`: Optional function that transforms the `forceRefresh` value into parameters for `pollingFn`.
+ *   - `initialValue`: Optional initial `AsyncState` value to emit before the first poll completes.
+ *   - `delay`: Optional delay in milliseconds to wait before starting the first poll.
+ *
+ * @returns An observable that emits `AsyncState<Data>` objects representing the polling results.
+ *   Each emission includes `loading`, `error`, and `data` properties.
+ *
+ * @example
+ * ```typescript
+ * // Simple polling
+ * const dataState$ = poll({
+ *   interval: 5000, // Poll every 5 seconds
+ *   pollingFn: () => this.http.get('/api/data'),
+ *   initialValue: { loading: true, error: null, data: null }
+ * });
+ *
+ * // Polling with manual refresh
+ * const refresh$ = new Subject<void>();
+ * const dataState$ = poll({
+ *   interval: 5000,
+ *   pollingFn: () => this.http.get('/api/data'),
+ *   forceRefresh: refresh$
+ * });
+ *
+ * // Polling with parameters
+ * const userId$ = new BehaviorSubject(1);
+ * const userState$ = poll({
+ *   interval: 10000,
+ *   pollingFn: (id: number) => this.http.get(`/api/users/${id}`),
+ *   forceRefresh: userId$,
+ *   paramsBuilder: (id) => id
+ * });
+ * ```
+ */
+declare function poll<Data>(options: {
+    interval: number;
+    pollingFn: (params: any) => Observable<Data> | Promise<Data> | Data;
+    initialValue?: AsyncState<Data>;
+    delay?: number;
+}): Observable<AsyncState<Data>>;
+declare function poll<Data, Input>(options: {
+    interval: number;
+    pollingFn: (params: Input) => Observable<Data> | Promise<Data> | Data;
+    forceRefresh: Observable<Input> | Signal<Input>;
+    initialValue?: AsyncState<Data>;
+    delay?: number;
+}): Observable<AsyncState<Data>>;
+declare function poll<Data, Input>(options: {
+    interval: number;
+    pollingFn: (params: any) => Observable<Data> | Promise<Data> | Data;
+    forceRefresh: Observable<Input> | Signal<Input>;
+    paramsBuilder: (input: Input) => any;
+    initialValue?: AsyncState<Data>;
+    delay?: number;
+}): Observable<AsyncState<Data>>;
+
+/**
+ * RxJS operator that executes a callback function before the source Observable starts emitting values.
+ * This operator is useful for triggering side effects (like logging, state updates, or initialization)
+ * before the main Observable begins emitting.
+ *
+ * @template T - The type of values emitted by the observable.
+ * @param callback - A function to be executed synchronously before the source Observable emits its first value.
+ * @returns An RxJS operator function that executes the callback and then returns the source Observable unchanged.
+ *
+ * @example
+ * ```typescript
+ * // Log before starting
+ * data$.pipe(
+ *   startWithTap(() => console.log('Starting data fetch...')),
+ *   switchMap(() => this.http.get('/api/data'))
+ * ).subscribe();
+ *
+ * // Update loading state
+ * data$.pipe(
+ *   startWithTap(() => this.loading.set(true)),
+ *   finalize(() => this.loading.set(false))
+ * ).subscribe();
+ * ```
+ */
+declare function startWithTap<T>(callback: () => void): (source: Observable<T>) => Observable<T>;
+
+/**
+ * Custom RxJS operator that uses switchMap to handle asynchronous operations and
+ * transforms the emitted values into an AsyncState object.
+ *
+ * @template T - The type of data emitted by the observable returned by the project.
+ * @template K - The type of value emitted by the source observable.
+ * @template E - The type of error that can be encountered during the asynchronous operation.
+ *
+ * @param {function(K): Observable<T>} project - A function that takes a value emitted by the source
+ * observable and returns an observable representing an asynchronous operation.
+ *
+ * @returns {OperatorFunction<K, AsyncState<T, E>>} - An RxJS operator that transforms the source observable into
+ * an observable of AsyncState objects.
+ *
+ * @example
+ * // Usage of the switchMapWithAsyncState operator
+ * const source$ = new BehaviorSubject<number>(1);
+ *
+ * const asyncOperation = (value: number) => {
+ *   return of(value * 2).pipe(delay(1000));
+ * };
+ *
+ * const result$ = source$.pipe(switchMapWithAsyncState(asyncOperation));
+ * result$.subscribe((state) => {
+ *   console.log(state); // Outputs AsyncState objects with loading, data, and error properties.
+ * });
+ */
+declare function switchMapWithAsyncState<T, K, E = HttpErrorResponse>(project: (value: K, index: number) => Observable<T>): OperatorFunction<K, AsyncState<T, E>>;
+
+/**
+ * Angular pipe that joins array elements into a string using a specified separator.
+ *
+ * @example
+ * ```html
+ * <!-- Join array with default comma separator -->
+ * <div>{{ ['apple', 'banana', 'cherry'] | arrayJoin }}</div>
+ * <!-- Output: "apple,banana,cherry" -->
+ *
+ * <!-- Join array with custom separator -->
+ * <div>{{ ['apple', 'banana', 'cherry'] | arrayJoin: ' - ' }}</div>
+ * <!-- Output: "apple - banana - cherry" -->
+ * ```
+ */
+declare class ArrayJoinPipe implements PipeTransform {
+    /**
+     * Transforms an array into a string by joining its elements with a separator.
+     *
+     * @param value - The array to join. If not an array, returns the value as-is.
+     * @param separator - The separator string to use between array elements. Defaults to ','.
+     * @returns A string containing the joined array elements, or the original value if not an array
+     */
+    transform(value: unknown, separator?: string): string | unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayJoinPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayJoinPipe, "arrayJoin", true>;
+}
+
+/**
+ * Angular pipe that converts a number of bytes into a human-readable string format
+ * (e.g., "1.5 MB", "2.3 GB") with locale-aware formatting.
+ *
+ * Supports multiple locales including English, French, Chinese, Japanese, and more.
+ * The pipe uses the application's LOCALE_ID to determine the appropriate unit translations.
+ *
+ * @example
+ * ```html
+ * <!-- Convert bytes to human-readable format -->
+ * <div>{{ 1024 | byteConverter }}</div>
+ * <!-- Output: "1 KB" (English) or "1 Ko" (French) -->
+ *
+ * <div>{{ 1048576 | byteConverter }}</div>
+ * <!-- Output: "1 MB" (English) or "1 Mo" (French) -->
+ * ```
+ *
+ * @example
+ * To use locale-specific formatting, configure LOCALE_ID in your app:
+ * ```typescript
+ * import { LOCALE_ID, NgModule } from '@angular/core';
+ * import { registerLocaleData } from '@angular/common';
+ * import localeEn from '@angular/common/locales/en';
+ * import localeFr from '@angular/common/locales/fr';
+ *
+ * registerLocaleData(localeEn);
+ * registerLocaleData(localeFr);
+ *
+ * @NgModule({
+ *   providers: [
+ *     {
+ *       provide: LOCALE_ID,
+ *       useFactory: () => navigator.language || 'en',
+ *     },
+ *   ],
+ * })
+ * export class AppModule {}
+ * ```
+ */
+declare class ByteConverterPipe implements PipeTransform {
+    private locale;
+    transform(value: number): string;
+    transform(value?: number): string | null;
+    transform(value?: number | null): string | null;
+    private formatNumber;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ByteConverterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ByteConverterPipe, "byteConverter", true>;
+}
+
+/**
+ * Angular pipe that checks if a URL string uses the HTTPS protocol.
+ *
+ * @example
+ * ```html
+ * <!-- Check if URL is HTTPS -->
+ * <div>{{ 'https://example.com' | isHttps }}</div>
+ * <!-- Output: true -->
+ *
+ * <div>{{ 'http://example.com' | isHttps }}</div>
+ * <!-- Output: false -->
+ * ```
+ */
+declare class IsHttpsPipe implements PipeTransform {
+    /**
+     * Transforms a URL string into a boolean indicating whether it uses HTTPS.
+     *
+     * @param value - The URL string to check
+     * @returns `true` if the URL uses HTTPS protocol, `false` otherwise
+     */
+    transform(value: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IsHttpsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IsHttpsPipe, "isHttps", true>;
+}
+
+/**
+ * Options for configuring the mask pipe behavior.
+ */
+interface MaskOptions {
+    /**
+     * The number of characters to leave unmasked at the beginning of the string.
+     * Defaults to 6.
+     */
+    unmaskedPrefixLength?: number;
+    /**
+     * The number of characters to leave unmasked at the end of the string.
+     * Defaults to 6.
+     */
+    unmaskedSuffixLength?: number;
+    /**
+     * Whether to apply masking. If `false`, the original string is returned unchanged.
+     * Defaults to `true`.
+     */
+    masked?: boolean;
+}
+/**
+ * Angular pipe that masks sensitive string data by replacing characters with asterisks,
+ * while preserving a configurable number of characters at the beginning and end.
+ *
+ * @example
+ * ```html
+ * <!-- Mask a credit card number -->
+ * <div>{{ '1234567890123456' | mask }}</div>
+ * <!-- Output: "123456******3456" -->
+ *
+ * <!-- Custom masking options -->
+ * <div>{{ '1234567890123456' | mask: { unmaskedPrefixLength: 4, unmaskedSuffixLength: 4 } }}</div>
+ * <!-- Output: "1234********3456" -->
+ * ```
+ */
+declare class MaskPipe implements PipeTransform {
+    /**
+     * Transforms the input string by masking characters based on the provided options.
+     *
+     * @param value - The input string to be masked
+     * @param options - Options for customizing the masking behavior
+     * @returns The masked string, or the original string if masking is disabled or the string is too short
+     */
+    transform(value: string, options?: MaskOptions): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaskPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MaskPipe, "mask", true>;
+}
+
+/**
+ * Angular pipe that generates an array of numbers within a specified range.
+ *
+ * @example
+ * ```html
+ * <!-- Generate array from 0 to 4 -->
+ * <div *ngFor="let i of [5] | range">{{ i }}</div>
+ *
+ * <!-- Generate array from 1 to 5 -->
+ * <div *ngFor="let i of [1, 5] | range">{{ i }}</div>
+ *
+ * <!-- Generate array from 0 to 10 with step 2 -->
+ * <div *ngFor="let i of [0, 10, 2] | range">{{ i }}</div>
+ * ```
+ */
+declare class RangePipe implements PipeTransform {
+    /**
+     * Transforms the input value into an array of numbers.
+     *
+     * @param value - An array containing:
+     *   - `[number]`: The end value (starts from 0)
+     *   - `[number, number]`: The start and end values
+     *   - `[number, number, number]`: The start, end, and step values
+     *   - `[number, number, number, boolean]`: The start, end, step, and inclusive flag
+     * @returns An array of numbers within the specified range
+     */
+    transform(value: [number]): number[];
+    transform(value: [number, number]): number[];
+    transform(value: [number, number, number]): number[];
+    transform(value: [number, number, number, boolean]): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangePipe, "range", true>;
+}
+
+type ObservableSignalInput$1<T> = ObservableInput<T> | Signal<T>;
+type ObservableSignalInputTuple$1<T> = {
+    [K in keyof T]: ObservableSignalInput$1<T[K]> | (() => T[K]);
+};
+type CombineFromOptions<IValue> = {
+    readonly injector?: Injector;
+    readonly initialValue?: IValue;
+};
+declare function combineFrom<Input extends readonly unknown[], Output = Input>(sources: readonly [...ObservableSignalInputTuple$1<Input>]): Signal<Output>;
+declare function combineFrom<Input extends readonly unknown[], Output = Input>(sources: readonly [...ObservableSignalInputTuple$1<Input>], operator?: OperatorFunction<Input, Output>, options?: CombineFromOptions<undefined>): Signal<Output | undefined>;
+declare function combineFrom<Input extends readonly unknown[], Output = Input>(sources: readonly [...ObservableSignalInputTuple$1<Input>], operator?: OperatorFunction<Input, Output>, options?: CombineFromOptions<null>): Signal<Output | null>;
+declare function combineFrom<Input extends readonly unknown[], Output = Input>(sources: readonly [...ObservableSignalInputTuple$1<Input>], operator?: OperatorFunction<Input, Output>, options?: CombineFromOptions<Output>): Signal<Output>;
+declare function combineFrom<Input extends readonly unknown[], Output = Input>(sources: readonly [...ObservableSignalInputTuple$1<Input>], options?: CombineFromOptions<undefined>): Signal<Output | undefined>;
+declare function combineFrom<Input extends readonly unknown[], Output = Input>(sources: readonly [...ObservableSignalInputTuple$1<Input>], options?: CombineFromOptions<null>): Signal<Output | null>;
+declare function combineFrom<Input extends readonly unknown[], Output = Input>(sources: readonly [...ObservableSignalInputTuple$1<Input>], options?: CombineFromOptions<Output>): Signal<Output>;
+declare function combineFrom<Input extends object, Output = Input>(sources: ObservableSignalInputTuple$1<Input>): Signal<Output>;
+declare function combineFrom<Input extends object, Output = Input>(sources: ObservableSignalInputTuple$1<Input>, operator?: OperatorFunction<Input, Output>, options?: CombineFromOptions<undefined>): Signal<Output | undefined>;
+declare function combineFrom<Input extends object, Output = Input>(sources: ObservableSignalInputTuple$1<Input>, operator?: OperatorFunction<Input, Output>, options?: CombineFromOptions<null>): Signal<Output | null>;
+declare function combineFrom<Input extends object, Output = Input>(sources: ObservableSignalInputTuple$1<Input>, operator?: OperatorFunction<Input, Output>, options?: CombineFromOptions<Output>): Signal<Output>;
+declare function combineFrom<Input extends object, Output = Input>(sources: ObservableSignalInputTuple$1<Input>, options?: CombineFromOptions<undefined>): Signal<Output | undefined>;
+declare function combineFrom<Input extends object, Output = Input>(sources: ObservableSignalInputTuple$1<Input>, options?: CombineFromOptions<null>): Signal<Output | null>;
+declare function combineFrom<Input extends object, Output = Input>(sources: ObservableSignalInputTuple$1<Input>, options?: CombineFromOptions<Output>): Signal<Output>;
+
+/**
+ * Behavior mode for handling multiple async sources in computedAsync.
+ * - `switch`: Cancel previous async operations when a new one starts (default)
+ * - `merge`: Process all async operations concurrently
+ * - `concat`: Process async operations sequentially
+ * - `exhaust`: Ignore new async operations while one is in progress
+ */
+type ComputedAsyncBehavior = 'switch' | 'merge' | 'concat' | 'exhaust';
+type BaseOptions<T> = CreateComputedOptions<T> & {
+    behavior?: ComputedAsyncBehavior;
+};
+type OptionsWithInitialValue<T> = {
+    initialValue: T;
+} & BaseOptions<T>;
+type OptionsWithOptionalInitialValue<T> = {
+    initialValue?: undefined;
+} & BaseOptions<T>;
+type OptionsWithRequireSync<T> = {
+    requireSync: true;
+} & BaseOptions<T>;
+/**
+ * Creates a computed signal that can derive its value from asynchronous sources
+ * (Observables, Promises) or synchronous values. The signal automatically updates
+ * when dependencies change.
+ *
+ * This function extends Angular's `computed()` to support async operations. It handles:
+ * - Observables: Automatically subscribes and unsubscribes
+ * - Promises: Converts to Observable and handles resolution
+ * - Synchronous values: Returns immediately
+ *
+ * The function supports different behaviors for handling multiple async operations:
+ * - `switch`: Cancel previous operations when a new one starts (default)
+ * - `merge`: Process all operations concurrently
+ * - `concat`: Process operations sequentially
+ * - `exhaust`: Ignore new operations while one is in progress
+ *
+ * @template T - The type of the computed value.
+ * @param computeFn - A function that computes the value. Can return an Observable, Promise, or synchronous value.
+ *   The function receives the previous value as a parameter (if available).
+ * @param options - Optional configuration:
+ *   - `initialValue`: Initial value for the Signal
+ *   - `requireSync`: If `true`, requires the first computation to be synchronous (throws error for Promises)
+ *   - `behavior`: How to handle multiple async operations ('switch' | 'merge' | 'concat' | 'exhaust')
+ *   - `equal`: Custom equality function for signal comparison
+ * @returns A signal that emits the computed value. May be `T | undefined` if no initial value is provided.
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with Observable
+ * const userId = signal(1);
+ * const user = computedAsync(() => this.userService.getUser(userId()));
+ *
+ * // With initial value
+ * const user = computedAsync(
+ *   () => this.userService.getUser(userId()),
+ *   { initialValue: null }
+ * );
+ *
+ * // With requireSync (ensures synchronous initial value)
+ * const user = computedAsync(
+ *   () => this.userService.getUserSync(userId()),
+ *   { requireSync: true }
+ * );
+ *
+ * // With behavior option
+ * const data = computedAsync(
+ *   () => this.dataService.getData(),
+ *   { behavior: 'merge' }
+ * );
+ * ```
+ */
+declare function computedAsync<T>(computeFn: (previousValue?: T) => Observable<T> | Promise<T> | T | undefined): Signal<T | undefined>;
+declare function computedAsync<T>(computeFn: (previousValue?: T) => Observable<T> | Promise<T> | T | undefined, options: OptionsWithOptionalInitialValue<T>): Signal<T | undefined>;
+declare function computedAsync<T>(computeFn: (previousValue?: T) => Observable<T> | Promise<T> | T | undefined, options: OptionsWithInitialValue<T>): Signal<T>;
+declare function computedAsync<T>(computeFn: (previousValue?: T) => Promise<T>, options: OptionsWithOptionalInitialValue<T> & {
+    requireSync: true;
+}): never;
+declare function computedAsync<T>(computeFn: (previousValue?: T) => Observable<T> | T | undefined, options: {
+    initialValue?: undefined;
+    requireSync?: false;
+} & BaseOptions<T>): Signal<T | undefined>;
+declare function computedAsync<T>(computeFn: (previousValue?: T) => Observable<T> | T, options: OptionsWithRequireSync<T> & {
+    initialValue?: undefined | T;
+}): Signal<T>;
+
+/**
+ * Creates a trigger signal that can be used to manually trigger updates or side effects.
+ * The trigger maintains an internal counter that increments each time `next()` is called.
+ *
+ * @returns An object containing:
+ *   - `next()`: A function to trigger an update (increments the internal counter)
+ *   - `value`: A readonly signal that emits the current counter value
+ *
+ * @example
+ * ```typescript
+ * export class MyComponent {
+ *   private refreshTrigger = createTrigger();
+ *
+ *   // Use the trigger to refresh data
+ *   refreshData() {
+ *     this.refreshTrigger.next();
+ *   }
+ *
+ *   // React to trigger changes
+ *   data$ = toObservable(this.refreshTrigger.value).pipe(
+ *     switchMap(() => this.dataService.getData())
+ *   );
+ * }
+ * ```
+ */
+declare function createTrigger(): {
+    /**
+     * Triggers an update by incrementing the internal counter.
+     */
+    next: () => void;
+    /**
+     * A readonly signal that emits the current counter value.
+     */
+    value: i0.Signal<number>;
+};
+
+type ParamsTransformFn<Output> = (params: Params) => Output;
+/**
+ * The `InputOptions` interface defines options for configuring the behavior of the `injectParams` function.
+ *
+ * @template Output - The expected type of the read value.
+ */
+interface ParamsOptions<Output> {
+    /**
+     * A transformation function to convert the written value to the expected read value.
+     *
+     * @param v - The value to transform.
+     * @returns The transformed value.
+     */
+    transform?: (v: string) => Output;
+    /**
+     * The initial value to use if the parameter is not present or undefined.
+     */
+    initialValue?: Output;
+}
+/**
+ * Injects the params from the current route.
+ * If a key is provided, returns the value of that key.
+ * If a transform function is provided, returns the result of the function.
+ * Otherwise, returns the entire params object.
+ *
+ * @example
+ * const params = injectParams(); // Returns the entire params object
+ * const userId = injectParams('id'); // Returns the value of the 'id' param
+ * const userId = injectParams(p => p['id'] as string); // Returns the 'id' param using a custom transform function
+ * const userId = injectParams('id', { transform: numberAttribute, initialValue: 1 });
+ *
+ * @param keyOrParamsTransform OPTIONAL The key of the param to return, or a transform function to apply to the params object
+ */
+declare function injectParams(): Signal<Params>;
+declare function injectParams<Output>(fn: ParamsTransformFn<Output>): Signal<Output>;
+declare function injectParams(key: string): Signal<string | null>;
+declare function injectParams(key: string, options: {
+    transform: (v: string) => boolean;
+    initialValue: boolean;
+}): Signal<boolean>;
+declare function injectParams(key: string, options: {
+    transform: (v: string) => number;
+    initialValue: number;
+}): Signal<number>;
+declare function injectParams(key: string, options: {
+    transform?: (v: string) => string;
+    initialValue: string;
+}): Signal<string>;
+declare function injectParams(key: string, options: {
+    transform: (v: string) => boolean;
+    initialValue?: undefined;
+}): Signal<boolean | null>;
+declare function injectParams(key: string, options: {
+    transform: (v: string) => number;
+    initialValue?: undefined;
+}): Signal<number | null>;
+declare function injectParams(key: string, options: {
+    transform: (v: string) => string;
+    initialValue?: undefined;
+}): Signal<string | null>;
+
+type QueryParamsTransformFn<Output> = (params: Params) => Output;
+/**
+ * The `InputOptions` interface defines options for configuring the behavior of the `injectQueryParams` function.
+ *
+ * @template Output - The expected type of the read value.
+ */
+interface QueryParamsOptions<Output> {
+    /**
+     * A transformation function to convert the written value to the expected read value.
+     *
+     * @param v - The value to transform.
+     * @returns The transformed value.
+     */
+    transform?: (v: string) => Output;
+    /**
+     * The initial value to use if the query parameter is not present or undefined.
+     */
+    initialValue?: Output;
+}
+/**
+ * The `injectQueryParams` function allows you to access and manipulate query parameters from the current route.
+ *
+ * @returns A `Signal` that emits the entire query parameters object.
+ */
+declare function injectQueryParams(): Signal<Params>;
+/**
+ * The `injectQueryParams` function allows you to access and manipulate query parameters from the current route.
+ * It retrieves the value of a query parameter based on a custom transform function applied to the query parameters object.
+ *
+ * @template Output - The expected type of the read value.
+ * @param {QueryParamsTransformFn<Output>} fn - A transform function that takes the query parameters object (`params: Params`) and returns the desired value.
+ * @returns {Signal} A `Signal` that emits the transformed value based on the provided custom transform function.
+ *
+ * @example
+ * const searchValue = injectQueryParams((params) => params['search'] as string);
+ */
+declare function injectQueryParams<Output>(fn: QueryParamsTransformFn<Output>): Signal<Output>;
+/**
+ * The `injectQueryParams` function allows you to access and manipulate query parameters from the current route.
+ *
+ * @param {string} key - The name of the query parameter to retrieve.
+ * @returns {Signal} A `Signal` that emits the value of the specified query parameter, or `null` if it's not present.
+ */
+declare function injectQueryParams(key: string): Signal<string | null>;
+declare function injectQueryParams(key: string, options: {
+    transform: (v: string) => boolean;
+    initialValue: boolean;
+}): Signal<boolean>;
+declare function injectQueryParams(key: string, options: {
+    transform: (v: string) => number;
+    initialValue: number;
+}): Signal<number>;
+declare function injectQueryParams(key: string, options: {
+    transform?: (v: string) => string;
+    initialValue: string;
+}): Signal<string>;
+declare function injectQueryParams(key: string, options: {
+    transform: (v: string) => boolean;
+    initialValue?: undefined;
+}): Signal<boolean | null>;
+declare function injectQueryParams(key: string, options: {
+    transform: (v: string) => number;
+    initialValue?: undefined;
+}): Signal<number | null>;
+declare function injectQueryParams(key: string, options: {
+    transform: (v: string) => string;
+    initialValue?: undefined;
+}): Signal<string | null>;
+
+type ObservableSignalInput<T> = ObservableInput<T> | Signal<T>;
+type ObservableSignalInputTuple<T> = {
+    [K in keyof T]: ObservableSignalInput<T[K]>;
+};
+type MergeFromOptions<T> = {
+    readonly injector?: Injector;
+    readonly initialValue?: T | null;
+};
+declare function mergeFrom<Input extends readonly unknown[], Output = Input[number]>(sources: readonly [...ObservableSignalInputTuple<Input>], operator?: OperatorFunction<Input[number], Output>, options?: MergeFromOptions<Output>): Signal<Output>;
+declare function mergeFrom<Input extends readonly unknown[], Output = Input[number]>(sources: readonly [...ObservableSignalInputTuple<Input>], options?: MergeFromOptions<Output>): Signal<Output>;
+
+/**
+ * Calculates the difference in whole days between two dates.
+ *
+ * @param {Date | number | string} dateLeft - The date from which the difference is measured (the reference date).
+ *   Can be a Date object, a number representing milliseconds since the Unix epoch,
+ *   or a string in a format parseable by the Date constructor.
+ * @param {Date | number | string} dateRight - The date to be compared against the reference date.
+ *   Can be a Date object, a number representing milliseconds since the Unix epoch,
+ *   or a string in a format parseable by the Date constructor.
+ * @returns {number} The number of whole days between the reference date (dateLeft) and the compared date (dateRight).
+ *
+ * @example
+ * // How many whole days are between '2022-09-08' and '2023-09-18'?
+ * const result = differenceInDays('2022-09-08', new Date('2023-09-18'));
+ *
+ * The result is 0 if the diff is within a full day
+ * const result = differenceInDays('2022-09-08T00:00:00', new Date('2023-09-08T14:00:00'));
+ */
+declare function differenceInDays(dateLeft: Date | number | string, dateRight: Date | number | string): number;
+
+/**
+ * Provides a conditional validator that applies the specified validator functions only if the condition is met.
+ *
+ * @param condition A function that determines whether the validators should be applied.
+ * @param trueValidatorFn The validator function or an array of validator functions to be applied when the condition is true.
+ * @param falseValidatorFn Optional. The validator function or an array of validator functions to be applied when the condition is false.
+ * @returns A validator function that can be used with Angular Reactive Forms.
+ */
+declare function ifValidator(condition: (control: AbstractControl) => boolean, trueValidatorFn: ValidatorFn | ValidatorFn[], falseValidatorFn?: ValidatorFn | ValidatorFn[]): ValidatorFn;
+/**
+ * Provides a conditional async validator that applies the specified async validator function only if the condition is met.
+ *
+ * @param condition A function that determines whether the async validator should be applied.
+ * @param validatorFn The async validator function to be applied conditionally.
+ * @returns An async validator function that can be used with Angular Reactive Forms.
+ */
+declare function ifAsyncValidator(condition: (control: AbstractControl) => boolean, validatorFn: AsyncValidatorFn): AsyncValidatorFn;
+
+/**
+ * Configuration options for the idle detection service.
+ * Used to customize the idle duration and timeout duration for user inactivity detection.
+ */
+declare class IdleDetectionConfig {
+    /**
+     * The duration in seconds before the user is considered idle.
+     * After this duration, the idle detection phase ends and countdown begins.
+     * Defaults to 19 minutes (1140 seconds) if not provided.
+     */
+    idleDurationInSeconds?: number;
+    /**
+     * The duration in seconds for the countdown phase after idle detection.
+     * During this phase, the user can still interact to reset the timer.
+     * After this duration, the timeout event is emitted.
+     * Defaults to 1 minute (60 seconds) if not provided.
+     */
+    timeoutDurationInSeconds?: number;
+}
+/**
+ * Provides configuration for the idle detection service.
+ * This function should be used in the application's providers array to configure idle detection.
+ *
+ * @param config - The idle detection configuration object.
+ * @returns Environment providers for the idle detection configuration.
+ *
+ * @example
+ * ```typescript
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideIdleDetectionConfig({
+ *       idleDurationInSeconds: 15 * 60, // 15 minutes
+ *       timeoutDurationInSeconds: 60 // 1 minute
+ *     })
+ *   ]
+ * };
+ * ```
+ */
+declare function provideIdleDetectionConfig(config: IdleDetectionConfig): i0.EnvironmentProviders;
+
+/**
+ * Idle detection module.
+ * @deprecated use provideIdleDetectionConfig(config: IdleDetectionConfig) instead
+ */
+declare class IdleDetectionModule {
+    static forRoot(config: IdleDetectionConfig): ModuleWithProviders<IdleDetectionModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdleDetectionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IdleDetectionModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IdleDetectionModule>;
+}
+
+/**
+ * Service for detecting user idle time and implementing a countdown.
+ */
+declare class IdleDetectionService {
+    /**
+     * The list of interruption events that will end the idle detection.
+     */
+    private interruptionEvents;
+    private interruptionSubscription?;
+    /**
+     * The default idle duration in seconds (19 minutes).
+     */
+    private idleDuration;
+    /**
+     * The default timeout duration in seconds (1 minute).
+     */
+    private timeoutDuration;
+    /**
+     * Timer for idle detection.
+     */
+    private idleTimer?;
+    /**
+     * Timer for countdown.
+     */
+    private countdownTimer?;
+    /**
+     * Flag to indicate if countdown is in progress.
+     */
+    private isCountingDown;
+    /**
+     * The current countdown value.
+     */
+    private countdown;
+    /**
+     * Subject to emit when idle period ends.
+     */
+    private idleEndSubject;
+    /**
+     * Subject to emit the countdown value.
+     */
+    private countdownSubject;
+    /**
+     * Subject to emit when countdown ends.
+     */
+    private countdownEndSubject;
+    /**
+     * Constructs the IdleDetectionService.
+     * @param config - Optional configuration for idle and timeout durations.
+     */
+    constructor();
+    /**
+     * Starts to watch for user inactivity.
+     */
+    startWatching(): void;
+    /**
+     * Resets the idle timer when user activity is detected.
+     * @param withCountdownReset - Flag to indicate if countdown should be reset.
+     * By default, it only reset the idle-detection timer. If you enter the countdown phase, it won't stop the countdown.
+     * Pass true when you want to reset the countdown as well. This is useful when you click "Keep Me Signed In" button in cll-idle-detection component
+     */
+    resetTimer(withCountdownReset?: boolean): void;
+    /**
+     * Sets up the interruption events that will end the idle detection.
+     * Listens to a set of events on the document (e.g. click, keydown, mousemove, etc.).
+     * When any of these events is triggered, the idle timer is reset.
+     * Uses `throttleTime` operator to only trigger the reset when the events are spaced
+     * out by at least 1000ms (1 second).
+     * @private
+     */
+    private setupInterruptionEvents;
+    /**
+     * Starts the idle timer.
+     * When the timer expires, it emits an event through onIdleEnd() and starts the countdown.
+     */
+    private startIdleTimer;
+    /**
+     * Starts the countdown.
+     */
+    private startCountdown;
+    /**
+     * Stops the countdown.
+     */
+    private stopCountdown;
+    /**
+     * Returns an observable that emits when the user has been idle for a long period.
+     * Developers can use this to perform actions like opening a dialog.
+     *
+     * user has been inactive for a long period (idleDuration), at this moment, idle detection phase ends, onIdleEnd event is emitted, and then enter countdown/timeout phase.
+     * During the countdown phase:
+     *  - if user has any activity, countdown phase immediately ends and restart the idle detection phase.
+     *  - else, countdownEnd event will be emitted when timeoutDuration is over.
+     * @returns {Observable<void>} - Observable for idle end event.
+     */
+    onIdleEnd(): rxjs.Observable<void>;
+    /**
+     * Returns an observable that emits when the countdown ends.
+     * Usually means the user has been inactive for a very long time and should be logged out.
+     * @returns {Observable<void>} - Observable for countdown end event.
+     */
+    onTimeoutEnd(): rxjs.Observable<void>;
+    /**
+     * Returns an observable that emits the countdown value every second.
+     * @returns {Observable<number>} - Observable for countdown value.
+     */
+    onCountDown(): rxjs.Observable<number>;
+    /**
+     * Clears all timers when the component is destroyed.
+     */
+    clearTimers(): void;
+    /**
+     * Sets the idle and timeout durations based on the provided configuration.
+     * @param config - Configuration object with idle and timeout durations.
+     */
+    setConfig(config: IdleDetectionConfig): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdleDetectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdleDetectionService>;
+}
+
+/**
+ * Type guard that checks if a string value is empty.
+ *
+ * @param value - The string value to check.
+ * @returns `true` if the value is an empty string, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isEmpty(''); // true
+ * isEmpty('text'); // false
+ * ```
+ */
+declare function isEmpty(value: string): value is '';
+/**
+ * Check if a value is null, undefined, empty ArrayLike, Map, Set or empty object.
+ * @param value The value to check.
+ * @returns Whether the value is null, undefined, empty ArrayLike, Map, Set or empty object.
+ */
+declare function isEmpty<T extends object | ArrayLike<any> | Map<any, any> | Set<any>>(value: T | null | undefined): value is null | undefined;
+/**
+ * Type guard that checks if a string value is not empty.
+ *
+ * @param value - The string value to check.
+ * @returns `false` if the value is an empty string, `true` otherwise.
+ */
+declare function isNotEmpty(value: ''): false;
+/**
+ * Type guard that checks if a string value is not empty.
+ *
+ * @param value - The string value to check.
+ * @returns `true` if the value is a non-empty string, `false` otherwise.
+ */
+declare function isNotEmpty(value: string): value is Exclude<string, ''>;
+/**
+ * Type guard that checks if a value is not empty (not null, undefined, or empty collection).
+ *
+ * @param value - The value to check.
+ * @returns `true` if the value is not null, undefined, or empty, `false` otherwise.
+ */
+declare function isNotEmpty<T extends object | ArrayLike<any> | Map<any, any> | Set<any>>(value: T | null | undefined): value is T;
+
+/**
+ * Check if two values are deeply equal.
+ * @param {T} value1 - The first value to compare.
+ * @param {T} value2 - The second value to compare.
+ * @returns {boolean} - Returns true if the values are deeply equal, otherwise false.
+ */
+declare function isEqual<T>(value1: T, value2: T): boolean;
+
+/**
+ * Create an object composed of object properties that do not satisfy a given condition.
+ * @param {T} source - The object to omit properties from.
+ * @param {(value: T[keyof T], key: string) => boolean} predicate - The function invoked per property.
+ * @returns {Partial<T>} - Returns the new object.
+ */
+declare function omitBy<T>(source: T, predicate: (value: T[keyof T], key: string) => boolean): Partial<T>;
+
+/**
+ * Create an object composed of object properties that satisfy a given condition.
+ * @param {T} source - The object to pick properties from.
+ * @param {(value: T[keyof T], key: string) => boolean} predicate - The function invoked per property.
+ * @returns {Partial<T>} - Returns the new object.
+ */
+declare function pickBy<T>(source: T, predicate: (value: T[keyof T], key: string) => boolean): Partial<T>;
+
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.
+ * A step of -1 is used if a negative start is specified without an end or step.
+ * If end is not specified, it's set to start with start then set to 0.
+ *
+ * @param {number} start The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} step The value to increment or decrement by.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Array} Returns the range of numbers.
+ */
+declare function range(start: number, end?: number | undefined, step?: number | undefined, fromRight?: boolean): any[];
+
+/**
+ * Checks if a hostname is a valid IP address (IPv4 or IPv6).
+ *
+ * @param hostname - The hostname to check. Should be extracted from `new URL(url).hostname`
+ * @returns `true` if the hostname is a valid IP address, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * const url = new URL('http://192.168.1.1');
+ * isIP(url.hostname); // true
+ *
+ * const url2 = new URL('http://example.com');
+ * isIP(url2.hostname); // false
+ * ```
+ */
+declare function isIP(hostname: string): boolean;
+/**
+ * Checks if a hostname is a valid Fully Qualified Domain Name (FQDN).
+ *
+ * @param hostname - The hostname to check. Should be extracted from `new URL(url).hostname`
+ * @returns `true` if the hostname is a valid FQDN, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * const url = new URL('http://example.com');
+ * isFQDN(url.hostname); // true
+ *
+ * const url2 = new URL('http://192.168.1.1');
+ * isFQDN(url2.hostname); // false
+ * ```
+ */
+declare function isFQDN(hostname: string): boolean;
+/**
+ * Checks if a string is a valid URL.
+ *
+ * @param url - The URL string to validate
+ * @returns `true` if the string is a valid URL, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isURL('https://example.com'); // true
+ * isURL('not-a-url'); // false
+ * ```
+ */
+declare function isURL(url: string): boolean;
+/**
+ * Checks if a URL string uses the HTTPS protocol.
+ * The URL must be a valid URL format.
+ *
+ * @param url - The URL string to check
+ * @returns `true` if the URL is valid and uses HTTPS protocol, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * isHttps('https://example.com'); // true
+ * isHttps('http://example.com'); // false
+ * ```
+ */
+declare function isHttps(url: string): boolean;
+
+/**
+ * Interface defining the options for the date range validator.
+ */
+interface DateRangeOptions {
+    /**
+     * The minimum allowed date. The control value must be greater than (or equal to, if `minInclusive` is true) this date.
+     * Can be a Date object or a string that can be parsed by the Date constructor.
+     */
+    minDate?: Date | string;
+    /**
+     * The maximum allowed date. The control value must be less than (or equal to, if `maxInclusive` is true) this date.
+     * Can be a Date object or a string that can be parsed by the Date constructor.
+     */
+    maxDate?: Date | string;
+    /**
+     * Whether the comparison for the minimum date can include the exact date.
+     * If `true`, the control value can be equal to `minDate`.
+     * If `false` (default), the control value must be strictly greater than `minDate`.
+     */
+    minInclusive?: boolean;
+    /**
+     * Whether the comparison for the maximum date can include the exact date.
+     * If `true`, the control value can be equal to `maxDate`.
+     * If `false` (default), the control value must be strictly less than `maxDate`.
+     */
+    maxInclusive?: boolean;
+    /**
+     * Whether to compare the time components as well.
+     * If `true`, comparisons will include Date time components (hours, minutes, seconds, milliseconds).
+     * If `false` (default), time parts will be ignored and only the date portion will be compared.
+     */
+    compareTime?: boolean;
+}
+/**
+ * Creates a validator function that validates a date against a specified date range.
+ *
+ * The validator checks if the form control's date value falls within the specified range.
+ * It supports:
+ * - Minimum and maximum date constraints
+ * - Inclusive or exclusive boundary comparisons
+ * - Time-aware or date-only comparisons
+ *
+ * @param options - The options for the date range validation.
+ * @returns A validator function that validates a FormControl and returns an error object if the date is out of range,
+ *   or `null` if the date is valid. Error objects contain:
+ *   - `minDate`: ISO string of the minimum date (if value is too early)
+ *   - `maxDate`: ISO string of the maximum date (if value is too late)
+ *   - `invalidDate`: `true` (if the value cannot be parsed as a date)
+ *
+ * @example
+ * ```typescript
+ * // Date range with inclusive boundaries
+ * const form = new FormGroup({
+ *   startDate: new FormControl('', [
+ *     dateRangeValidator({
+ *       minDate: new Date('2024-01-01'),
+ *       maxDate: new Date('2024-12-31'),
+ *       minInclusive: true,
+ *       maxInclusive: true
+ *     })
+ *   ])
+ * });
+ *
+ * // Date-only comparison (ignores time)
+ * const form = new FormGroup({
+ *   appointment: new FormControl('', [
+ *     dateRangeValidator({
+ *       minDate: '2024-01-01',
+ *       compareTime: false
+ *     })
+ *   ])
+ * });
+ * ```
+ */
+declare function dateRangeValidator(options: DateRangeOptions): ValidatorFn;
+
+/**
+ * Creates a validator function that checks for intersection between two form controls within a FormGroup.
+ * Both controls' values must be arrays. The validator sets an error on both controls if they have any common values.
+ *
+ * This is useful for scenarios where you need to ensure two arrays don't share any elements,
+ * such as preventing duplicate selections in multi-select scenarios.
+ *
+ * @template T - The type of elements in the arrays (defaults to `string`).
+ * @param controlName1 - The name of the first form control in the FormGroup.
+ * @param controlName2 - The name of the second form control in the FormGroup.
+ * @returns A validator function that validates the FormGroup and returns an error object with `intersection: true`
+ *   if there is an intersection between the two arrays, or `null` if there is no intersection.
+ *
+ * @example
+ * ```typescript
+ * const form = new FormGroup({
+ *   selectedUsers: new FormControl(['user1', 'user2']),
+ *   excludedUsers: new FormControl(['user3', 'user4']),
+ * }, {
+ *   validators: [intersectionValidator('selectedUsers', 'excludedUsers')]
+ * });
+ *
+ * // If selectedUsers contains 'user1' and excludedUsers also contains 'user1',
+ * // both controls will have an error: { intersection: true }
+ * ```
+ */
+declare function intersectionValidator<T = string>(controlName1: string, controlName2: string): ValidatorFn;
+
+/**
+ * Validator for checking uniqueness across multiple fields in a FormArray or FormGroup.
+ *
+ * This validator can be applied to a FormArray or FormGroup containing the controls to be validated.
+ * It ensures that each control's value is unique among all other controls within the array or group.
+ *
+ * When duplicate values are found, the validator sets a `notUnique` error on all affected controls.
+ * The error is automatically removed when the value becomes unique again.
+ *
+ * @example
+ * ```typescript
+ * // FormArray with unique values
+ * const formArray = new FormArray([
+ *   new FormControl('value1'),
+ *   new FormControl('value2'),
+ *   new FormControl('value1') // This will have notUnique error
+ * ], [UniqueValidator.unique()]);
+ *
+ * // FormArray with custom key selector
+ * const formArray = new FormArray([
+ *   new FormGroup({
+ *     id: new FormControl(1),
+ *     name: new FormControl('Item 1')
+ *   }),
+ *   new FormGroup({
+ *     id: new FormControl(2),
+ *     name: new FormControl('Item 2')
+ *   })
+ * ], [UniqueValidator.unique(control => control.get('id'))]);
+ * ```
+ */
+declare class UniqueValidator {
+    /**
+     * Creates a validator function that checks for uniqueness of values across controls in a FormArray or FormGroup.
+     *
+     * The validator:
+     * - Compares values using the provided key selector function
+     * - Sets `notUnique` error on controls with duplicate values
+     * - Automatically removes errors when values become unique
+     * - Ignores null, undefined, empty strings, and 'NaN' values
+     *
+     * @template T - The type of the control value.
+     * @param keySelector - A function to select the key control for comparison.
+     *   Defaults to the control itself if not provided.
+     *   This is useful when validating FormGroups where you want to check uniqueness of a specific field.
+     * @returns A validator function that can be attached to a FormArray or FormGroup.
+     */
+    static unique<T>(keySelector?: (control: AbstractControl) => AbstractControl<T>): ValidatorFn;
+}
+
+/**
+ * Validator function that checks if a form control value is a valid URL.
+ *
+ * @param control - The form control to validate
+ * @returns `null` if the value is a valid URL, or an error object with `invalidUrl: true` if invalid
+ *
+ * @example
+ * ```typescript
+ * const form = new FormGroup({
+ *   website: new FormControl('', urlValidator)
+ * });
+ * ```
+ */
+declare function urlValidator(control: AbstractControl): ValidationErrors | null;
+/**
+ * Validator function that checks if a form control value is a valid HTTPS URL.
+ *
+ * @param control - The form control to validate
+ * @returns `null` if the value is a valid HTTPS URL, or an error object with `invalidUrl: true` if invalid
+ *
+ * @example
+ * ```typescript
+ * const form = new FormGroup({
+ *   secureUrl: new FormControl('', httpsValidator)
+ * });
+ * ```
+ */
+declare function httpsValidator(control: AbstractControl): ValidationErrors | null;
+
+export { ArrayJoinPipe, ByteConverterPipe, IdleDetectionConfig, IdleDetectionModule, IdleDetectionService, IsHttpsPipe, MaskPipe, RangePipe, UniqueValidator, aggregatePaginatedKubernetesResources, combineFrom, combineLatestEager, computedAsync, createAsyncState, createTrigger, dateRangeValidator, differenceInDays, distinctOnChange, fetchPaginatedKubernetesResources, httpsValidator, ifAsyncValidator, ifValidator, injectParams, injectQueryParams, intersectionValidator, isEmpty, isEqual, isFQDN, isHttps, isIP, isNotEmpty, isURL, logger, mergeFrom, omitBy, pickBy, poll, provideIdleDetectionConfig, range, startWithTap, switchMapWithAsyncState, urlValidator };
+export type { AsyncState, CombineFromOptions, KubernetesList, KubernetesObject, KubernetesObjectCondition, KubernetesObjectMetaV1, MaskOptions, MergeFromOptions, ParamsOptions, QueryParamsOptions };