@dereekb/rxjs 13.3.1 → 13.4.1

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dereekb/rxjs",
-  "version": "13.3.1",
+  "version": "13.4.1",
   "peerDependencies": {
     "rxjs": "^7.8.0",
-    "@dereekb/util": "13.3.1"
+    "@dereekb/util": "13.4.1"
   },
   "exports": {
     "./package.json": "./package.json",

package/src/lib/filter/filter.map.d.ts

@@ -89,10 +89,14 @@ export declare class FilterMapKeyInstance<F> implements FilterSourceConnector<F>
     get key(): FilterMapKey;
     /**
      * Sets the default filter observable for this key.
+     *
+     * @param filterObs - the observable to use as the default filter for this key
      */
     initWithFilter(filterObs: Observable<F>): void;
     /**
      * Connects a filter source, adding its filter observable to this key's merged filters.
+     *
+     * @param filterSource - the filter source whose filter$ will be added to this key's merged stream
      */
     connectWithSource(filterSource: FilterSource<F>): void;
 }

package/src/lib/filter/filter.source.d.ts

@@ -6,11 +6,17 @@ import { type Destroyable, type Maybe } from '@dereekb/util';
  * Configuration for initializing a {@link FilterSourceInstance}.
  */
 export interface FilterSourceInstanceConfig<F> {
-    /** Observable used to initialize the filter value, taking priority over the default. */
+    /**
+     * Observable used to initialize the filter value, taking priority over the default.
+     */
     readonly initWithFilter?: Maybe<Observable<F>>;
-    /** Default filter value or observable, used as a fallback when no explicit filter is set. */
+    /**
+     * Default filter value or observable, used as a fallback when no explicit filter is set.
+     */
     readonly defaultFilter?: MaybeObservableOrValue<F>;
-    /** Explicit filter value to set immediately. */
+    /**
+     * Explicit filter value to set immediately.
+     */
     readonly filter?: Maybe<F>;
 }
 /**

package/src/lib/iterator/iteration.accumulator.d.ts

@@ -62,13 +62,21 @@ export interface ItemAccumulatorValuePair<O, I = unknown> extends MapFunctionOut
  * and successful states.
  */
 export interface ItemAccumulatorInstance<O, I = unknown, N extends ItemIteration<I> = ItemIteration<I>> extends ItemAccumulator<O, I, N>, Destroyable {
-    /** Emits `true` once the first load has completed. */
+    /**
+     * Emits `true` once the first load has completed.
+     */
     readonly hasCompletedInitialLoad$: Observable<boolean>;
-    /** The most recent loading state that completed without an error. */
+    /**
+     * The most recent loading state that completed without an error.
+     */
     readonly latestSuccessfulState$: Observable<LoadingState<I>>;
-    /** All successful loading states accumulated in order. */
+    /**
+     * All successful loading states accumulated in order.
+     */
     readonly allSuccessfulStates$: Observable<LoadingState<I>[]>;
-    /** Count of successfully loaded pages so far. */
+    /**
+     * Count of successfully loaded pages so far.
+     */
     readonly successfulLoadCount$: Observable<number>;
 }
 /**
@@ -92,11 +100,17 @@ export type ItemAccumulatorNextPageUntilResultsCountFunction<O> = MapFunction<O[
  * Configuration for {@link itemAccumulatorNextPageUntilResultsCount}.
  */
 export interface ItemAccumulatorNextPageUntilResultsCountConfig<O> {
-    /** The accumulator whose iteration will be advanced. */
+    /**
+     * The accumulator whose iteration will be advanced.
+     */
     readonly accumulator: ItemAccumulator<O, any, PageItemIteration<any>>;
-    /** Target number of results to accumulate before stopping. */
+    /**
+     * Target number of results to accumulate before stopping.
+     */
     readonly maxResultsLimit: GetterOrValue<number>;
-    /** Function to count how many meaningful results exist in the accumulated items. */
+    /**
+     * Function to count how many meaningful results exist in the accumulated items.
+     */
     readonly countResultsFunction: ItemAccumulatorNextPageUntilResultsCountFunction<O>;
 }
 /**

package/src/lib/loading/loading.context.simple.d.ts

@@ -28,6 +28,8 @@ export declare class SimpleLoadingContext implements LoadingContext, Destroyable
     destroy(): void;
     /**
      * Whether the current state has a non-null error.
+     *
+     * @returns true if the current state contains an error
      */
     hasError(): boolean;
     /**

package/src/lib/loading/loading.context.state.d.ts

@@ -79,6 +79,10 @@ export type LoadingEventForLoadingPairConfigInput = Pick<LoadingStateContextConf
  *
  * Determines the `loading` flag based on whether an error is present, whether the value is defined,
  * and the `showLoadingOnUndefinedValue` setting. Loading progress is only included while loading.
+ *
+ * @param state - the current loading state to convert into a context event
+ * @param input - configuration input controlling how the loading flag is derived
+ * @returns a loading state context event derived from the given state
  */
 export declare const DEFAULT_LOADING_EVENT_FOR_LOADING_PAIR_FUNCTION: <T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingStateContextEvent = LoadingContextEvent & S>(state: S, input: LoadingEventForLoadingPairConfigInput) => LoadingStateContextEvent<T>;
 /**

package/src/lib/loading/loading.state.d.ts

@@ -174,6 +174,8 @@ export declare function isLoadingStateFinishedLoading<L extends LoadingState>(st
  * // { loading: false }
  * loadingStateType(state); // LoadingStateType.IDLE
  * ```
+ *
+ * @returns a loading state with `loading: false` and no value or error
  */
 export declare function idleLoadingState<T>(): LoadingState<T>;
 /**
@@ -405,6 +407,10 @@ export declare function isPageLoadingStateMetadataEqual(a: Partial<PageLoadingSt
  * const merged = mergeLoadingStates(beginLoading(), successResult({ a: 1 }));
  * // { loading: true }
  * ```
+ *
+ * @param a - the first loading state to merge
+ * @param b - the second loading state to merge
+ * @returns the combined loading state reflecting the merged values, errors, and loading flags
  */
 export declare function mergeLoadingStates<A extends object, B extends object>(a: LoadingState<A>, b: LoadingState<B>): LoadingState<A & B>;
 export declare function mergeLoadingStates<A extends object, B extends object, O>(a: LoadingState<A>, b: LoadingState<B>, mergeFn: (a: A, b: B) => O): LoadingState<O>;
