@dereekb/rxjs 13.11.13 → 13.11.15

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

@@ -3,44 +3,44 @@ import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction }
 /**
  * RxJS operator that checks whether the emitted `Set` contains all values from the given observable.
  *
- * @param valuesObs - observable of values to check against
- * @returns an operator that emits true if all values are contained in the set
+ * @param valuesObs - Observable of values to check against.
+ * @returns An operator that emits true if all values are contained in the set.
  */
 export declare function setContainsAllValuesFrom<T>(valuesObs: Observable<Maybe<Iterable<T>>>): OperatorFunction<Set<T>, boolean>;
 /**
  * RxJS operator that checks whether the emitted `Set` contains any value from the given observable.
  *
- * @param valuesObs - observable of values to check against
- * @returns an operator that emits true if any value is contained in the set
+ * @param valuesObs - Observable of values to check against.
+ * @returns An operator that emits true if any value is contained in the set.
  */
 export declare function setContainsAnyValueFrom<T>(valuesObs: Observable<Maybe<Iterable<T>>>): OperatorFunction<Set<T>, boolean>;
 /**
  * RxJS operator that checks whether the emitted `Set` contains none of the values from the given observable.
  *
- * @param valuesObs - observable of values to check against
- * @returns an operator that emits true if no values are contained in the set
+ * @param valuesObs - Observable of values to check against.
+ * @returns An operator that emits true if no values are contained in the set.
  */
 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
+ * @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>;
 /**
  * `distinctUntilChanged` variant that extracts iterable values from the emitted item and only emits
  * 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
+ * @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 extends Maybe<unknown>, V extends Iterable<PrimativeKey>>(readValues: ReadValueFunction<NonNullable<I>, V>): MonoTypeOperatorFunction<I>;
 /**
  * `distinctUntilChanged` variant that extracts values from the emitted item and compares them
  * using a custom equality comparator.
  *
- * @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
+ * @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 extends Maybe<unknown>, V>(readValues: ReadValueFunction<NonNullable<I>, V>, isEqualComparator: EqualityComparatorFunction<V>): MonoTypeOperatorFunction<I>;

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

@@ -13,6 +13,9 @@ export interface SearchStringFilterConfig<T> {
  * Combines the source array with the `search$` observable and applies the configured
  * search string filter function. When the search is null/undefined, all items pass through.
  *
+ * @param config - Search filter configuration with filter function and search$ observable.
+ * @returns An operator that filters arrays by search string.
+ *
  * @example
  * ```ts
  * const items$ = of(['apple', 'banana', 'cherry']);
@@ -23,8 +26,5 @@ export interface SearchStringFilterConfig<T> {
  * ).subscribe(console.log);
  * // ['banana']
  * ```
- *
- * @param config - search filter configuration with filter function and search$ observable
- * @returns an operator that filters arrays by search string
  */
 export declare function filterWithSearchString<T>(config: SearchStringFilterConfig<T>): MonoTypeOperatorFunction<T[]>;

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

@@ -5,24 +5,24 @@ import { type Getter, type GetterOrValue } from '@dereekb/util';
  *
  * After the timeout, the default value is prepended and the source continues normally.
  *
- * @param defaultValue - value or getter to use as the default
- * @param first - timeout in ms before emitting the default (defaults to 0)
- * @returns an operator that provides a fallback on slow emissions
+ * @param defaultValue - Value or getter to use as the default.
+ * @param first - Timeout in ms before emitting the default (defaults to 0)
+ * @returns An operator that provides a fallback on slow emissions.
  */
 export declare function timeoutStartWith<T>(defaultValue: GetterOrValue<T>, first?: number): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that executes a side-effect function if the source does not emit within the given timeout.
  *
