@odx/angular 6.0.0 → 6.1.0

package/utils/lib/helpers/get-axis.d.ts

@@ -1,2 +1,22 @@
 import { Axis, Position } from '../types';
+/**
+ * Determines the axis associated with a given position. The function first extracts the side from the position,
+ * then evaluates whether that side corresponds to the X-axis (left or right) or the Y-axis (top or bottom).
+ *
+ * @param {Position} position - The position string, which includes a side (top, bottom, left, right) and possibly an alignment.
+ * @returns {Axis} The axis (X or Y) associated with the given position's side.
+ *
+ * @example
+ * ```ts
+ * // Determining the axis for different positions
+ * console.log(getAxis('top-left')); // Outputs: 'Y'
+ * console.log(getAxis('right'));    // Outputs: 'X'
+ *
+ * // Using getAxis in UI element positioning logic
+ * const elementPosition = 'bottom';
+ * const axis = getAxis(elementPosition);
+ * // Assuming a function that adjusts UI elements based on the axis
+ * adjustElementAlongAxis(axis);
+ * ```
+ */
 export declare function getAxis(position: Position): Axis;

package/utils/lib/helpers/get-language-code.d.ts

@@ -1 +1,18 @@
+/**
+ * Extracts the language code from a language string that may include both a language and a region code.
+ * The function supports language strings formatted with either a hyphen (`-`) or an underscore (`_`) as the separator.
+ *
+ * @param {string} language - The complete language string, potentially including both language and region codes.
+ * @returns {string} The extracted language code, converted to lower case.
+ *
+ * @example
+ * ```ts
+ * // Extracting language code from a language-region string
+ * console.log(getLanguageCode('en-US')); // Outputs: 'en'
+ * console.log(getLanguageCode('zh_CN')); // Outputs: 'zh'
+ *
+ * // Handling language codes without region codes
+ * console.log(getLanguageCode('fr'));    // Outputs: 'fr'
+ * ```
+ */
 export declare function getLanguageCode(language: string): string;

package/utils/lib/helpers/get-opposite-side.d.ts

@@ -1,2 +1,23 @@
 import { Position, Side } from '../types';
+/**
+ * Determines the opposite side for a given position. This function is useful for scenarios
+ * where you need to dynamically calculate the positioning or alignment opposite to the current one,
+ * such as inverting tooltips, popovers, or any UI elements that adjust based on available viewport space.
+ *
+ * @param {Position} position - The position string, which includes a side and possibly an alignment.
+ * @returns {Side} The opposite side relative to the provided position's side.
+ *
+ * @example
+ * ```ts
+ * // Getting the opposite side of a given position
+ * console.log(getOppositeSide('top-left')); // Outputs: 'bottom'
+ * console.log(getOppositeSide('right'));    // Outputs: 'left'
+ *
+ * // Using getOppositeSide to adjust UI elements
+ * const currentSide = 'left';
+ * const newPosition = getOppositeSide(currentSide);
+ * // Assuming an element's position or orientation needs to be dynamically updated
+ * updateElementPosition(newPosition);
+ * ```
+ */
 export declare function getOppositeSide(position: Position): Side;

package/utils/lib/helpers/get-side.d.ts

@@ -1,2 +1,19 @@
 import { Position, Side } from '../types';
+/**
+ * Extracts the side part from a position string. The position format generally combines
+ * a side (e.g., "top", "bottom", "left", "right") with an optional alignment
+ * (e.g., "left", "center", "right" for vertical positions or "top", "middle", "bottom" for horizontal positions).
+ *
+ * @param {Position} position - The position string from which to extract the side.
+ * @returns {Side} The side part of the position, indicating the general placement direction.
+ *
+ * @example
+ * ```ts
+ * // Extracting the side from a position with alignment
+ * console.log(getSide('top-left')); // Outputs: 'top'
+ *
+ * // Extracting the side from a simple position
+ * console.log(getSide('bottom')); // Outputs: 'bottom'
+ * ```
+ */
 export declare function getSide(position: Position): Side;