@@ -443,8 +449,8 @@ export declare function mergeLoadingStateWithValue<S extends LoadingState>(state
 export declare function mergeLoadingStateWithError<S extends LoadingState = LoadingState>(state: S, error?: ReadableDataError): S;
 export type MapMultipleLoadingStateValuesFn<T, X> = (input: X[]) => T;
 export interface MapMultipleLoadingStateResultsConfiguration<T, X, L extends LoadingState<X>[], R extends LoadingState<T>> {
-    mapValues?: MapMultipleLoadingStateValuesFn<T, X>;
-    mapState?: (input: L) => R;
+    readonly mapValues?: MapMultipleLoadingStateValuesFn<T, X>;
+    readonly mapState?: (input: L) => R;
 }
 /**
  * Maps multiple {@link LoadingState} results into a single state using a value mapping or state mapping function.
@@ -461,9 +467,9 @@ export declare function mapMultipleLoadingStateResults<T, X, L extends LoadingSt
 export type MapLoadingStateFn<A, B, L extends LoadingState<A> = LoadingState<A>, O extends LoadingState<B> = LoadingState<B>> = (input: L, value?: B) => O;
 export type MapLoadingStateValuesFn<A, B, L extends LoadingState<A> = LoadingState<A>> = (input: A, state: L) => B;
 export interface MapLoadingStateResultsConfiguration<A, B, L extends LoadingState<A> = LoadingState<A>, O extends LoadingState<B> = LoadingState<B>> {
-    alwaysMapValue?: boolean;
-    mapValue?: MapLoadingStateValuesFn<A, B, L>;
-    mapState?: MapLoadingStateFn<A, B, L, O>;
+    readonly alwaysMapValue?: boolean;
+    readonly mapValue?: MapLoadingStateValuesFn<A, B, L>;
+    readonly mapState?: MapLoadingStateFn<A, B, L, O>;
 }
 /**
  * Maps the value of a single {@link LoadingState} to a new type using the provided configuration.

package/src/lib/loading/loading.state.rxjs.d.ts

@@ -48,7 +48,8 @@ export declare function loadingStateFromObs<T>(obs: Observable<T>, firstOnly?: b
  * // => emits LoadingState<{ sum: number }> with value { sum: 3 }
  * ```
  *
- * @param args - Two or more LoadingState observables, with an optional merge function as the last argument.
+ * @param obsA - the first LoadingState observable to combine
+ * @param obsB - the second LoadingState observable to combine
  * @returns An observable emitting the merged {@link LoadingState}.
  */
 export declare function combineLoadingStates<A, B>(obsA: Observable<LoadingState<A>>, obsB: Observable<LoadingState<B>>): Observable<LoadingState<A & B>>;
@@ -350,19 +351,19 @@ export interface DistinctLoadingStateConfig<L extends LoadingState> {
      *
      * By default this uses a DecisionFunction that returns true on undefined and false on null.
      */
-    passRetainedValue?: (value: Maybe<LoadingStateValue<L>>, previousValue: Maybe<LoadingStateValue<L>>, state: L, previousState: Maybe<L>) => boolean;
+    readonly passRetainedValue?: (value: Maybe<LoadingStateValue<L>>, previousValue: Maybe<LoadingStateValue<L>>, state: L, previousState: Maybe<L>) => boolean;
     /**
      * Whether or not to compare the
      */
-    compareOnUndefinedValue?: boolean;
+    readonly compareOnUndefinedValue?: boolean;
     /**
      * Used for comparing the values of the LoadingState.
      */
-    valueComparator: EqualityComparatorFunction<Maybe<LoadingStateValue<L>>>;
+    readonly valueComparator: EqualityComparatorFunction<Maybe<LoadingStateValue<L>>>;
     /**
      * Used for comparing the metadata values of the LoadingState. By default uses isPageLoadingStateMetadataEqual.
      */
-    metadataComparator?: EqualityComparatorFunction<Maybe<Partial<L>>>;
+    readonly metadataComparator?: EqualityComparatorFunction<Maybe<Partial<L>>>;
 }
 /**
  * A special `distinctUntilChanged`-like operator for {@link LoadingState} and {@link PageLoadingState}.

package/src/lib/lock.d.ts

@@ -1,6 +1,6 @@
 import { type ObservableOrValue } from './rxjs/getter';
 import { type Subscription, type Observable } from 'rxjs';
-import { type Destroyable, type Maybe } from '@dereekb/util';
+import { type Destroyable, type Maybe, type Milliseconds, type Seconds } from '@dereekb/util';
 /**
  * Key used to identify a specific lock within a {@link LockSet}.
  */
@@ -19,14 +19,22 @@ export type RemoveLockFunction = () => void;
  * Configuration for {@link onLockSetNextUnlock} that specifies how to wait for a {@link LockSet} to unlock.
  */
 export interface OnLockSetUnlockedConfig {
-    /** The lock set to monitor for the next unlock event. */
+    /**
+     * The lock set to monitor for the next unlock event.
+     */
     readonly lockSet: LockSet;
-    /** Optional callback to invoke when the lock set unlocks or the timeout is reached. */
+    /**
+     * Optional callback to invoke when the lock set unlocks or the timeout is reached.
+     */
     readonly fn?: Maybe<OnLockSetUnlockedFunction>;
-    /** Maximum time in milliseconds to wait for unlock before timing out. Defaults to 50 seconds. */
-    readonly timeout?: Maybe<number>;
-    /** Optional delay in milliseconds after the unlock is detected before invoking the callback. */
-    readonly delayTime?: Maybe<number>;
+    /**
+     * Maximum time in milliseconds to wait for unlock before timing out. Defaults to 50 seconds.
+     */
+    readonly timeout?: Maybe<Milliseconds>;
+    /**
+     * Optional delay in milliseconds after the unlock is detected before invoking the callback.
+     */
+    readonly delayTime?: Maybe<Milliseconds>;
 }
 /**
  * Configuration for {@link LockSet.destroyOnNextUnlock}, excluding the lock set reference.
@@ -45,7 +53,7 @@ export interface SetLockedConfig {
      *
      * Only relevant for locking.
      */
-    readonly duration?: number;
+    readonly duration?: Milliseconds;
 }
 /**
  * Default lock key used by {@link LockSet.lockForTime} when no custom key is provided.
@@ -57,6 +65,10 @@ export declare const DEFAULT_LOCK_SET_TIME_LOCK_KEY = "timelock";
  * Useful for deferring an action until all locks are released, with a safety timeout to avoid waiting indefinitely.
  *
  * @param config - configuration specifying the lock set, callback, timeout, and optional delay
+ * @param config.lockSet - the lock set to monitor for the next unlock event
+ * @param config.fn - optional callback to invoke when the lock set unlocks or the timeout is reached
+ * @param config.timeout - maximum time in milliseconds to wait before timing out
+ * @param config.delayTime - optional delay in milliseconds after unlock before invoking the callback
  * @returns subscription that can be unsubscribed to cancel the wait
  *
  * @example
@@ -132,20 +144,20 @@ export declare class LockSet implements Destroyable {
      * @param duration - optional auto-unlock duration in milliseconds (only used with boolean config)
      */
     setLocked(key: LockKey, config: SetLockedConfig): void;
