@dereekb/rxjs 13.4.0 → 13.4.2

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dereekb/rxjs",
-  "version": "13.4.0",
+  "version": "13.4.2",
   "peerDependencies": {
     "rxjs": "^7.8.0",
-    "@dereekb/util": "13.4.0"
+    "@dereekb/util": "13.4.2"
   },
   "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>;

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>>;

package/src/lib/lock.d.ts

@@ -19,13 +19,21 @@ 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. */
+    /**
+     * 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. */
+    /**
+     * Optional delay in milliseconds after the unlock is detected before invoking the callback.
+     */
     readonly delayTime?: Maybe<Milliseconds>;
 }
 /**
@@ -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

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/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>>;

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

@@ -59,6 +59,7 @@ export declare function makeIsModifiedFunctionObservable<T>(config: MakeIsModifi
  *
  * @param isCheckFunction - optional check function
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns a function that evaluates each value against the check function and returns it or undefined
  */
 export declare function makeReturnIfIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<Maybe<T>>;
 /**
@@ -67,6 +68,7 @@ export declare function makeReturnIfIsFunction<T>(isCheckFunction: Maybe<IsModif
  * @param isCheckFunction - optional check function
  * @param value - the value to check
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns an observable that emits the value if the check passes, or undefined otherwise
  */
 export declare function returnIfIs<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, value: Maybe<T>, defaultValueOnMaybe?: boolean): Observable<Maybe<T>>;
 /**
@@ -74,6 +76,7 @@ export declare function returnIfIs<T>(isCheckFunction: Maybe<IsModifiedFunction<
  *
  * @param isCheckFunction - optional check function
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns a function that evaluates each value against the check function and returns an observable boolean
  */
 export declare function makeCheckIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<boolean>;
 /**
@@ -84,10 +87,13 @@ export declare function makeCheckIsFunction<T>(isCheckFunction: Maybe<IsModified
  * @param isCheckFunction - optional check function
  * @param value - the value to check
  * @param defaultValueOnMaybe - default result for null/undefined values (defaults to false)
+ * @returns an observable boolean indicating whether the value passes the check
  */
 export declare function checkIs<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, value: Maybe<T>, defaultValueOnMaybe?: boolean): Observable<boolean>;
 /**
  * RxJS operator that filters out null and undefined values, only passing through defined values.
+ *
+ * @returns operator that filters out null and undefined emissions
  */
 export declare function filterMaybe<T>(): OperatorFunction<Maybe<T>, T>;
 /**
@@ -96,20 +102,27 @@ export declare function filterMaybe<T>(): OperatorFunction<Maybe<T>, T>;
 export declare const filterMaybeStrict: <T>() => OperatorFunction<Maybe<T>, MaybeSoStrict<T>>;
 /**
  * RxJS operator that filters out null/undefined elements from an emitted array, keeping only defined values.
+ *
+ * @returns operator that maps each emitted array to a version with null/undefined elements removed
  */
 export declare function filterMaybeArray<T>(): OperatorFunction<Maybe<T>[], T[]>;
 /**
  * RxJS operator that skips all leading null/undefined emissions, then passes all subsequent values through.
+ *
+ * @returns operator that skips all null/undefined emissions at the start of the stream
  */
 export declare function skipAllInitialMaybe<T>(): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that skips only the first emission if it is null/undefined, then passes all subsequent values.
+ *
+ * @returns operator that skips the first null/undefined emission if it occurs at the start of the stream
  */
 export declare function skipInitialMaybe<T>(): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that skips up to `maxToSkip` null/undefined emissions, then passes all subsequent values.
  *
  * @param maxToSkip - maximum number of null/undefined emissions to skip