package/utils/lib/helpers/get-unique-id.d.ts

@@ -1,2 +1,35 @@
+/**
+ * Generates a unique identifier for a given key. If the key has previously been used,
+ * the function increments a counter associated with that key to ensure uniqueness.
+ * The generated ID is in the format of `${key}-${counter}`.
+ *
+ * @param {string} key - The key for which to generate a unique identifier.
+ * @returns {string} A unique identifier string based on the provided key.
+ *
+ * @example
+ * ```ts
+ * const id1 = getUniqueId('component');
+ * console.log(id1); // Outputs: "component-1"
+ *
+ * const id2 = getUniqueId('component');
+ * console.log(id2); // Outputs: "component-2"
+ * ```
+ */
 export declare function getUniqueId(key: string): string;
+/**
+ * Clears the cache used by `getUniqueId` to generate unique identifiers. This function
+ * resets all counters associated with each key, effectively restarting the generation
+ * of unique IDs from their initial state.
+ *
+ * This can be useful in scenarios such as testing or when starting a new session that
+ * requires resetting the state of unique ID generation.
+ *
+ * @example
+ * ```ts
+ * getUniqueId('component'); // Returns "component-1"
+ * getUniqueId('component'); // Returns "component-2"
+ * clearUniqueIdCache();
+ * getUniqueId('component'); // Returns "component-1" after cache reset
+ * ```
+ */
 export declare function clearUniqueIdCache(): void;

package/utils/lib/helpers/match-url.d.ts

@@ -1,2 +1,42 @@
+/**
+ * Checks if a given value is a valid URL matcher, which can be either a string or a regular expression.
+ * This function serves as a type guard to facilitate URL matching operations by verifying the type of the filter.
+ *
+ * @param {unknown} value - The value to check for being a valid URL matcher.
+ * @returns {value is string | RegExp} `true` if the value is a string or RegExp, indicating it can be used for URL matching; otherwise, `false`.
+ *
+ * @example
+ * ```ts
+ * // Checking a string URL matcher
+ * console.log(isUrlMatcher('https://example.com')); // true
+ *
+ * // Checking a RegExp URL matcher
+ * console.log(isUrlMatcher(/https:\/\/example\.com/)); // true
+ *
+ * // Checking a non-matcher value
+ * console.log(isUrlMatcher(123)); // false
+ * ```
+ */
 export declare function isUrlMatcher(value: unknown): value is string | RegExp;
+/**
+ * Determines if a given URL matches a specified filter, which can be either a string or a regular expression.
+ * For string filters, the function checks if the URL starts with the filter value. For RegExp filters,
+ * it checks if the URL matches the regular expression pattern.
+ *
+ * @param {string} url - The URL to be checked against the filter.
+ * @param {string | RegExp} filter - The filter used to match the URL, which can be a prefix string or a RegExp pattern.
+ * @returns {boolean} `true` if the URL matches the filter; otherwise, `false`.
+ *
+ * @example
+ * ```ts
+ * // Matching a URL with a string filter
+ * console.log(matchUrl('https://example.com/page', 'https://example.com')); // true
+ *
+ * // Matching a URL with a RegExp filter
+ * console.log(matchUrl('https://example.com/page', /example\.com\/page/)); // true
+ *
+ * // A non-matching example
+ * console.log(matchUrl('https://example.com/page', 'https://another.com')); // false
+ * ```
+ */
 export declare function matchUrl(url: string, filter: string | RegExp): boolean;

package/utils/lib/helpers/ng-changes.d.ts

@@ -1,4 +1,27 @@
 import { GetProperties } from '../types';