-    setLocked(key: LockKey, config: boolean, duration?: number): void;
+    setLocked(key: LockKey, config: boolean, duration?: Milliseconds): void;
     /**
      * Locks for a specified number of seconds using the default time lock key.
      *
      * @param seconds - duration in seconds
      */
-    lockForSeconds(seconds: number): void;
+    lockForSeconds(seconds: Seconds): void;
     /**
      * Locks for a specified duration in milliseconds, automatically unlocking when the time elapses.
      *
      * @param milliseconds - lock duration
      * @param key - optional lock key, defaults to {@link DEFAULT_LOCK_SET_TIME_LOCK_KEY}
      */
-    lockForTime(milliseconds: number, key?: LockKey): void;
+    lockForTime(milliseconds: Milliseconds, key?: LockKey): void;
     /**
      * Registers a lock observable under the given key. The lock is considered active when
      * the observable emits `true`. Empty observables are treated as unlocked.
@@ -178,7 +190,7 @@ export declare class LockSet implements Destroyable {
      * @param delayTime - optional delay in milliseconds after unlock before invoking the callback
      * @returns subscription that can be unsubscribed to cancel the wait
      */
-    onNextUnlock(config: OnLockSetUnlockedFunction | Omit<OnLockSetUnlockedConfig, 'lockSet'>, delayTime?: number): Subscription;
+    onNextUnlock(config: OnLockSetUnlockedFunction | Omit<OnLockSetUnlockedConfig, 'lockSet'>, delayTime?: Milliseconds): Subscription;
     /**
      * Establishes a parent-child relationship where this lock set's locked state is propagated
      * to the parent. When this lock set is locked, the parent will also reflect a locked state.
@@ -204,7 +216,7 @@ export declare class LockSet implements Destroyable {
      * @param config - optional callback or configuration for the unlock wait
      * @param delayTime - optional delay in milliseconds after unlock before invoking the callback
      */