+ * @returns operator that skips the first N null/undefined emissions from the stream
  */
 export declare function skipMaybes<T>(maxToSkip: number): MonoTypeOperatorFunction<T>;
 /**
@@ -140,11 +153,17 @@ export interface SwitchMapObjectConfig<T> {
 /**
  * RxJS operator that resolves an observable/getter config input into a value, applying defaults
  * for `null`/`undefined`/`true` inputs and emitting `null` for `false`.
+ *
+ * @param config - configuration providing an optional default getter for null/undefined/true inputs
+ * @returns operator that resolves each emitted getter into a value, using the default for nullish or true inputs
  */
 export declare function switchMapObject<T extends object>(config: SwitchMapObjectConfig<T>): OperatorFunction<Maybe<ObservableOrValueGetter<Maybe<T | boolean>>>, Maybe<T>>;
 /**
  * RxJS operator that emits from the given observable/getter when the source boolean is `true`,
  * otherwise emits from the `otherwise` source or `EMPTY`.
+ *
+ * @param obs - observable or getter to subscribe to when the source emits `true`
+ * @returns operator that switches to the given source when the boolean is true
  */
 export declare function switchMapWhileTrue<T = unknown>(obs: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileTrue<T = unknown>(obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
@@ -153,6 +172,9 @@ export declare function switchMapWhileTrue<T = unknown>(obs: MaybeObservableOrVa
 /**
  * RxJS operator that emits from the given observable/getter when the source boolean is `false`,
  * otherwise emits from the `otherwise` source or `EMPTY`.
+ *
+ * @param obs - observable or getter to subscribe to when the source emits `false`
+ * @returns operator that switches to the given source when the boolean is false
  */
 export declare function switchMapWhileFalse<T = unknown>(obs: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileFalse<T = unknown>(obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
@@ -165,6 +187,7 @@ export declare function switchMapWhileFalse<T = unknown>(obs: MaybeObservableOrV
  * @param switchOnValue - the boolean value that triggers emitting from `obs`
  * @param obs - observable/getter to emit from when matched
  * @param otherwise - optional observable/getter for the non-matching case
+ * @returns operator that switches to the appropriate source based on the emitted boolean value
  */
 export declare function switchMapOnBoolean<T = unknown>(switchOnValue: boolean, obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapOnBoolean<T = unknown>(switchOnValue: boolean, obs: MaybeObservableOrValueGetter<T>, otherwise?: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, Maybe<T>>;
@@ -172,10 +195,14 @@ export declare function switchMapOnBoolean<T = unknown>(switchOnValue: boolean,
  * RxJS operator that filters out null/undefined observables and then switches to the remaining ones.
  *
  * Combines {@link filterMaybe} and `switchMap` to only subscribe to non-nullish observables.
+ *
+ * @returns operator that filters nullish observables and subscribes to the non-nullish ones
  */
 export declare function switchMapFilterMaybe<T = unknown>(): OperatorFunction<Maybe<Observable<Maybe<T>>>, T>;
 /**
  * RxJS operator that switches to the emitted observable if defined, or emits `undefined` when the observable is nullish.
+ *
+ * @returns operator that switches to the emitted observable or emits undefined for null/undefined inputs
  */
 export declare function switchMapMaybe<T = unknown>(): OperatorFunction<Maybe<Observable<Maybe<T>>>, Maybe<T>>;
 /**
@@ -194,20 +221,29 @@ export declare function mapMaybe<A, B>(mapFn: MapFunction<A, Maybe<B>>): Operato
  */
 export declare function mapIf<A, B>(mapFn: MapFunction<Maybe<A>, Maybe<B>>, decision: DecisionFunction<Maybe<A>>): OperatorFunction<Maybe<A>, Maybe<B>>;
 /**
- * Combines both combineLatest with map values to an other value.
+ * Combines the source observable with another observable via `combineLatest`, then maps the pair to a result.
  *
- * @param combineObs
- * @param mapFn
- * @returns
+ * @param combineObs - the secondary observable to combine with the source
+ * @param mapFn - function that maps the source value and combined value to the output
+ * @returns operator that combines the source with `combineObs` and maps each pair using `mapFn`
  */
 export declare function combineLatestMapFrom<A, B, C>(combineObs: Observable<B>, mapFn: (a: A, b: B) => C): OperatorFunction<A, C>;
 /**
  * Creates an observable that emits a starting value, then a second value after a delay.
  *
  * If the delay is not provided, or is falsy, then the second value is never emitted.
+ *
+ * @param startWith - the value to emit immediately
+ * @param endWith - the value to emit after the delay
+ * @param delayTime - optional delay in milliseconds before emitting the second value
+ * @returns an observable that emits `startWith` immediately and `endWith` after the delay (if provided)
  */
 export declare function emitDelayObs<T>(startWith: T, endWith: T, delayTime: Maybe<Milliseconds>): Observable<T>;
 /**
  * Emits a value after a given delay after every new emission.
+ *
+ * @param value - the value to emit after the delay
+ * @param delayTime - duration in milliseconds before emitting the value
+ * @returns operator that appends the given value after each source emission with the specified delay
  */
 export declare function emitAfterDelay<T>(value: T, delayTime: Milliseconds): MonoTypeOperatorFunction<T>;

package/src/lib/subscription.d.ts

@@ -26,6 +26,8 @@ export declare class SubscriptionObject<T extends Unsubscribable = Unsubscribabl
     constructor(sub?: Maybe<T>);
     /**
      * Whether a subscription is currently being managed.
+     *
+     * @returns true if a subscription is currently active
      */
     get hasSubscription(): boolean;
     /**
@@ -77,6 +79,8 @@ export declare class MultiSubscriptionObject<T extends Unsubscribable = Unsubscr
     constructor(subs?: ArrayOrValue<T>);
     /**
      * Whether any subscriptions are currently being managed.
+     *
+     * @returns true if one or more subscriptions are currently active
      */
     get hasSubscription(): boolean;
     /**

package/src/lib/work/work.factory.d.ts

@@ -52,6 +52,8 @@ export interface WorkFactoryConfig<T, O> {
  * ```
  *
  * @param config - work function and delegate configuration
+ * @param config.work - the work function to execute for each input value
+ * @param config.delegate - delegate that receives lifecycle callbacks (start, success, reject)
  * @returns a factory function that creates WorkInstance for each input
  */
 export declare function workFactory<T, O>({ work, delegate }: WorkFactoryConfig<T, O>): WorkFactory<T, O>;

package/src/lib/work/work.instance.d.ts

@@ -61,7 +61,7 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
      *
      * If the loading state returns an error, the error is forwarded.
      *
-     * @param loadingStateObs
+     * @param loadingStateObs - observable of the loading state to track as the work result
      */
     startWorkingWithLoadingStateObservable(loadingStateObs: Observable<Maybe<LoadingState<O>>>): void;
     /**
@@ -71,7 +71,8 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
      *
      * It is used in conjunction with startWorking() and ideal for cases where multiple observables or promises are used.
      *
-     * @param loadingStateObs
+     * @param loadingStateObs - promise or observable of the loading state to track for errors
+     * @returns a promise that resolves with the value from the loading state or rejects on error
      */
     performTaskWithLoadingState<T>(loadingStateObs: Promise<LoadingState<T>> | Observable<Maybe<LoadingState<T>>>): Promise<T>;
     /**
@@ -79,15 +80,19 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
      *
      * If an error is thrown, the error is forwarded to the reject function.
      *
-     * @param fn
+     * @param fn - synchronous function that returns the result value or throws an error
      */
     performTaskWithReturnValue(fn: () => O): void;
     /**
      * Begins working using a promise.
+     *
+     * @param promise - the promise that represents the asynchronous work
      */
     startWorkingWithPromise(promise: Promise<O>): void;
     /**
      * Begins working using an observable.
+     *
+     * @param workObs - the observable that represents the asynchronous work and emits the result
      */
     startWorkingWithObservable(workObs: Observable<O>): void;
     /**
@@ -96,10 +101,14 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
     startWorking(): void;
     /**
      * Sets success on the work.
+     *
+     * @param result - the successful result value to pass to the delegate
      */
     success(result?: O): void;
     /**
      * Sets rejected on the work.
+     *
+     * @param error - the error to pass to the delegate as the rejection reason
      */
     reject(error?: ErrorInput): void;
     destroy(): void;