+/**
+ * Represents a typed version of Angular's `SimpleChanges` object, describing the changes to each
+ * property of a component or directive. This utility enhances type safety when working with Angular's
+ * change detection mechanism by providing specific property types.
+ *
+ * @template C - The component or directive class.
+ * @template Properties - The properties of the component or directive, inferred from `C` by default.
+ * @type {Object} - A mapping from property names to change information for each property.
+ *
+ * @example
+ * ```ts
+ * interface MyComponent {
+ *   name: string;
+ *   age: number;
+ * }
+ *
+ * function ngOnChanges(changes: NgChanges<MyComponent>) {
+ *   if (changes.name) {
+ *     console.log('Name changed from', changes.name.previousValue, 'to', changes.name.currentValue);
+ *   }
+ * }
+ * ```
+ */
 export type NgChanges<C, Properties = GetProperties<C>> = {
     [Key in keyof Properties]: {
         previousValue: Properties[Key];
@@ -7,4 +30,33 @@ export type NgChanges<C, Properties = GetProperties<C>> = {
         isFirstChange(): boolean;
     };
 };
+/**
+ * Checks if the specified property or properties have changed in the current change detection cycle.
+ * Optionally ignores changes that occur during the first change detection cycle (e.g., initialization).
+ *
+ * @template U - The component or directive class.
+ * @template T - The type representing the changes, typically `NgChanges<U>`.
+ * @template K - The key or keys representing the properties to check for changes.
+ * @param {T} changes - The `NgChanges` object containing information about all changes.
+ * @param {K | K[]} keyOrKeys - The property name(s) to check for changes.
+ * @param {boolean} [ignoreFirstChange=true] - Whether to ignore changes that occur during the first change detection cycle.
+ * @returns {boolean} `true` if the specified property or properties have changed, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * // Example usage within an Angular component's `ngOnChanges` method
+ * ngOnChanges(changes: NgChanges<MyComponent>): void {
+ *   if (hasChanged(changes, 'name')) {
+ *     console.log('Name has changed');
+ *   }
+ * }
+ *
+ * // Checking multiple properties for changes
+ * ngOnChanges(changes: NgChanges<MyComponent>): void {
+ *   if (hasChanged(changes, ['name', 'age'], false)) {
+ *     console.log('Name or age has changed (including first change)');
+ *   }
+ * }
+ * ```
+ */
 export declare function hasChanged<U extends Record<string, unknown>, T extends NgChanges<U>, K extends keyof T>(changes: T, keyOrKeys: K | K[], ignoreFirstChange?: boolean): boolean;

package/utils/lib/helpers/provide-config.d.ts

@@ -8,6 +8,62 @@ interface ConfigFactoryProvider<T, D extends ConfigDependencies> {
 export type ConfigDependencies<T = unknown> = ReadonlyArray<Type<T> | InjectionToken<T>>;
 export type ConfigProvider<T = unknown, D extends ConfigDependencies = []> = ConfigFactoryProvider<T, D> | T;
 export type ConfigTransformFn<T = unknown> = (config: Partial<T>) => Partial<T>;
+/**
+ * Provides a configuration object or a factory for creating the configuration object, optionally applying a transformation function.
+ * This utility simplifies the process of defining and injecting configuration objects throughout an Angular application.
+ *
+ * @template T - The type of the configuration object.
+ * @template D - The dependencies required by the configuration factory, if any.
+ * @param {InjectionToken<T> | string} token - The injection token or string token associated with the configuration.
+ * @param {ConfigProvider<T, D>} config - The configuration object or a factory provider that produces the configuration.
+ * @param {ConfigTransformFn<T>} [transform=() => ({}))] - An optional transformation function to apply to the configuration object.
+ * @returns {FactoryProvider | ValueProvider} - An Angular provider object for the given configuration.
+ *
+ * @example
+ * ```ts
+ * // Define a simple configuration object
+ * const appConfig = { apiEndpoint: 'https://api.example.com' };
+ *
+ * // Provide the configuration with an optional transformation function
+ * provideConfig(appConfigToken, appConfig, (config) => ({
+ *   ...config,
+ *   apiEndpoint: `${config.apiEndpoint}/v2`,
+ * }));
+ *
+ * // Using a factory provider for dynamic configuration
+ * provideConfig(appConfigToken, {
+ *   useFactory: (envService) => ({ apiEndpoint: envService.getApiEndpoint() }),
+ *   deps: [EnvironmentService],
+ * });
+ * ```
+ */
 export declare function provideConfig<T extends object, D extends ConfigDependencies = ConfigDependencies>(token: InjectionToken<T> | string, config: ConfigProvider<T, D>, transform?: ConfigTransformFn<T>): FactoryProvider | ValueProvider;
+/**
+ * Generates a set of configuration-related tokens and utility functions for managing configuration in an Angular application.
+ * This function creates a standardized way to define, provide, and inject configurations, including defaults and transformations.
+ *
+ * @template T - The type of the configuration object.
+ * @template N - The name of the configuration, used to generate token names and utility functions.
+ * @param {N} name - The name of the configuration.
+ * @param {string} prefix - A prefix for the injection token to ensure uniqueness across the application.
+ * @param {T} defaultValue - The default value for the configuration.
+ * @param {ConfigTransformFn<T>} [transform] - An optional transformation function to be applied to the configuration.
+ * @returns An object containing the generated injection token, default configuration, and utility functions for the configuration.
+ *
+ * @example
+ * ```ts
+ * // Create configuration tokens and utilities for "appConfig" with a default value and optional transform function
+ * const { appConfigConfig, provideAppConfigConfig } = createConfigTokens('appConfig', 'myPrefix', { debug: false }, (config) => ({
+ *   ...config,
+ *   debug: true, // Enable debug mode by default
+ * }));
+ *
+ * // Later, in a module or component, provide the customized configuration
+ * @NgModule({
+ *   providers: [provideAppConfigConfig({ apiEndpoint: 'https://api.example.com' })]
+ * })
+ * class AppModule {}
+ * ```
+ */
 export declare function createConfigTokens<T, N extends string>(name: N, prefix: string, defaultValue: T, transform?: ConfigTransformFn<T>): Record<`${N}Config`, InjectionToken<Partial<T>>> & Record<`${N}DefaultConfig`, T> & Record<`inject${N}Config`, () => T> & Record<`provide${N}Config`, <D extends ConfigDependencies<unknown> = ConfigDependencies<Partial<T>>>(config: ConfigProvider<Partial<T>, D>) => FactoryProvider | ValueProvider>;
 export {};

package/utils/lib/helpers/queue.d.ts

@@ -3,26 +3,109 @@ type QueueItemId = string | number;
 type QueueItem<T> = T & {
     id: QueueItemId;
 };
+/**
+ * A class representing a queue structure with advanced functionalities including adding, removing,
+ * updating items, and observing changes through RxJS observables. It supports generic queue item types,
+ * allowing for flexible usage across different contexts.
+ *
+ * @template T - The type of items stored in the queue. Each item must extend an object containing a unique `id`.
+ */
 export declare class Queue<T> {
     private readonly queue;
     private readonly events$$;
     private values;
     private firstItem;
     private lastItem;
+    /**
+     * An observable that emits when an item is added to the queue.
+     * @type {Observable<T>}
+     */
     readonly onAdd$: Observable<T>;
+    /**
+     * An observable that emits when an item in the queue is updated.
+     * @type {Observable<T>}
+     */
     readonly onUpdate$: Observable<T>;
+    /**
+     * An observable that emits when an item is removed from the queue.
+     * @type {Observable<T>}
+     */
     readonly onRemove$: Observable<T>;
+    /**
+     * An observable representing the current state of the queue as an array of items.
+     * @type {Observable<QueueItem<T>[]>}
+     */
     readonly value$: Observable<QueueItem<T>[]>;
+    /**
+     * An observable that emits the current size of the queue.
+     * @type {Observable<number>}
+     */
     readonly size$: Observable<number>;
+    /**
+     * Gets the size of the queue.
+     * @returns The number of elements in the queue.
+     */
     get size(): number;
+    /**
+     * Checks if the specified item is the first item in the queue.
+     * @param {QueueItem<T>} item - The item to check.
+     * @returns {boolean} - Returns `true` if the item is the first item in the queue, `false` otherwise.
+     */
     isFirst({ id }: QueueItem<T>): boolean;
+    /**
+     * Checks if the specified item is the last item in the queue.
+     * @param {QueueItem<T>} item - The item to check.
+     * @returns {boolean} - Returns true if the item is the last item, otherwise returns false.
+     */
     isLast({ id }: QueueItem<T>): boolean;
+    /**
+     * Retrieves a queue item from the queue based on the provided item or item ID.
+     * @param itemOrId - The queue item or item ID to retrieve.
+     * @returns The queue item if found, or `null` if not found.
+     */
     get(itemOrId: QueueItem<T> | QueueItemId): QueueItem<T> | null;
+    /**
+     * Adds an item to the queue, optionally emitting an event.
+     *
+     * @param {QueueItem<T>} item - The item to add.
+     * @param {boolean} [emitEvent=true] - Whether to emit an event for this action.
+     * @returns {QueueItem<T>} The item added to the queue.
+     */
     add(item: QueueItem<T>, emitEvent?: boolean): QueueItem<T>;
+    /**
+     * Adds multiple items to the queue.
+     *
+     * @param items - An array of items to be added to the queue.
+     * @param emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.
+     * @returns An array of added items.
+     */
     addMany(items: Array<QueueItem<T>>, emitEvent?: boolean): Array<QueueItem<T>>;
+    /**
+     * Removes an item from the queue.
+     *
+     * @param itemOrId - The item or ID of the item to be removed.
+     * @param emitEvent - Whether to emit an event after removing the item. Default is `true`.
+     * @returns The removed item, or `null` if the item was not found.
+     */
     remove(itemOrId: QueueItem<T> | QueueItemId, emitEvent?: boolean): QueueItem<T> | null;
+    /**
+     * Removes multiple items from the queue based on the provided item or item IDs.
+     * @param itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.
+     * @param emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.
+     * @returns An array of removed QueueItem objects or null values.
+     */
     removeMany(itemOrIds: Array<QueueItem<T> | QueueItemId>, emitEvent?: boolean): Array<QueueItem<T> | null>;
+    /**
+     * Clears the queue by removing all items.
+     *
+     * @param emitEvent - Whether to emit an event after clearing the queue. Default is true.
+     */
     clear(emitEvent?: boolean): void;
+    /**
+     * Returns an array representation of the queue.
+     *
+     * @returns An array containing all the items in the queue.
+     */
     toArray(): QueueItem<T>[];
     private notify;
     private createEventObserver;

package/utils/lib/helpers/type-guards.d.ts

@@ -1,10 +1,67 @@
 import { TemplateRef, Type, ViewContainerRef } from '@angular/core';
+/**
+ * Checks if the given value is a `ViewContainerRef`.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is ViewContainerRef} `true` if the value is a `ViewContainerRef`, otherwise `false`.
+ */
 export declare function isViewContainer(value: unknown): value is ViewContainerRef;
+/**
+ * Checks if the given value is a `TemplateRef`.
+ *
+ * @template T - The embedded view type.
+ * @param {unknown} value - The value to check.
+ * @returns {value is TemplateRef<T>} `true` if the value is a `TemplateRef`, otherwise `false`.
+ */
 export declare function isTemplateRef<T = unknown>(value: unknown): value is TemplateRef<T>;
+/**
+ * Checks if the given value is an Angular component class.
+ *
+ * @template T - The component class type.
+ * @param {unknown} value - The value to check.
+ * @returns {value is Type<T>} `true` if the value is a component class, otherwise `false`.
+ */
 export declare function isComponent<T = unknown>(value: unknown): value is Type<T>;
+/**
+ * Checks if the given value is a string.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is string} `true` if the value is a string, otherwise `false`.
+ */
 export declare function isString(value: unknown): value is string;
+/**
+ * Checks if the given value is a non-empty string.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is string} `true` if the value is a non-empty string, otherwise `false`.
+ */
 export declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Checks if the given value is a boolean.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is boolean} `true` if the value is a boolean, otherwise `false`.
+ */
 export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Checks if the given value is a function.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is CallableFunction} `true` if the value is a function, otherwise `false`.
+ */
 export declare function isFunction(value: unknown): value is CallableFunction;
+/**
+ * Checks if the given value is present (not null or undefined).
+ *
+ * @template T - The value type.
+ * @param {T | null | undefined} value - The value to check.
+ * @returns {value is NonNullable<T>} `true` if the value is present, otherwise `false`.
+ */
 export declare function isPresent<T>(value: T | null | undefined): value is NonNullable<T>;
+/**
+ * Checks if the given value is a number.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is number} `true` if the value is a number, otherwise `false`.
+ */
 export declare function isNumber(value: unknown): value is number;

package/utils/lib/helpers/until-destroyed.d.ts

@@ -1,2 +1,40 @@
 import { MonoTypeOperatorFunction } from 'rxjs';
+/**
+ * Creates a MonoTypeOperatorFunction that automatically unsubscribes from observables when the host component or service is destroyed.
+ * It uses Angular's `DestroyRef` to detect when the component or service is destroyed and triggers the unsubscription at that point.
+ * This utility function helps in managing subscriptions and prevents memory leaks by ensuring observables are unsubscribed when no longer needed.
+ *
+ * @returns A function that returns a `MonoTypeOperatorFunction<T>`, which can be used in an RxJS pipe to automatically unsubscribe
+ * based on the component's or service's lifecycle.
+ *
+ * @example
+ * ```ts
+ * // In an Angular component or service
+ * import { Component } from '@angular/core';
+ * import { Observable } from 'rxjs';
+ * import { untilDestroyed } from './path/to/untilDestroyed';
+ *
+ * @Component({
+ *   selector: 'app-example',
+ *   template: `<div>Example Component</div>`,
+ * })
+ * export class ExampleComponent {
+ *   private readonly takeUntilDestroyed = untilDestroyed();
+ *
+ *   constructor() {
+ *     const exampleObservable$ = new Observable(observer => {
+ *       // Observable logic here
+ *     });
+ *
+ *     exampleObservable$.pipe(
+ *       this.takeUntilDestroyed(),
+ *     ).subscribe(data => {
+ *       // Subscription logic here
+ *     });
+ *   }
+ *
+ *   // No need to manually implement ngOnDestroy to unsubscribe
+ * }
+ * ```
+ */
 export declare function untilDestroyed(): <T>() => MonoTypeOperatorFunction<T>;

package/esm2022/rxjs/lib/form-query-list.mjs

@@ -1,5 +0,0 @@
-import { startWith } from 'rxjs';
-export function fromQueryList(queryList) {
-    return queryList.changes.pipe(startWith(queryList));
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1xdWVyeS1saXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3J4anMvc3JjL2xpYi9mb3JtLXF1ZXJ5LWxpc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFjLFNBQVMsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUU3QyxNQUFNLFVBQVUsYUFBYSxDQUFJLFNBQXVCO0lBQ3RELE9BQU8sU0FBUyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7QUFDdEQsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFF1ZXJ5TGlzdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgc3RhcnRXaXRoIH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBmcm9tUXVlcnlMaXN0PFQ+KHF1ZXJ5TGlzdDogUXVlcnlMaXN0PFQ+KTogT2JzZXJ2YWJsZTxRdWVyeUxpc3Q8VD4+IHtcbiAgcmV0dXJuIHF1ZXJ5TGlzdC5jaGFuZ2VzLnBpcGUoc3RhcnRXaXRoKHF1ZXJ5TGlzdCkpO1xufVxuIl19

package/rxjs/lib/form-query-list.d.ts

@@ -1,3 +0,0 @@
-import { QueryList } from '@angular/core';
-import { Observable } from 'rxjs';
-export declare function fromQueryList<T>(queryList: QueryList<T>): Observable<QueryList<T>>;