- * @param timeoutDelay - timeout in ms before triggering the side-effect
- * @param useFn - side-effect function to call on timeout
- * @returns an operator that taps after timeout
+ * @param timeoutDelay - Timeout in ms before triggering the side-effect.
+ * @param useFn - Side-effect function to call on timeout.
+ * @returns An operator that taps after timeout.
  */
 export declare function tapAfterTimeout<T>(timeoutDelay: number, useFn: () => void): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that throws an error if the source does not emit within the given timeout.
  *
- * @param timeoutDelay - timeout in ms before throwing
- * @param error - getter that produces the error to throw
- * @returns an operator that throws on timeout
+ * @param timeoutDelay - Timeout in ms before throwing.
+ * @param error - Getter that produces the error to throw.
+ * @returns An operator that throws on timeout.
  */
 export declare function throwErrorAfterTimeout<T>(timeoutDelay: number, error: Getter<unknown>): MonoTypeOperatorFunction<T>;

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

@@ -3,7 +3,7 @@ import { type Observable } from 'rxjs';
  * Subscribes to the observable, calls the provided function with the first emitted value,
  * then automatically unsubscribes.
  *
- * @param obs - the source observable
- * @param useFn - function to call with the first value
+ * @param obs - The source observable.
+ * @param useFn - Function to call with the first value.
  */
 export declare function useFirst<T>(obs: Observable<T>, useFn: (value: T) => void): void;

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