-    destroyOnNextUnlock(config?: Maybe<DestroyOnNextUnlockConfig['fn'] | DestroyOnNextUnlockConfig>, delayTime?: number): void;
+    destroyOnNextUnlock(config?: Maybe<DestroyOnNextUnlockConfig['fn'] | DestroyOnNextUnlockConfig>, delayTime?: Milliseconds): void;
     /**
      * Completes all internal subjects, unsubscribes from the parent lock set, and marks this lock set as destroyed.
      */

package/src/lib/object.d.ts

@@ -22,7 +22,7 @@ export declare function distinctUntilObjectValuesChanged<T>(): MonoTypeOperatorF
  * Accepts either a static reference value or an observable of reference values. When given an observable,
  * each emission is compared against the latest reference value. Uses {@link areEqualPOJOValues} for comparison.
  *
- * @param input - static reference value or observable of reference values to compare against
+ * @param inputFilter - static reference value or observable of reference values to compare against
  * @returns operator that only passes through values that differ from the reference
  *
  * @example

package/src/lib/rxjs/boolean.d.ts

@@ -9,13 +9,19 @@ import { type OperatorFunction, type MonoTypeOperatorFunction } from 'rxjs';
 export declare function pipeIf<A>(usePipe: boolean, pipe: OperatorFunction<A, A>): OperatorFunction<A, A>;
 /**
  * RxJS operator that negates each emitted boolean value.
+ *
+ * @returns operator that maps each boolean emission to its negated value
  */
 export declare function isNot(): MonoTypeOperatorFunction<boolean>;
 /**
  * RxJS operator that only emits when a boolean stream transitions from `true` to `false`.
+ *
+ * @returns operator that filters to only true-to-false transition emissions
  */
 export declare function onTrueToFalse(): MonoTypeOperatorFunction<boolean>;
 /**
  * RxJS operator that only emits when a boolean stream transitions from `false` to `true`.
+ *
+ * @returns operator that filters to only false-to-true transition emissions
  */
 export declare function onFalseToTrue(): MonoTypeOperatorFunction<boolean>;

package/src/lib/rxjs/expires.d.ts

@@ -5,23 +5,27 @@ import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction }
  * time relative to the current moment.
  *
  * @param expiresIn - duration in milliseconds until expiration
- * @returns an operator that maps values to Expires objects
+ * @returns an `OperatorFunction` that maps each emission to an {@link Expires} object
  */
 export declare function toExpiration<T>(expiresIn: number): OperatorFunction<T, Expires>;
 /**
  * RxJS operator that filters out emissions whose {@link Expires} value has already expired.
+ *
+ * @returns operator that only passes through non-expired emissions
  */
 export declare function skipExpired<T extends Expires>(): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that skips emissions until the elapsed time since the emitted date/timestamp has exceeded `expiresIn`.
  *
  * @param expiresIn - duration in milliseconds
+ * @returns operator that skips emissions until the time window has elapsed
  */
 export declare function skipUntilExpiration(expiresIn?: number): MonoTypeOperatorFunction<DateOrUnixDateTimeMillisecondsNumber>;
 /**
  * RxJS operator that skips emissions after the elapsed time since the emitted date/timestamp has exceeded `expiresIn`.
  *
  * @param expiresIn - duration in milliseconds
+ * @returns operator that passes through emissions only within the time window
  */
 export declare function skipAfterExpiration(expiresIn?: number): MonoTypeOperatorFunction<DateOrUnixDateTimeMillisecondsNumber>;
 /**
@@ -29,6 +33,7 @@ export declare function skipAfterExpiration(expiresIn?: number): MonoTypeOperato
  *
  * @param watch - observable whose emissions reset the time window
  * @param takeFor - duration in milliseconds of each time window
+ * @returns operator that limits source emissions to the active time window after each watch emission
  */
 export declare function skipUntilTimeElapsedAfterLastEmission<T>(watch: Observable<unknown>, takeFor: Milliseconds): MonoTypeOperatorFunction<T>;
 /**
@@ -37,5 +42,6 @@ export declare function skipUntilTimeElapsedAfterLastEmission<T>(watch: Observab
  *
  * @param watch - observable whose emissions reset the skip window
  * @param skipFor - duration in milliseconds to skip after each watch emission
+ * @returns an operator that delays passing values through until time has elapsed since the last watch emission
  */
 export declare function takeAfterTimeElapsedSinceLastEmission<T>(watch: Observable<unknown>, skipFor: Milliseconds): MonoTypeOperatorFunction<T>;

package/src/lib/rxjs/getter.d.ts

@@ -7,6 +7,9 @@ export type ObservableOrValue<T> = T | Observable<T>;
 export type MaybeObservableOrValue<T> = Maybe<ObservableOrValue<Maybe<T>>>;
 /**
  * Wraps a value as an observable using `of()`, or returns it directly if it is already an observable.
+ *
+ * @param valueOrObs - the value or observable to wrap
+ * @returns an observable that emits the given value, or the original observable if already one
  */
 export declare function asObservable<T>(valueOrObs: ObservableOrValue<T>): Observable<T>;
 export declare function asObservable<T>(valueOrObs: Maybe<ObservableOrValue<T>>): Observable<Maybe<T>>;
@@ -51,14 +54,16 @@ export declare function valueFromObservableOrValueGetter<T>(): OperatorFunction<
 /**
  * RxJS operator that flattens an emitted Maybe<{@link ObservableOrValueGetter}> into its resolved value,
  * emitting `undefined` when the input is nullish.
+ *
+ * @returns an operator that unwraps Maybe<ObservableOrValueGetter> emissions, emitting undefined for nullish inputs
  */
 export declare function maybeValueFromObservableOrValueGetter<T>(): OperatorFunction<MaybeObservableOrValueGetter<T>, Maybe<T>>;
 /**
  * Subscribes to an {@link ObservableOrValue} and calls the observer/next function with each emitted value.
  *
  * @param input - the observable or value to subscribe to
- * @param observer - callback or partial observer
- * @returns the subscription
+ * @param next - callback function or partial observer to handle each emitted value
+ * @returns the resulting subscription
  */
 export declare function useAsObservable<T>(input: ObservableOrValue<T>, next: (value: T) => void): Subscription;
 export declare function useAsObservable<T>(input: ObservableOrValue<T>, observer: Partial<Observer<T>>): Subscription;

package/src/lib/rxjs/misc.d.ts