@@ -21,8 +21,9 @@ export type IsModifiedFunction<T = unknown> = IsCheckFunction<T>;
 /**
  * Creates an {@link IsModifiedFunction} by inverting the result of an {@link IsEqualFunction}.
  *
- * @param isEqualFunction - equality check function to invert
- * @returns a function that returns true when the value has been modified
+ * @param isEqualFunction - Equality check function to invert.
+ * @returns Predicate that reports true whenever the underlying equality check signals inequality.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function makeIsModifiedFunction<T>(isEqualFunction: IsEqualFunction<T>): IsModifiedFunction<T>;
@@ -51,35 +52,38 @@ export interface MakeIsModifiedFunctionObservableConfig<T = unknown> {
  * Prefers `isModified` over `isEqual` (which is inverted), falling back to `defaultFunction`
  * or a function that always returns true.
  *
- * @param config - configuration with isModified, isEqual, and/or defaultFunction
- * @returns an observable of the resolved IsModifiedFunction
+ * @param config - Configuration with isModified, isEqual, and/or defaultFunction.
+ * @returns An observable of the resolved IsModifiedFunction.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function makeIsModifiedFunctionObservable<T>(config: MakeIsModifiedFunctionObservableConfig<T>): Observable<IsModifiedFunction<T>>;
 /**
  * Creates a function that returns the value if the check function returns true, otherwise undefined.
  *
- * @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
+ * @param isCheckFunction - Optional check function.
+ * @param defaultValueOnMaybe - Default result for null/undefined values.
+ * @returns Function that yields the input value when it passes the check, or undefined otherwise.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function makeReturnIfIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<Maybe<T>>;
 /**
  * Returns the value wrapped in an observable if the check function passes, otherwise emits undefined.
  *
- * @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
+ * @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>>;
 /**
  * Creates a function that checks a value against the check function and returns an observable boolean.
  *
- * @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
+ * @param isCheckFunction - Optional check function.
+ * @param defaultValueOnMaybe - Default result for null/undefined values.
+ * @returns Function that emits whether the supplied value passes the check, falling back to the default for missing values.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function makeCheckIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<boolean>;
@@ -88,16 +92,16 @@ export declare function makeCheckIsFunction<T>(isCheckFunction: Maybe<IsModified
  *
  * Returns `of(true)` when no check function is provided.
  *
- * @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
+ * @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
+ * @returns Operator that filters out null and undefined emissions.
  */
 export declare function filterMaybe<T>(): OperatorFunction<Maybe<T>, T>;
 /**
@@ -107,33 +111,33 @@ export declare const filterMaybeStrict: <T>() => OperatorFunction<Maybe<T>, Mayb
 /**
  * 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
+ * @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
+ * @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
+ * @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
+ * @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>;
 /**
  * RxJS operator that switches to the emitted observable if defined, or emits the default value if null/undefined.
  *
- * @param defaultValue - fallback value when the observable is nullish (defaults to undefined)
- * @returns an operator that handles optional observables
+ * @param defaultValue - Fallback value when the observable is nullish (defaults to undefined)
+ * @returns An operator that handles optional observables.
  */
 export declare function switchMapMaybeDefault<T = unknown>(defaultValue?: Maybe<T>): OperatorFunction<Maybe<Observable<Maybe<T>>>, Maybe<T>>;
 /**
@@ -158,8 +162,8 @@ 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
+ * @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>>;
 /**
@@ -200,36 +204,36 @@ export declare function switchMapOnBoolean<T = unknown>(switchOnValue: boolean,
  *
  * 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
+ * @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
+ * @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>>;
 /**
  * RxJS operator that applies a map function only when the emitted value is non-null/non-undefined.
  *
- * @param mapFn - function to transform defined values
- * @returns an operator that maps defined values and passes through undefined
+ * @param mapFn - Function to transform defined values.
+ * @returns An operator that maps defined values and passes through undefined.
  */
 export declare function mapMaybe<A, B>(mapFn: MapFunction<A, Maybe<B>>): OperatorFunction<Maybe<A>, Maybe<B>>;
 /**
  * RxJS operator that applies a map function only when the decision function returns true.
  *
- * @param mapFn - function to transform the value
- * @param decision - predicate that determines whether to apply the map
- * @returns an operator that conditionally maps values
+ * @param mapFn - Function to transform the value.
+ * @param decision - Predicate that determines whether to apply the map.
+ * @returns An operator that conditionally maps values.
  */
 export declare function mapIf<A, B>(mapFn: MapFunction<Maybe<A>, Maybe<B>>, decision: DecisionFunction<Maybe<A>>): OperatorFunction<Maybe<A>, Maybe<B>>;
 /**
  * Combines the source observable with another observable via `combineLatest`, then maps the pair to a result.
  *
- * @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`
+ * @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>;
 /**
@@ -237,17 +241,17 @@ export declare function combineLatestMapFrom<A, B, C>(combineObs: Observable<B>,
  *
  * 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)
+ * @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
+ * @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

@@ -21,13 +21,13 @@ import { type ArrayOrValue, type Destroyable, type Maybe } from '@dereekb/util';
 export declare class SubscriptionObject<T extends Unsubscribable = Unsubscribable> implements Destroyable {
     private _subscription?;
     /**
-     * @param sub - optional initial subscription to manage
+     * @param sub - Optional initial subscription to manage.
      */
     constructor(sub?: Maybe<T>);
     /**
      * Whether a subscription is currently being managed.
      *
-     * @returns true if a subscription is currently active
+     * @returns True if a subscription is currently active.
      */
     get hasSubscription(): boolean;
     /**
@@ -37,7 +37,7 @@ export declare class SubscriptionObject<T extends Unsubscribable = Unsubscribabl
     /**
      * Replaces the current subscription with the given one, unsubscribing from the previous.
      *
-     * @param sub - new subscription to manage, or `undefined`/`void` to just unsubscribe
+     * @param sub - New subscription to manage, or `undefined`/`void` to just unsubscribe.
      */
     setSub(sub: Maybe<T | void>): void;
     /**
@@ -74,13 +74,13 @@ export declare class SubscriptionObject<T extends Unsubscribable = Unsubscribabl
 export declare class MultiSubscriptionObject<T extends Unsubscribable = Unsubscribable> implements Destroyable {
     private _subscriptions?;
     /**
-     * @param subs - optional initial subscription(s) to manage
+     * @param subs - Optional initial subscription(s) to manage.
      */
     constructor(subs?: ArrayOrValue<T>);
     /**
      * Whether any subscriptions are currently being managed.
      *
-     * @returns true if one or more subscriptions are currently active
+     * @returns True if one or more subscriptions are currently active.
      */
     get hasSubscription(): boolean;
     /**
@@ -90,13 +90,13 @@ export declare class MultiSubscriptionObject<T extends Unsubscribable = Unsubscr
     /**
      * Replaces all managed subscriptions with the given ones, unsubscribing from all previous.
      *
-     * @param subs - new subscription(s) to manage
+     * @param subs - New subscription(s) to manage.
      */
     setSubs(subs: ArrayOrValue<T>): void;
     /**
      * Adds subscription(s) to the managed set without affecting existing ones. Duplicate subscriptions are ignored.
      *
-     * @param subs - subscription(s) to add
+     * @param subs - Subscription(s) to add.
      */
     addSubs(subs: ArrayOrValue<T>): void;
     /**

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

@@ -40,6 +40,11 @@ export interface WorkFactoryConfig<T, O> {
  * If the work function returns an observable, it is automatically subscribed to. If it uses
  * the handler directly, the observable return is ignored.
  *
+ * @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.
+ *
  * @example
  * ```ts
  * const factory = workFactory({
@@ -51,10 +56,6 @@ export interface WorkFactoryConfig<T, O> {
  * // instance tracks the work lifecycle
  * ```
  *
- * @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
  * @__NO_SIDE_EFFECTS__
  */
 export declare function workFactory<T, O>({ work, delegate }: WorkFactoryConfig<T, O>): WorkFactory<T, O>;
@@ -67,8 +68,9 @@ export type WorkFactoryConfigFactory<T, O> = FactoryWithRequiredInput<WorkFactor
  * Creates a {@link WorkFactory} that generates a new {@link WorkFactoryConfig} for each input,
  * enabling dynamic work and delegate selection per invocation.
  *
- * @param configFactory - factory that produces work configuration from the input value
- * @returns a work factory with per-invocation configuration
+ * @param configFactory - Factory that produces work configuration from the input value.
+ * @returns A work factory with per-invocation configuration.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function workFactoryForConfigFactory<T, O>(configFactory: WorkFactoryConfigFactory<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 - observable of the loading state to track as the work result
+     * @param loadingStateObs - Observable of the loading state to track as the work result.
      */
     startWorkingWithLoadingStateObservable(loadingStateObs: Observable<Maybe<LoadingState<O>>>): void;
     /**
@@ -71,8 +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 - 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
+     * @param loadingStateObs - Promise or observable of the loading state to track for errors.
+     * @returns Resolves with the first non-loading value, or rejects when the loading state surfaces an error.
      */
     performTaskWithLoadingState<T>(loadingStateObs: Promise<LoadingState<T>> | Observable<Maybe<LoadingState<T>>>): Promise<T>;
     /**
@@ -80,19 +80,20 @@ 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 - synchronous function that returns the result value or throws an error
+     * @param fn - Synchronous function that returns the result value or throws an error.
+     * @throws Re-throws the error from `fn` after forwarding it to the reject function.
      */
     performTaskWithReturnValue(fn: () => O): void;
     /**
      * Begins working using a promise.
      *
-     * @param promise - the promise that represents the asynchronous work
+     * @param promise - Asynchronous work whose resolved value should be tracked as the work result.
      */
     startWorkingWithPromise(promise: Promise<O>): void;
     /**
      * Begins working using an observable.
      *
-     * @param workObs - the observable that represents the asynchronous work and emits the result
+     * @param workObs - The observable that represents the asynchronous work and emits the result.
      */
     startWorkingWithObservable(workObs: Observable<O>): void;
     /**
@@ -102,13 +103,13 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
     /**
      * Sets success on the work.
      *
-     * @param result - the successful result value to pass to the delegate
+     * @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
+     * @param error - The error to pass to the delegate as the rejection reason.
      */
     reject(error?: ErrorInput): void;
     destroy(): void;