@@ -13,7 +13,7 @@ import { type MonoTypeOperatorFunction, type SchedulerLike } from 'rxjs';
  * // logs "Value: <emitted value>" for each emission
  * ```
  *
- * @param messageOrFunction - static label or function returning log arguments
+ * @param message - static label or function returning log arguments
  * @param consoleLogFn - which console method to use (defaults to 'log')
  * @returns a tap operator that logs emissions
  */

package/src/lib/rxjs/model.d.ts

@@ -1,9 +1,13 @@
 import { type ModelKeyRef, type UniqueModel } from '@dereekb/util';
 /**
  * `distinctUntilChanged` variant that only emits when the model's `id` property changes.
+ *
+ * @returns operator that suppresses consecutive emissions with the same model `id`
  */
 export declare function distinctUntilModelIdChange<T extends UniqueModel>(): import("rxjs").MonoTypeOperatorFunction<T>;
 /**
  * `distinctUntilChanged` variant that only emits when the model's `key` property changes.
+ *
+ * @returns operator that suppresses consecutive emissions with the same model `key`
  */
 export declare function distinctUntilModelKeyChange<T extends ModelKeyRef>(): import("rxjs").MonoTypeOperatorFunction<T>;

package/src/lib/rxjs/rxjs.async.d.ts

@@ -1,4 +1,4 @@
-import { type CachedFactoryWithInput, type Destroyable } from '@dereekb/util';
+import { type CachedFactoryWithInput, type Destroyable, type Milliseconds } from '@dereekb/util';
 import { type Observable, type Subject } from 'rxjs';
 /**
  * Default amount of throttle in milliseconds used by AsyncPusher.
@@ -25,19 +25,19 @@ export interface AsyncPusherConfig<T> {
     /**
      * Time to throttle each emission.
      */
-    throttle?: number;
+    readonly throttle?: Milliseconds;
     /**
      * Whether or not to filter on distinct values.
      */
-    distinct?: boolean;
+    readonly distinct?: boolean;
     /**
      * Configuration function to build onto the internal observable.
      */
-    pipe?: (obs: Observable<T>) => Observable<T>;
+    readonly pipe?: (obs: Observable<T>) => Observable<T>;
     /**
      * (Optional) Observable to watch for cleaunup.
      */
-    cleanupObs?: Observable<unknown>;
+    readonly cleanupObs?: Observable<unknown>;
 }
 /**
  * Creates an {@link AsyncPusher} — a callable function backed by a throttled {@link BehaviorSubject}.

package/src/lib/rxjs/set.d.ts

@@ -23,6 +23,8 @@ export declare function setContainsAnyValueFrom<T>(valuesObs: Observable<Maybe<I
 export declare function setContainsNoValueFrom<T>(valuesObs: Observable<Maybe<Iterable<T>>>): OperatorFunction<Set<T>, boolean>;
 /**
  * `distinctUntilChanged` variant for iterables that only emits when the contained values change.
+ *
+ * @returns operator that suppresses consecutive iterable emissions with the same set of values
  */
 export declare function distinctUntilHasDifferentValues<I extends Iterable<K>, K extends PrimativeKey>(): MonoTypeOperatorFunction<I>;
 /**
@@ -30,6 +32,7 @@ export declare function distinctUntilHasDifferentValues<I extends Iterable<K>, K
  * when the set of extracted values changes.
  *
  * @param readValues - function to extract the iterable of values to compare
+ * @returns operator that suppresses consecutive emissions whose extracted iterable values are the same
  */
 export declare function distinctUntilItemsHaveDifferentValues<I, V extends Iterable<PrimativeKey>>(readValues: ReadValueFunction<I, V>): MonoTypeOperatorFunction<I>;
 export declare function distinctUntilItemsHaveDifferentValues<I, V extends Iterable<PrimativeKey>>(readValues: ReadValueFunction<I, V>): MonoTypeOperatorFunction<Maybe<I>>;
@@ -39,6 +42,7 @@ export declare function distinctUntilItemsHaveDifferentValues<I, V extends Itera
  *
  * @param readValues - function to extract the value to compare
  * @param isEqualComparator - custom equality function for the extracted values
+ * @returns operator that suppresses consecutive emissions whose extracted values are considered equal
  */
 export declare function distinctUntilItemsValueChanges<I, V>(readValues: ReadValueFunction<I, V>, isEqualComparator: EqualityComparatorFunction<V>): MonoTypeOperatorFunction<I>;
 export declare function distinctUntilItemsValueChanges<I, V>(readValues: ReadValueFunction<I, V>, isEqualComparator: EqualityComparatorFunction<V>): MonoTypeOperatorFunction<Maybe<I>>;