uneventful 0.0.1

package/dist/mod.d.ts

@@ -0,0 +1,1895 @@
+/**
+ * Invoke a no-argument function as a microtask, using queueMicrotask or Promise.resolve().then()
+ *
+ * @category Scheduling
+ */
+declare let defer: (cb: () => any) => void;
+
+/**
+ * Resolve a {@link Request} with a value.
+ *
+ * (For a curried version, see {@link resolver}.)
+ *
+ * @category Requests and Results
+ */
+declare function resolve<T>(request: Request<T>, val: T): void;
+/**
+ * Reject a {@link Request} with a reason.
+ *
+ * (For a curried version, see {@link rejecter}.)
+ *
+ * @category Requests and Results
+ */
+declare function reject(request: Request<any>, reason: any): void;
+/**
+ * Create a callback that will resolve the given {@link Request} with a value.
+ *
+ * @category Requests and Results
+ */
+declare function resolver<T>(request: Request<T>): (val: T) => void;
+/**
+ * Create a callback that will reject the given {@link Request} with a reason.
+ *
+ * @category Requests and Results
+ */
+declare function rejecter(request: Request<any>): (err: any) => void;
+/**
+ * A function that does nothing and returns void.
+ *
+ * @category Stream Consumers
+ */
+declare function noop(): void;
+/**
+ * An {@link ErrorResult} that hasn't yet been "handled" (by being passed to an
+ * error-specific handler, converted to a promise, given to {@link markHandled},
+ * etc.)
+ *
+ * @category Types and Interfaces
+ */
+type UnhandledError = {
+    op: "throw";
+    val: undefined;
+    err: any;
+};
+/**
+ * An {@link ErrorResult} that has been marked "handled" (by being passed to an
+ * error-specific handler, converted to a promise, given to {@link markHandled},
+ * etc.)
+ *
+ * @category Types and Interfaces
+ */
+type HandledError = {
+    op: "throw";
+    val: null;
+    err: any;
+};
+/**
+ * A result passed to a job's cleanup callbacks, or supplied by its
+ * .{@link Job.result result}() method.
+ *
+ * You can inspect a JobResult using functions like {@link isCancel}(),
+ * {@link isError}(), and {@link isValue}().  {@link getResult}() can be used to
+ * unwrap the value or throw the error.
+ *
+ * @category Types and Interfaces
+ */
+type JobResult<T> = ValueResult<T> | ErrorResult | CancelResult;
+/**
+ * A {@link JobResult} that indicates the job was canceled by its creator (via
+ * end() or restart()).
+ *
+ * @category Types and Interfaces
+ */
+type CancelResult = {
+    op: "cancel";
+    val: undefined;
+    err: undefined;
+};
+/**
+ * The {@link JobResult} used to indicate a canceled job.
+ *
+ * @category Requests and Results
+ */
+declare const CancelResult: Readonly<CancelResult>;
+/**
+ * A {@link JobResult} that indicates the job was ended via a return() value.
+ *
+ * @category Types and Interfaces
+ */
+type ValueResult<T> = {
+    op: "next";
+    val: T;
+    err: undefined;
+};
+/**
+ * Create a {@link ValueResult} from a value
+ *
+ * @category Requests and Results
+ */
+declare function ValueResult<T>(val: T): ValueResult<T>;
+/**
+ * A {@link JobResult} that indicates the job was ended via a throw() or other
+ * error.
+ *
+ * @category Types and Interfaces
+ */
+type ErrorResult = UnhandledError | HandledError;
+/**
+ * Create an {@link ErrorResult} from an error
+ *
+ * @category Requests and Results
+ */
+declare function ErrorResult(err: any): UnhandledError;
+/**
+ * Returns true if the given result is a {@link CancelResult}.
+ *
+ * @category Requests and Results
+ */
+declare function isCancel(res: JobResult<any> | undefined): res is CancelResult;
+/**
+ * Returns true if the given result is a {@link ValueResult}.
+ *
+ * @category Requests and Results
+ */
+declare function isValue<T>(res: JobResult<T> | undefined): res is ValueResult<T>;
+/**
+ * Returns true if the given result is a {@link ErrorResult}.
+ *
+ * @category Requests and Results
+ */
+declare function isError(res: JobResult<any> | undefined): res is ErrorResult;
+/**
+ * Returns true if the given result is an {@link UnhandledError}.
+ *
+ * @category Requests and Results
+ */
+declare function isUnhandled(res: JobResult<any> | undefined): res is UnhandledError;
+/**
+ * Returns true if the given result is a {@link HandledError} (an
+ * {@link ErrorResult} that has been touched by {@link markHandled}).
+ *
+ * @category Requests and Results
+ */
+declare function isHandled(res: JobResult<any> | undefined): res is HandledError;
+/**
+ * Return the error of an {@link ErrorResult} and mark it as handled. The
+ * {@link ErrorResult} is mutated in-place to become a {@link HandledError}.
+ *
+ * @category Requests and Results
+ */
+declare function markHandled(res: ErrorResult): any;
+/**
+ * Get the return value from a {@link JobResult}, throwing an appropriate error
+ * if the result isn't a {@link ValueResult}.
+ *
+ * @param res The job result you want to unwrap.  Must not be undefined!
+ *
+ * @returns The value if the result is a {@link ValueResult}, or a thrown error
+ * if it's an {@link ErrorResult}.  A {@link CancelError} is thrown if the job
+ * was canceled, or the error in the result is thrown.
+ *
+ * If the result is an error, it is marked as handled.
+ *
+ * @category Jobs
+ */
+declare function getResult<T>(res: JobResult<T>): T;
+/**
+ * Fulfill a Promise from a {@link JobResult}
+ *
+ * If the result is a {@link CancelResult}, the promise is rejected with a
+ * {@link CancelError}.  Otherwise it is resolved or rejected according to the
+ * state of the result.
+ *
+ * @param resolve A value-taking function (first arg to `new Promise` callback)
+ *
+ * @param reject An error-taking function (second arg to `new Promise` callback)
+ *
+ * @param res The job result you want to settle the promise with.  An error will
+ * be thrown if it's undefined.
+ *
+ * If the result is an error, it is marked as handled.
+ *
+ * @category Requests and Results
+ */
+declare function fulfillPromise<T>(resolve: (v: T) => void, reject: (e: any) => void, res: JobResult<T>): void;
+/**
+ * Propagate a {@link JobResult} to another job
+ *
+ * If the result is a {@link CancelResult}, the job will throw with a
+ * {@link CancelError}.  Otherwise it is resolved or rejected according to the
+ * state of the result.
+ *
+ * @param job The job to terminate.  If it's already ended, nothing changes: the
+ * result is not propagated and the error (if any) is not marked as handled.
+ *
+ * @param res The job result you want to settle the job with.  An error will be
+ * thrown if it's undefined.  If the result is an error, it is marked as
+ * handled.
+ *
+ * @category Requests and Results
+ */
+declare function propagateResult<T>(job: Job<T>, res: JobResult<T>): void;
+/**
+ * Error thrown when waiting for a result from a job that is canceled.
+ *
+ * If you `await`, `yield *`, `.then()`, `.catch()`, {@link getResult}() or
+ * otherwise wait on the result of a job that is canceled, this is the type
+ * of error you'll get.
+ *
+ * @category Errors
+ */
+declare class CancelError extends Error {
+}
+
+/**
+ * The result type returned from calls to {@link Each}.next()
+ *
+ * @category Types and Interfaces
+ */
+type EachResult<T> = {
+    /** The value provided by the source being iterated */
+    item: T;
+    /**
+     * A suspend callback that must be `yield`-ed before the next call to the
+     * iterator's .next() method. (That is, you must `yield next` it exactly once
+     * per loop pass.  See {@link each}() for more details.)
+     */
+    next: Suspend<void>;
+};
+/**
+ * The iterable returned by `yield *` {@link each}()
+ *
+ * @category Types and Interfaces
+ */
+type Each<T> = IterableIterator<EachResult<T>>;
+/**
+ * Asynchronously iterate over an event source
+ *
+ * Usage:
+ *
+ * ```ts
+ * for (const {item: event, next} of yield *each(mouseMove)) {
+ *     console.log(event.clientX, event.clientY);
+ *     yield next;  // required exactly once per iteration, even/w continue!
+ * }
+ * ```
+ *
+ * each(eventSource) yield-returns an iterator of `{item, next}` pairs.  The
+ * item is the data supplied by the event source, and `next` is a
+ * {@link Suspend}\<void\> that advances the iterator to the next item.  It
+ * *must* be yielded exactly once per loop iteration.  If you use `continue` to
+ * shortcut the loop body, you must `yield next` *before* doing so.
+ *
+ * The for-loop will end if the source ends, errors, or is canceled.  The source
+ * is paused while the loop body is running, and resumed when the `yield next`
+ * happens.  If events arrive anyway (e.g. because the source doesn't support
+ * pausing), they will be ignored unless you pipe the source through the
+ * {@link slack}() operator to provide a buffer. If the for-loop is exited
+ * early for any reason (or the iterator's `.return()` is called), the source is
+ * unsubscribed and the iteration ended.
+ *
+ * @category Stream Consumers
+ */
+declare function each<T>(src: Source<T>): Yielding<Each<T>>;
+/**
+ * An object that can be waited on with `yield *until()`.
+ *
+ * @category Types and Interfaces
+ */
+type Waitable<T> = UntilMethod<T> | Source<T> | Promise<T> | PromiseLike<T>;
+/**
+ * An object that can be waited on with `yield *until()`, by calling its
+ * "uneventful.until" method.
+ *
+ * @category Types and Interfaces
+ */
+interface UntilMethod<T> {
+    "uneventful.until"(): Yielding<T>;
+}
+/**
+ * Wait for and return next value (or error) from a data source when processed
+ * with `yield *` within a {@link Job}.
+ *
+ * @param source A {@link Waitable} data source, which can be any of:
+ * - A {@link Signal} (in which case the job will resume when the value is
+ *   truthy - perhaps immediately!)
+ * - A {@link Source}
+ * - A promise, or promise-like object with a `.then()` method
+ * - An object with an `"uneventful.until"` method returning a {@link Yielding}
+ *   (in which case the result will be the the result of that method)
+ *
+ * @returns a Yieldable that when processed with `yield *` in a job, will return
+ * the triggered event, promise resolution, or signal value.  An error is thrown
+ * if the promise rejects or the event stream throws or closes early, or the
+ * signal throws.
+ *
+ * @category Scheduling
+ */
+declare function until<T>(source: Waitable<T>): Yielding<T>;
+
+/**
+ * Error indicating a rule has attempted to write a value it indirectly
+ * depends on, or which has already been read by another rule in the current
+ * batch. (Also thrown when a cached function attempts to write a value at all,
+ * directly or inidirectly.)
+ *
+ * @category Errors
+ */
+declare class WriteConflict extends Error {
+}
+/**
+ * Error indicating a rule has attempted to write a value it directly depends
+ * on, or a cached function has called itself, directly or indirectly.
+ *
+ * @category Errors
+ */
+declare class CircularDependency extends Error {
+}
+/**
+ * A queue for rules to run during a particular kind of period, such as
+ * microtasks or animation frames.  (Can only be obtained or created via
+ * {@link RuleScheduler.for}().)
+ *
+ * @category Signals
+ */
+declare class RuleScheduler {
+    /**
+     * Run all pending rules on this scheduler.
+     *
+     * This is a bound method
+     *
+     * (Note: "pending" rules are ones with at least one changed ancestor
+     * dependency; this doesn't mean they will actually *do* anything,
+     * since intermediate cached() function results might end up unchanged.)
+     */
+    flush: () => void;
+    /**
+     * Create an {@link RuleScheduler} from a callback-taking function, that
+     * you can then use to make rules that run in a specific time frame.
+     *
+     * ```ts
+     * // frame.rule will now create rules that run during animation fames
+     * const animate = RuleScheduler.for(requestAnimationFrame).rule;
+     *
+     * animate(() => {
+     *     // ... do stuff in an animation frame when signals used here change
+     * })
+     * ```
+     *
+     * Returns the default scheduler if no arguments are given.  If called with
+     * the same function more than once, it returns the same scheduler instance.
+     *
+     * @param scheduleFn A single-argument scheduling function (like
+     * requestAnimationFrame, setImmediate, or queueMicrotask).  The scheduler
+     * will call it from time to time with a single callback.  The scheduling
+     * function should then arrange for that callback to be invoked *once* at
+     * some future point, when it is the desired time for all pending rules on
+     * that scheduler to run.
+     */
+    static for(scheduleFn?: (cb: () => unknown) => unknown): RuleScheduler;
+    protected constructor(_scheduleFn?: (cb: () => unknown) => unknown);
+    /**
+     * @inheritdoc rule tied to a specific scheduler.  See {@link rule} for
+     * more details.
+     *
+     * @remarks The rule will only run during its matching
+     * {@link RuleScheduler.flush}().
+     *
+     * This is a bound method, so you can use it independently of the scheduler
+     * it came from.
+     */
+    rule: (fn: (stop: DisposeFn) => OptionalCleanup) => DisposeFn;
+}
+/**
+ * Subscribe a function to run every time certain values change.
+ *
+ * @remarks
+ * The function is run asynchronously, first after being created, then again
+ * after there are changes in any of the values or cached functions it read
+ * during its previous run.
+ *
+ * The created subscription is tied to the currently-active job (which may be
+ * another rule).  So when that job is ended or restarted, the rule will be
+ * terminated automatically.  You can also terminate it early by calling the
+ * "stop" function that is both passed to the rule function and returned by
+ * `rule()`.
+ *
+ * Note: this function will throw an error if called without an active job. If
+ * you need a standalone rule, use {@link detached}.run to wrap the
+ * call to rule.
+ *
+ * @param fn The function that will be run each time its dependencies change.
+ * The function will be run in a restarted job each time, with any resources
+ * used by the previous run being cleaned up.  The function is passed a single
+ * argument: a function that can be called to terminate the rule.   The function
+ * should return a cleanup function or void.
+ *
+ * @returns A function that can be called to terminate the rule.
+ *
+ * @category Signals
+ */
+declare const rule: (fn: (stop: DisposeFn) => OptionalCleanup) => DisposeFn;
+/**
+ * Synchronously run pending rules from the default scheduler.
+ *
+ * @remarks Equivalent to calling
+ * {@link RuleScheduler.for}(defer).{@link RuleScheduler.flush flush}().
+ *
+ * Note that you should normally only need to call this when you need
+ * side-effects to occur within a specific synchronous timeframe, e.g. if
+ * rules need to be able to cancel a synchronous event or continue an
+ * IndexedDB transaction.  (You can also define rules to run in a specific
+ * timeframe by creating a {@link RuleScheduler} for them, via
+ * {@link RuleScheduler.for}.)
+ *
+ * @category Signals
+ */
+declare const runRules: () => void;
+
+interface Signal<T> {
+    /**
+     * A signal object implements the {@link Producer} interface, even if it's
+     * not directly recognized as one by TypeScript.
+     */
+    (sink: Sink<T>, conn?: Connection, inlet?: Inlet): typeof IsStream;
+    /** A signal object can be called to get its current value */
+    (): T;
+}
+/**
+ * An observable value, as a zero-argument callable with extra methods.
+ *
+ * Note: this class is not directly instantiable - use {@link cached}() or call
+ * {@link readonly |.readonly()} on an existing signal instead.
+ *
+ * @category Types and Interfaces
+ */
+declare class Signal<T> extends Function implements UntilMethod<T> {
+    /** The current value */
+    get value(): T;
+    /** The current value */
+    valueOf(): T;
+    /** The current value, as a string */
+    toString(): string;
+    /** The current value */
+    toJSON(): T;
+    /** Get the signal's current value, without adding the signal as a dependency */
+    peek(): T;
+    /** Get a read-only version of this signal */
+    readonly(): Signal<T>;
+    /** New writable signal with a custom setter */
+    withSet(set: (v: T) => unknown): Writable<T>;
+    "uneventful.until"(): Yielding<T>;
+    protected constructor();
+}
+interface Writable<T> {
+    /** Set the current value.  (Note: this is a bound method so it can be used as a callback.) */
+    set(val: T): void;
+}
+/**
+ * A {@link Signal} with a {@link Writable.set | .set()} method and writable
+ * {@link Writable.value | .value} property.
+ *
+ * Note: this class is not directly instantiable - use {@link value}() or call
+ * {@link Signal.withSet | .withSet()} on an existing signal instead.
+ *
+ * @category Types and Interfaces
+ */
+declare class Writable<T> extends Signal<T> {
+    get value(): T;
+    set value(val: T);
+    readonly(): Signal<T>;
+}
+/**
+ * Create a {@link Writable} signal with the given inital value
+ *
+ * @category Signals
+ */
+declare function value<T>(val?: T): Writable<T>;
+/**
+ * Create a cached version of a function.  The returned callable is also a
+ * {@link Signal}.
+ *
+ * Note: If the supplied function has a non-zero `.length` (i.e., it explicitly
+ * takes arguments), it is assumed to be a {@link Source}, and the second
+ * calling signature below will apply, even if TypeScript doesn't see it that
+ * way!)
+ *
+ * @category Signals
+ */
+declare function cached<T>(compute: () => T): Signal<T>;
+/**
+ * If the supplied function has a non-zero `.length` (i.e., it explicitly takes
+ * arguments), it is assumed to be a {@link Source}, and the second argument is
+ * a default value for the created signal to use as default value until the
+ * source produces a value.
+ *
+ * The source will be subscribed *only* while the signal is subscribed as a
+ * stream, or observed (directly or indirectly) by a rule.  While subscribed,
+ * the signal will update itself with the most recent value produced by the
+ * source, triggering rules or events as appropriate if the value changes. When
+ * the signal is once again unobserved, it will revert to the supplied inital
+ * value.
+ *
+ * @param source A {@link Source} providing data which will become this signal's value
+ * @param initVal The value to use when the signal is unobserved or waiting for the
+ * first item from the source.
+ */
+declare function cached<T>(source: Source<T>, initVal?: T): Signal<T>;
+declare function cached<T extends Signal<any>>(signal: T): T;
+/**
+ * Call a function without creating a dependency on any signals it reads.  (Like
+ * {@link Signal.peek}, but for any function with any arguments.)
+ *
+ * You can also pass in any arguments the function takes, and the function's
+ * return value is returned.
+ *
+ * @returns The result of calling `fn(..args)`
+ *
+ * @category Signals
+ */
+declare function noDeps<F extends PlainFunction>(fn: F, ...args: Parameters<F>): ReturnType<F>;
+/**
+ * Arrange for the current signal or rule to recalculate on demand
+ *
+ * This lets you interop with systems that have a way to query a value and
+ * subscribe to changes to it, but not directly produce a signal.  (Such as
+ * querying the DOM state and using a MutationObserver.)
+ *
+ * By calling this with a {@link Source} or {@link RecalcSource}, you arrange
+ * for it to be subscribed, if and when the call occurs in a rule or a cached
+ * function that's in use by a rule (directly or indirectly).  When the source
+ * emits a value, the signal machinery will invalidate the caching of the
+ * function or rule, forcing a recalculation and subsequent rule reruns, if
+ * applicable.
+ *
+ * Note: you should generally only call the 1-argument version of this function
+ * with "static" sources - i.e. ones that won't change on every call. Otherwise,
+ * you will end up creating new signals each time, subscribing and unsubscribing
+ * on every call to recalcWhen().
+ *
+ * If the source needs to reference some object, it's best to use the 2-argument
+ * version (i.e. `changesWhen(someObj, factory)`, where `factory` is a function
+ * that takes `someObj` and returns a suitable {@link RecalcSource}.)
+ *
+ * @remarks
+ * recalcWhen is specifically designed so that using it does not pull in any
+ * part of Uneventful's signals framework, in the event a program doesn't
+ * already use it.  This means you can use it in library code to provide signal
+ * compatibility, without adding bundle bloat to code that doesn't use signals.
+ *
+ * @category Signals
+ */
+declare function recalcWhen(src: RecalcSource): void;
+/**
+ * Two-argument variant of recalcWhen
+ *
+ * In certain circumstances, you may wish to use recalcWhen with a source
+ * related to some object.  You could call recalcWhen with a closure, but that
+ * would create and discard signals on every call.  So this 2-argument version
+ * lets you avoid that by allowing the use of an arbitrary object as a key,
+ * along with a factory function to turn the key into a {@link RecalcSource}.
+ *
+ * @param key an object to be used as a key
+ *
+ * @param factory a function that will be called with the key to obtain a
+ * {@link RecalcSource}.  Note that this factory function must also be a static
+ * function, not a closure, or the same memory thrash issue will occur.
+ */
+declare function recalcWhen<T extends WeakKey>(key: T, factory: (key: T) => RecalcSource): void;
+
+/**
+ * A backpressure controller: returns true if downstream is ready to accept
+ * data.
+ *
+ * @param cb (optional) - a callback to run when the downstream consumer wishes
+ * to resume event production (i.e., when a sink calls
+ * {@link Throttle.resume}()).  The callback is automatically unregistered when
+ * invoked, so the producer must re-register it after each call if it wishes to
+ * keep being called.
+ *
+ * @category Types and Interfaces
+ */
+type Backpressure = (cb?: () => any) => boolean;
+/**
+ * Create a backpressure control function for the given connection
+ *
+ * @category Stream Producers
+ */
+declare function backpressure(inlet?: Inlet): Backpressure;
+/**
+ * Control backpressure for listening streams.  This interface is the API
+ * internal to the implementation of {@link backpressure}().  Unless you're
+ * implementing a backpressurable stream yourself, see the {@link Throttle}
+ * interface instead.
+ *
+ * @category Types and Interfaces
+ */
+interface Inlet {
+    /** Is the main connection open?  (i.e. is the creating job not closed yet?) */
+    isOpen(): boolean;
+    /** Is the conduit currently ready to receive data? */
+    isReady(): boolean;
+    /**
+     * Register a callback to produce more data when the inlet is resumed
+     * (The callback is unregistered if the supplied job ends.)
+     */
+    onReady(cb: () => any, job: Job): this;
+}
+/**
+ * Control backpressure for listening streams
+ *
+ * Obtain instances via {@link throttle}(), then pass them into the appropriate
+ * stream-consuming API.  (e.g. {@link connect}).
+ *
+ * @category Types and Interfaces
+ */
+interface Throttle extends Inlet {
+    /** Set inlet status to "paused". */
+    pause(): void;
+    /**
+     * Un-pause, and iterate backpressure-able sources' onReady callbacks to
+     * resume sending immediately.  (i.e., synchronously!)
+     */
+    resume(): void;
+}
+/**
+ * A Connection is a job that returns void when the connected stream ends
+ * itself.  If the stream doesn't end itself (e.g. it's an event listener), the
+ * job will never return, and only end with a cancel or throw.
+ *
+ * @category Types and Interfaces
+ */
+type Connection = Job<void>;
+/**
+ * A Producer is a function that can be called to arrange for data to be
+ * produced and sent to a {@link Sink} function for consumption, until the
+ * associated {@link Connection} is closed (either by the source or the sink,
+ * e.g. if the sink doesn't want more data or the source has no more to send).
+ *
+ * If the source is a backpressurable stream, it can use the (optional) supplied
+ * inlet (usually a {@link throttle}()) to rate-limit its output.
+ *
+ * A producer function *must* return the special {@link IsStream} value, so
+ * TypeScript can tell what functions are usable as sources.  (Otherwise any
+ * void function with no arguments would appear to be usable as a source!)
+ *
+ * @category Types and Interfaces
+ */
+type Producer<T> = (sink: Sink<T>, conn?: Connection, inlet?: Throttle | Inlet) => typeof IsStream;
+/**
+ * A Source is either a {@link Producer} or a {@link Signal}.  (Signals actually
+ * implement the {@link Producer} interface as an overload, but TypeScript gets
+ * confused about that sometimes, so we generally declare our stream *inputs* as
+ * `Source<T>` and our stream *outputs* as {@link Producer}, so that TypeScript
+ * knows what's what.
+ *
+ * @category Types and Interfaces
+ */
+type Source<T> = Producer<T> | Signal<T> | Writable<T>;
+/**
+ * A specially-typed string used to verify that a function supports uneventful's
+ * streaming protocol.  Return it from a function to implement the
+ * {@link Source} type.
+ *
+ * @category Types and Interfaces
+ */
+declare const IsStream: "uneventful/is-stream";
+/**
+ * A `Sink` is a function that receives data from a {@link Source}.
+ *
+ * @category Types and Interfaces
+ */
+type Sink<T> = (val: T) => void;
+/**
+ * A `Transformer` is a function that takes one source and returns another,
+ * possibly one that produces data of a different type.  Most operator functions
+ * return a transformer, allowing them to be combined via {@link pipe}().
+ *
+ * @category Types and Interfaces
+ */
+type Transformer<T, V = T> = (input: Source<T>) => Producer<V>;
+/**
+ * Subscribe a sink to a source, returning a nested job. (Shorthand for
+ * {@link getJob}().{@link Job.connect connect}(...).)
+ *
+ * @param src An event source or finite data stream
+ * @param sink A callback that will receive the events
+ * @param inlet Optional - a {@link throttle}() to control backpressure
+ *
+ * @returns A job that can be aborted to end the subscription, and which will
+ * end naturally (with a void return or error) if the stream ends itself.
+ *
+ * @category Stream Consumers
+ */
+declare function connect<T>(src: Source<T>, sink: Sink<T>, inlet?: Throttle | Inlet): Connection;
+/**
+ * Create a backpressure controller for a stream.  Pass it to one or more
+ * sources you're connecting to, and if they support backpressure they'll
+ * respond when you call its .pause() and .resume() methods.
+ *
+ * @param job - Optional: a job that controls readiness.  (The throttle will
+ * pause indefinitely when the job ends.)  Defaults to the currently-active job,
+ * but unlike most such defaults, it won't throw if no job is active.
+ *
+ * @category Stream Consumers
+ */
+declare function throttle(job?: Job): Throttle;
+/**
+ * Pipe a stream (or anything else) through a series of single-argument
+ * functions/operators
+ *
+ * e.g. the following creates a stream that outputs 4 and then 6:
+ *
+ * ```ts
+ * pipe(fromIterable([1,2,3,4]), skip(1), take(2), map(x => x*2))
+ * ```
+ *
+ * The first argument to pipe() can be any value, but all other arguments must
+ * be functions.  The value is passed to the first function, and then the result
+ * is passed to the next function in turn, until all provided functions have
+ * been called with the result of the previous function.  The return value is
+ * the last result, or the original value if no functions were given.
+ *
+ * The underlying implementation of pipe() works with any number of arguments,
+ * but due to TypeScript limitations we only have typing defined for a max of 9
+ * functions (10 arguments total).  If you need more than 9 functions, you can
+ * stack some of them with {@link compose}(), e.g.:
+ *
+ * ```typescript
+ * pipe(
+ *     aStream,
+ *     compose(op1, op2, ...),
+ *     compose(op10, op11, ...),
+ *     compose(op19, ...),
+ *     ...
+ * )
+ * ```
+ *
+ * @category Stream Operators
+ */
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(input: A, ...fns: Chain9<A, J, B, C, D, E, F, G, H, I>): J;
+declare function pipe<A, B, C, D, E, F, G, H, I>(input: A, ...fns: Chain8<A, I, B, C, D, E, F, G, H>): I;
+declare function pipe<A, B, C, D, E, F, G, H>(input: A, ...fns: Chain7<A, H, B, C, D, E, F, G>): H;
+declare function pipe<A, B, C, D, E, F, G>(input: A, ...fns: Chain6<A, G, B, C, D, E, F>): G;
+declare function pipe<A, B, C, D, E, F>(input: A, ...fns: Chain5<A, F, B, C, D, E>): F;
+declare function pipe<A, B, C, D, E>(input: A, ...fns: Chain4<A, E, B, C, D>): E;
+declare function pipe<A, B, C, D>(input: A, ...fns: Chain3<A, D, B, C>): D;
+declare function pipe<A, B, C>(input: A, ...fns: Chain2<A, C, B>): C;
+declare function pipe<A, B>(input: A, ...fns: Chain1<A, B>): B;
+declare function pipe<A>(input: A): A;
+declare function pipe(input: any, ...fns: Array<(v: any) => any>): any;
+/**
+ * Compose a series of single-argument functions/operators in application order.
+ * (This is basically a deferred version of {@link pipe}().)  For example:
+ *
+ * ```ts
+ * const func = compose(skip(1), take(2), map(x => x*2));
+ * const stream_4_6 = func(fromIterable([1,2,3,4])); // stream that outputs 4, 6
+ * ```
+ *
+ * As with `pipe()`, the declared typings only support composing up to 9
+ * functions at once; if you need more you'll need to nest calls to `compose()`
+ * (i.e. passing the result of a `compose()` as an argument to another
+ * `compose()` call.)
+ *
+ * @returns A function taking the same type as the first input function,
+ * returning the same type as the last input function.
+ *
+ * @category Stream Operators
+ */
+declare function compose<A, B, C, D, E, F, G, H, I, J>(...fns: Chain9<A, J, B, C, D, E, F, G, H, I>): (a: A) => J;
+declare function compose<A, B, C, D, E, F, G, H, I>(...fns: Chain8<A, I, B, C, D, E, F, G, H>): (a: A) => I;
+declare function compose<A, B, C, D, E, F, G, H>(...fns: Chain7<A, H, B, C, D, E, F, G>): (a: A) => H;
+declare function compose<A, B, C, D, E, F, G>(...fns: Chain6<A, G, B, C, D, E, F>): (a: A) => G;
+declare function compose<A, B, C, D, E, F>(...fns: Chain5<A, F, B, C, D, E>): (a: A) => F;
+declare function compose<A, B, C, D, E>(...fns: Chain4<A, E, B, C, D>): (a: A) => E;
+declare function compose<A, B, C, D>(...fns: Chain3<A, D, B, C>): (a: A) => D;
+declare function compose<A, B, C>(...fns: Chain2<A, C, B>): (a: A) => C;
+declare function compose<A, B>(...fns: Chain1<A, B>): (a: A) => B;
+declare function compose<A>(): (a: A) => A;
+type Chain1<A, R> = [(v: A) => R];
+type Chain2<A, R, B> = [...Chain1<A, B>, ...Chain1<B, R>];
+type Chain3<A, R, B, C> = [...Chain1<A, B>, ...Chain2<B, R, C>];
+type Chain4<A, R, B, C, D> = [...Chain1<A, B>, ...Chain3<B, R, C, D>];
+type Chain5<A, R, B, C, D, E> = [...Chain1<A, B>, ...Chain4<B, R, C, D, E>];
+type Chain6<A, R, B, C, D, E, F> = [...Chain1<A, B>, ...Chain5<B, R, C, D, E, F>];
+type Chain7<A, R, B, C, D, E, F, G> = [...Chain1<A, B>, ...Chain6<B, R, C, D, E, F, G>];
+type Chain8<A, R, B, C, D, E, F, G, H> = [...Chain1<A, B>, ...Chain7<B, R, C, D, E, F, G, H>];
+type Chain9<A, R, B, C, D, E, F, G, H, I> = [...Chain1<A, B>, ...Chain8<B, R, C, D, E, F, G, H, I>];
+/**
+ * Pass subscriber into a stream (or any arguments into any other function).
+ *
+ * This utility is mainly here for uses like:
+ *
+ * - `pipe(src, into(sink))`,
+ * - `pipe(src, into(sink, conn))`,
+ * - `pipe(src, into(restarting(sink)))`, etc.
+ *
+ * but can also be used for argument currying generally.
+ *
+ * @param args The arguments to pass to the stream (or other function)
+ *
+ * @returns a function that takes another function and calls it with the given args.
+ *
+ * @category Stream Consumers
+ */
+declare function into<In extends any[], Out>(...args: In): (src: (...args: In) => Out) => Out;
+
+/**
+ * An undefined or null value
+ *
+ * @category Types and Interfaces
+ */
+type Nothing = undefined | null | void;
+/**
+ * A function without a `this`
+ *
+ * @category Types and Interfaces
+ */
+type PlainFunction = (this: void, ...args: any[]) => any;
+/**
+ * Any function
+ *
+ * @category Types and Interfaces
+ */
+type AnyFunction = (...args: any[]) => any;
+/**
+ * A cleanup function is a callback invoked when a job is ended or restarted.
+ * It receives a result that indicates whether the job ended itself with a return
+ * value or error, or was canceled/restarted by its creator.
+ *
+ * @category Types and Interfaces
+ */
+type CleanupFn<T = any> = (res: JobResult<T>) => unknown;
+/**
+ * A function that can be called to dispose of something or unsubscribe
+ * something.  It's called without arguments and returns void.
+ *
+ * @category Types and Interfaces
+ */
+type DisposeFn = () => void;
+/**
+ * An optional cleanup parameter or return.
+ *
+ * @category Types and Interfaces
+ */
+type OptionalCleanup<T = any> = CleanupFn<T> | Nothing;
+/**
+ * An asynchronous start function is called immediately in the new job and must
+ * return a {@link StartObj}, such as a job, generator, or promise.  If a job or
+ * promise is returned, it will be awaited and its result used to asynchronously
+ * set the result of the returned job.
+ *
+ * If a generator is returned, it will be run asynchronously, in the context of
+ * the newly-started job.  Any result it returns or error it throws will be
+ * treated as the result of the job.  If the job is canceled, the iterator's
+ * `.return()` method will be called to abort it (thereby running any
+ * try-finally clauses in the generator), and the result of the call will be
+ * otherwise ignored.
+ *
+ * @template T The type the job will end up returning
+ * @template This The type of `this` the function accepts, if using two-argument
+ * start().  Defaults to void (for one-argument start()).
+ *
+ * @category Types and Interfaces
+ */
+type AsyncStart<T, This = void> = (this: This, job: Job<T>) => StartObj<T>;
+/**
+ * A synchronous start function returns void. It runs immediately and gets
+ * passed the newly created job as its first argument.
+ *
+ * @template T The type the job will end up returning
+ * @template This The type of `this` the function accepts, if using two-argument
+ * start().  Defaults to void (for one-argument start()).
+ *
+ * @category Types and Interfaces
+ */
+type SyncStart<T, This = void> = (this: This, job: Job<T>) => void;
+/**
+ * A synchronous or asynchronous initializing function for use with the
+ * {@link start}() function or a job's {@link Job.start .start}() method.
+ *
+ * @template T The type the job will end up returning
+ * @template This The type of `this` the function accepts, if using two-argument
+ * start().  Defaults to void (for one-argument start()).
+ *
+ * @category Types and Interfaces
+ */
+type StartFn<T, This = void> = AsyncStart<T, This> | SyncStart<T, This>;
+/**
+ * An object that can be passed as a single argument to {@link start}() or a
+ * job's {@link Job.start .start}() method, such as a job, generator, or
+ * promise.
+ *
+ * @category Types and Interfaces
+ */
+type StartObj<T> = Yielding<T> | Promise<T> | PromiseLike<T>;
+/**
+ * A cancellable asynchronous operation with automatic resource cleanup.
+ *
+ * You can add cleanup callbacks to a job via {@link must}() or its
+ * .{@link must}() method.  When the job is ended or canceled, the callbacks
+ * are (synchronously) run in reverse order -- a bit like a delayed and
+ * distributed collection of `finally` blocks.
+ *
+ * Jobs implement the Promise interface (then, catch, and finally) so they can
+ * be passed to Promise-using APIs or awaited by async functions.  They also
+ * implement {@link Yielding}, so you can await their results from a
+ * {@link start}() using `yield *`.  They also have
+ * {@link Job.return \.return()} and {@link Job.throw \.throw()} methods so
+ * you can end a job with a result or error.
+ *
+ * Most jobs, however, are not intended to produce results, and are merely
+ * canceled (using {@link Job.end \.end()} or
+ * {@link Job.restart \.restart()}).
+ *
+ * Jobs can be created and accessed using {@link start}(),
+ * {@link detached}.start(), {@link makeJob}(), and {@link getJob}().
+ *
+ * @category Types and Interfaces
+ */
+interface Job<T = any> extends Yielding<T>, Promise<T> {
+    /**
+     * The result of the job (canceled, returned value, or error), or
+     * undefined if the job isn't finished.
+     *
+     * @category Obtaining Results
+     */
+    result(): JobResult<T> | undefined;
+    /**
+     * Add a cleanup callback to be run when the job is ended or restarted.
+     * (Non-function values are ignored.)  If the job has already ended, the
+     * callback will be invoked asynchronously in the next microtask. Cleanup
+     * functions are run in LIFO order, after any {@link Job.release}()
+     * callbacks (including those of the job's children), but before any
+     * {@link Job.do}() callbacks are run for the same job.
+     *
+     * Generally speaking, this method is used within a job to arrange for used
+     * resources to be cleaned up or to undo other state that was only supposed
+     * to be active while the job was running.
+     *
+     * @category Resource Tracking
+     */
+    must(cleanup?: OptionalCleanup<T>): this;
+    /**
+     * Create a mutual-cleanup link with a resource that might be stopped or
+     * terminated in some way before the job ends. (Like a child process, a
+     * server connection, etc.)
+     *
+     * If a job uses a lot of such resources, using {@link Job.must} callbacks
+     * to trigger each one would result in an ever growing number of callbacks
+     * (and uncollectable reference to the no-longer-usable resources).  So this
+     * method lets you *remove* a cleanup function when it's no longer needed:
+     * when the resource is closed or finished, invoking the callback returned
+     * by this method will remove the cleanup callback from the job, allowing
+     * the resource to be freed before the job ends, without accumulating an
+     * endless number of callbacks in the job.  (Uneventful also uses this
+     * mechanism internally to link child jobs to their parents.)
+     *
+     * In order to ensure that all such "child" jobs, resources, and activities
+     * are marked as canceled *before* any side effects (such as events,
+     * callbacks or I/O operations) can occur, Uneventful prioritizes *all*
+     * release callbacks to run before *any* other callbacks of any kind.  since
+     * release callbacks are used for child jobs, this means that the entire job
+     * subtree is notified immediately of cancellation, before any other actions
+     * are taken.  This ensures that no "stray" operations can continue, unaware
+     * that their job is canceled.
+     *
+     * This means, however, that release callbacks must do **only** simple
+     * actions that **can't** result in arbitrary code being synchronously run.
+     * (Some safe examples would be setting flags, cancelling event
+     * subscriptions, removing things from internal queues, etc.)  Synchronously
+     * triggering events or other callbacks, however, runs the risk of that code
+     * doing things it wouldn't have done if it knew its job were canceled.
+     *
+     * Note that if you still need such actions to happen, your release callback
+     * can always add a new {@link Job.must}() or {@link Job.do}() callback at
+     * that point, and the callback will then get done during a later phase of
+     * job cleanup, without losing the benefits of the mutual-cleanup process.
+     *
+     * @param cleanup A cleanup callback.  It will receive a {@link JobResult},
+     * and its return value is ignored.
+     *
+     * @returns A callback that should be used to remove the passed-in cleanup
+     * callback from the job, if the resource is disposed of before the job
+     * ends.
+     *
+     * @category Resource Tracking
+     */
+    release(cleanup: CleanupFn<T>): DisposeFn;
+    /**
+     * Start a nested job using the given function (or {@link Yielding},
+     * promise, etc.). (Like {@link start}(), but using a specific job as the
+     * parent, rather than whatever job is active.  Zero, one, and two arguments
+     * are supported, just as with start().)
+     *
+     * @category Execution Control
+     */
+    start<T>(init?: StartFn<T> | StartObj<T>): Job<T>;
+    start<T, This>(thisArg: This, fn: StartFn<T, This>): Job<T>;
+    /**
+     * Start a nested job that will end when the given stream does
+     *
+     * This is basically shorthand for `start<void>(job => void src(sink, job,
+     * inlet))` -- i.e. a quick way to subscribe to a finite and/or pausable stream.
+     *
+     * @param src An event source or finite data stream
+     * @param sink A callback that will receive the events
+     * @param inlet Optional - a {@link throttle}() to control backpressure
+     * @returns A job that can be aborted to end the subscription, and which will
+     * end naturally (with a void return or error) if the stream ends itself.
+     *
+     * @category Execution Control
+     */
+    connect<T>(src: Source<T>, sink: Sink<T>, inlet?: Throttle | Inlet): Connection;
+    /**
+     * Invoke a function with this job as the active one, so that calling the
+     * global {@link must} function will add cleanup callbacks to it,
+     * {@link getJob} will return it, etc.  (Note: signal dependency tracking is
+     * disabled for the duration of the call.)
+     *
+     * @param fn The function to call
+     * @param args The arguments to call it with, if any
+     * @returns The result of calling fn(...args)
+     *
+     * @category Execution Control
+     */
+    run<F extends PlainFunction>(fn: F, ...args: Parameters<F>): ReturnType<F>;
+    /**
+     * Wrap a function so this job will be active when it's called.
+     *
+     * @param fn The function to wrap
+     *
+     * @returns A function with the same signature(s), but will have this job
+     * active when called.
+     *
+     * @remarks Note that if the supplied function has any custom properties,
+     * they will *not* be available on the returned function at runtime, even
+     * though TypeScript will act as if they are present at compile time.  This
+     * is because the only way to copy all overloads of a function signature is
+     * to copy the exact type (as TypeScript has no way to generically say,
+     * "this a function with all the same overloads, but none of the
+     * properties").
+     *
+     * @category Execution Control
+     */
+    bind<F extends (...args: any[]) => any>(fn: F): F;
+    /**
+     * Release all resources held by the job.
+     *
+     * Arrange for all cleanup functions and result consumers added to the job
+     * (via release, must, do, etc.) be called in the appropriate order.  When
+     * the call to end() returns, all child jobs will have been notified of
+     * their cancellation.  (But not all of their cleanups or result consumers
+     * may have run yet, in the event that another job's end() is in progress
+     * when this method is called.)
+     *
+     * If any callbacks throw exceptions, they're converted to unhandled promise
+     * rejections (so that all of them will be called, even if one throws an
+     * error).
+     *
+     * Note: this method is a bound function, so you can pass it as a callback
+     * to another job, event source, etc.
+     *
+     * @category Execution Control
+     */
+    readonly end: () => void;
+    /**
+     * Invoke a callback with the result of a job.  Similar to
+     * {@link Job.must}(), except that `do` callbacks run in FIFO order after
+     * all {@link Job.must}() and {@link Job.release}() callbacks are done for
+     * the same job.
+     *
+     * These callbacks are used internally to implement promises, and should
+     * generally be used when you want to perform actions based on the *result*
+     * of a job.  (Whereas {@link Job.must}() callbacks are intended to clean up
+     * resources used by the job itself, and {@link Job.release}() callbacks are
+     * used to notify other activities (such as child jobs) that they are being
+     * canceled.)
+     *
+     * @remarks The .{@link Job.onError onError}(),  .{@link Job.onError onValue}(),
+     * and .{@link Job.onError onCancel}() provide shortcuts for creating `do`
+     * callbacks that only run under specific end conditions.
+     *
+     * @category Obtaining Results
+     */
+    do(action: (res?: JobResult<T>) => unknown): this;
+    /**
+     * Invoke a callback if the job ends with an error.
+     *
+     * This is shorthand for a .{@link Job.do do}() callback that checks for an
+     * error and marks it handled, so it uses the same relative order and runs
+     * in the same group as other .do callbacks.
+     *
+     * @param cb A callback that will receive the error
+     *
+     * @category Obtaining Results
+     */
+    onError(cb: (err: any) => unknown): this;
+    /**
+     * Invoke a callback if the job ends with a return() value.
+     *
+     * This is shorthand for a .{@link Job.do do}() callback that checks for a
+     * value result, so it uses the same relative order and runs in the same
+     * group as other .do callbacks.
+     *
+     * @param cb A callback that will receive the value
+     *
+     * @category Obtaining Results
+     */
+    onValue(cb: (val: T) => unknown): this;
+    /**
+     * Invoke a callback if the job ends with an cancellation or
+     * .{@link Job.restart restart}().
+     *
+     * This is shorthand for a .{@link Job.do do}() callback that checks for an
+     * error and marks it handled, so it uses the same relative order and runs
+     * in the same group as other .do callbacks.
+     *
+     * @param cb A callback that will receive the error
+     *
+     * @category Obtaining Results
+     */
+    onCancel(cb: () => unknown): this;
+    /**
+     * Restart this job - works just like .{@link Job.end end}(), except that
+     * the job isn't ended, so cleanup callbacks can be added again and won't be
+     * invoked until the next restart or the job is ended.  Note that the job's
+     * startup code will *not* be rerun: this just runs an early cleanup and
+     * then "uncancels" the job, changing its {@link Job.result result}() from
+     * {@link CancelResult} back to undefined.  It's up to you to do any needed
+     * re-initialization.
+     *
+     * Unlinke .{@link Job.end end}(), restart() guarantees that *all* cleanups
+     * and result consumers for the target job will have completed running when
+     * it returns.
+     *
+     * @see The {@link restarting} wrapper can be used to make a function that
+     * runs over and over in the same job, restarting each time.
+     *
+     * @category Execution Control
+     */
+    restart(): this;
+    /**
+     * Informs a job of an unhandled error from one of its children.
+     *
+     * If the job has an .{@link Job.asyncCatch asyncCatch}() handler set, it
+     * will be called with the error, otherwise the job will end with the
+     * supplied error.  If the error then isn't handled by a listener on the
+     * job, the error will cascade to an asyncThrow on the job's parent, until
+     * the {@link detached} job and its asyncCatch handler is reached. (Which
+     * defaults to creating an unhandled promise rejection.)
+     *
+     * Note: application code should not normally need to call this method
+     * directly, as it's automatically invoked on a job's parent if the job
+     * fails with no error listeners.  (That is, if a job result isn't awaited
+     * by anything and has no onError handlers, and the job throws, then the
+     * error is automatically asyncThrow()n to the job's parent.)
+     *
+     * @param err The error thrown by the child job
+     *
+     * @category Handling Errors
+     */
+    asyncThrow(err: any): this;
+    /**
+     * Set up a callback to receive unhandled errors from child jobs.
+     *
+     * Setting an async-catch handler allows you to create robust parent jobs
+     * that log or report errors and restart either a single job or an entire
+     * group of them, in the event that a child job malfunctions in a way that's
+     * not caught elsewhere.
+     *
+     * @param handler Either an error-receiving callback, or null.  If null,
+     * asyncThrow()n errors for the job will be passed to the job's throw()
+     * method instead.  If a callback is given, it's called with `this` bound to
+     * the relevant job instance.
+     *
+     * @category Handling Errors
+     */
+    asyncCatch(handler: ((this: Job, err: any) => unknown) | null): this;
+    /**
+     * End the job with a thrown error, passing an {@link ErrorResult} to the
+     * cleanup callbacks.  (Throws an error if the job is already ended or is
+     * currently restarting.)  Provides the same execution and ordering
+     * guarantees as .{@link Job.end end}().
+     *
+     * Note: since this immediately ends the job with an error, it should only
+     * be called by the job when it is no longer able to continue.  If you want
+     * to notify a job about an error in a *different* job, you may want to use
+     * .{@link Job.asyncThrow asyncThrow}() instead.
+     *
+     * @category Producing Results
+     */
+    throw(err: any): this;
+    /**
+     * End the job with a return value, passing a {@link ValueResult} to the
+     * cleanup callbacks.  (Throws an error if the job is already ended or is
+     * currently restarting.)  Provides the same execution and ordering
+     * guarantees as .{@link Job.end end}().
+     *
+     * @category Producing Results
+     */
+    return(val: T): this;
+}
+/**
+ * A pausable computation that ultimately produces a value of type T.
+ *
+ * An item of this type can be used to either create a job of type T, or awaited
+ * in a job via `yield *` to obtain the value.
+ *
+ * Any generator function that ultimately returns a value, implicitly returns a
+ * Yielding of that type, but it's best to *explicitly* declare this so that
+ * TypeScript can properly type check your yield expressions.  (e.g. `function
+ * *(): Yielding<number> {}` for a generator function that ultimately returns a
+ * number.)
+ *
+ * Generator functions implementing this type should only ever `yield *` to
+ * things that are of Yielding type, such as a {@link Job}, {@link to}() or
+ * other generators declared Yielding.
+ *
+ * @yields {@link Suspend}\<any>
+ * @returns T
+ *
+ *
+ * @category Types and Interfaces
+ */
+type Yielding<T> = {
+    /**
+     * An iterator suitable for use with `yield *` (in a job generator) to
+     * obtain a result.
+     *
+     * @category Obtaining Results
+     */
+    [Symbol.iterator](): JobIterator<T>;
+};
+/**
+ * An iterator yielding {@link Suspend} callbacks.  (An implementation detail of
+ * the {@link Yielding} type.)
+ *
+ * @category Types and Interfaces
+ */
+type JobIterator<T> = Generator<Suspend<any>, T, any>;
+/**
+ * An asynchronous operation that can be waited on by a {@link Job}.
+ *
+ * When a {@link JobIterator} yields a Suspend, the job invokes it with a
+ * {@link Request}.  The Suspend function should arrange for the request to be
+ * settled (via {@link resolve} or {@link reject}).
+ *
+ * Note: If the request is not settled, **the job will be suspended until
+ * cancelled by outside forces**.  (Such as its enclosing job ending, or
+ * explicit throw()/return() calls on the job instance.)
+ *
+ * Also note that any subjobs the Suspend function creates (or cleanup callbacks
+ * it registers) **will not be called until the *calling* job ends**.  So any
+ * resources that won't be needed once the job is resumed should be explicitly
+ * disposed of -- in which case you should probably just `yield *` to a
+ * {@link start}(), instead of yielding a Suspend!
+ *
+ * @category Types and Interfaces
+ */
+type Suspend<T> = (request: Request<T>) => void;
+/**
+ * A request for a value (or error) to be returned asynchronously.
+ *
+ * A request is like the inverse of a Promise: instead of waiting for it to
+ * settle, you settle it by passing it to {@link resolve}() or {@link reject}().
+ * Like a promise, it can only be settled once: resolving or rejecting it after
+ * it's already resolved or rejected has no effect.
+ *
+ * Settling a request will cause the requesting job (or other code) to resume
+ * immediately, running up to its next suspension or termination.  (Unless it's
+ * settled while the requesting job is already on the call stack, in which case
+ * the job will be resumed later.)
+ *
+ * (Note: do not call a Request directly, unless you want your code to maybe
+ * break in future.  Use resolve or reject (or {@link resolver}() or
+ * {@link rejecter}()), as 1) they'll shield you from future changes to this
+ * protocol and 2) they have better type checking anyway.)
+ *
+ * @category Types and Interfaces
+ */
+interface Request<T> {
+    (op: "next", val: T, err?: any): void;
+    (op: "throw", val: undefined | null, err: any): void;
+    (op: "next" | "throw", val?: T | undefined | null, err?: any): void;
+}
+/**
+ * A subscribable function used to trigger signal recalculations
+ *
+ * It must accept a callback, and should arrange (via {@link must}()) to
+ * unsubscribe when its calling job ends.  Once subscribed, it should
+ * invoke the callback to trigger recalculation of the signal(s) that
+ * were targeted via {@link recalcWhen}.
+ *
+ * @category Types and Interfaces
+ */
+type RecalcSource = ((cb: () => void) => unknown);
+
+/**
+ * Is the given value a function?
+ *
+ * @category Types and Interfaces
+ */
+declare function isFunction(f: any): f is Function;
+/**
+ * Return the currently-active Job, or throw an error if none is active.
+ *
+ * (You can check if a job is active first using {@link isJobActive}().)
+ *
+ * @category Jobs
+ */
+declare function getJob<T = unknown>(): Job<T>;
+/**
+ * Obtain a native promise for a job
+ *
+ * While jobs have the same interface as native promises, there are occasionally
+ * reasons to just use one directly.  (Like when Uneventful uses this function
+ * to implement jobs' promise methods!)
+ *
+ * @param job Optional: the job to get a native promise for.  If none is given,
+ * the active job is used.
+ *
+ * @returns A {@link Promise} that resolves or rejects according to whether the
+ * job returns or throws.  If the job is canceled, the promise is rejected with
+ * a {@link CancelError}.
+ *
+ * @category Jobs
+ */
+declare function nativePromise<T>(job?: Job<T>): Promise<T>;
+/**
+ * Return a new {@link Job}.  If *either* a parent parameter or stop function
+ * are given, the new job is linked to the parent.
+ *
+ * @param parent The parent job to which the new job should be attached.
+ * Defaults to the currently-active job if none given (assuming a stop
+ * parameter is provided).
+ *
+ * @param stop The function to call to destroy the nested job.  Defaults to the
+ * {@link Job.end} method of the new job if none is given (assuming a parent
+ * parameter is provided).
+ *
+ * @returns A new job.  The job is linked/nested if any arguments are given,
+ * or a detached (parentless) job otherwise.
+ *
+ * @category Jobs
+ */
+declare const makeJob: <T, R = unknown>(parent?: Job<R>, stop?: CleanupFn<R>) => Job<T>;
+/**
+ * A special {@link Job} with no parents, that can be used to create standalone
+ * jobs.  detached.start() returns a new detached job, detached.run() can be
+ * used to run code that expects to create a child job, and detached.bind() can
+ * wrap a function to work without a parent job.
+ *
+ * (Note that in all cases, a child job of `detached` *must* be stopped
+ * explicitly, or it may "run" forever, never running its cleanup callbacks.)
+ *
+ * The detached job has a few special features and limitations:
+ *
+ * - It can't be ended, thrown, return()ed, etc. -- you'll get an error
+ *
+ * - It can't have any cleanup functions added: no do, must, onError, etc., and
+ *   thus also can't have any native promise, abort signal, etc. used.  You can
+ *   call its release() method, but nothing will actually be registered and the
+ *   returned callback is a no-op.
+ *
+ * - Unhandled errors from jobs without parents (and errors from *any* job's
+ *   cleanup functions) are sent to the detached job for handling.  This means
+ *   whatever you set as the detached job's .{@link Job.asyncCatch asyncCatch}()
+ *   handler will receive them.  (Its default is Promise.reject, causing an
+ *   unhandled promise rejection.)
+ *
+ * @category Jobs
+ */
+declare const detached: Job<unknown>;
+
+/**
+ * Convert a promise to something you can `yield *to()` in a job
+ *
+ * Much like `await valueOrPromiseLike` in an async function, using `yield
+ * *to(valueOrPromiseLike)` in a {@link Job}'s generator function will return
+ * the value or the result of the promise/promise-like object.
+ *
+ * @category Scheduling
+ */
+declare function to<T>(p: Promise<T> | PromiseLike<T> | T): Yielding<T>;
+/**
+ * Pause the job for the specified time in ms, e.g. `yield *sleep(1000)` to wait
+ * one second.
+ *
+ * @category Scheduling
+ */
+declare function sleep(ms: number): Yielding<void>;
+
+/**
+ * A function that emits events, with a .source they're emitted from
+ *
+ * Created using {@link emitter}.
+ *
+ * @category Types and Interfaces
+ */
+interface Emitter<T> {
+    /** Call the emitter to emit events on its .source */
+    (val: T): void;
+    /** An event source that receives the events */
+    source: Producer<T>;
+    /** Close all current subscribers' connections */
+    end: () => void;
+    /** Close all current subscribers' connections with an error */
+    throw: (e: any) => void;
+}
+/**
+ * Create an event source and a function to emit events on it
+ *
+ * (Note: you must specify the event type (e.g. `emitter<number>()`), since
+ * there's nothing else to infer it from.)
+ *
+ * @returns A function that emits events, with a .source property they're
+ * emitted on.
+ *
+ * @category Stream Producers
+ */
+declare function emitter<T>(): Emitter<T>;
+/**
+ * A stream that immediately closes
+ *
+ * @category Stream Producers
+ */
+declare function empty(): Producer<never>;
+/**
+ * Convert an async iterable to an event source
+ *
+ * Each time the resulting source is subscribed to, it will emit an event for
+ * each item output by the iterator, then end the stream.  Pause/resume is
+ * supported.
+ *
+ * @category Stream Producers
+ */
+declare function fromAsyncIterable<T>(iterable: AsyncIterable<T>): Producer<T>;
+/**
+ * Create an event source from an element, window, or other event target
+ *
+ * You can manually override the expected event type using a type parameter,
+ * e.g. `fromDomEvent<CustomEvent>(someTarget, "custom-event")`.
+ *
+ * @param target an HTMLElement, Window, Document, or other EventTarget.
+ * @param type the name of the event to add a listener for
+ * @param options a boolean capture option, or an object of event listener
+ * options
+ * @returns a source that can be subscribed or piped, issuing events from the
+ * target of the specified type.
+ *
+ * @category Stream Producers
+ */
+declare function fromDomEvent<T extends HTMLElement, K extends keyof HTMLElementEventMap>(target: T, type: K, options?: boolean | AddEventListenerOptions): Producer<HTMLElementEventMap[K]>;
+declare function fromDomEvent<T extends Window, K extends keyof WindowEventMap>(target: T, type: K, options?: boolean | AddEventListenerOptions): Producer<WindowEventMap[K]>;
+declare function fromDomEvent<T extends Document, K extends keyof DocumentEventMap>(target: T, type: K, options?: boolean | AddEventListenerOptions): Producer<DocumentEventMap[K]>;
+declare function fromDomEvent<T extends Event>(target: EventTarget, type: string, options?: boolean | AddEventListenerOptions): Producer<T>;
+/**
+ * Convert an iterable to a synchronous event source
+ *
+ * Each time the resulting source is subscribed to, it will emit an event for
+ * each item in the iterator, then close the conduit.  Pause/resume is
+ * supported.
+ *
+ * @category Stream Producers
+ */
+declare function fromIterable<T>(iterable: Iterable<T>): Producer<T>;
+/**
+ * Convert a Promise to an event source
+ *
+ * Each time the resulting source is subscribed to, it will emit an event for
+ * the result of the promise, then close the conduit.  (Unless the promise is
+ * rejected, in which case the conduit throws and closes each time the source is
+ * subscribed.)  Non-native promises and non-promise values are converted using
+ * Promise.resolve().
+ *
+ * @category Stream Producers
+ */
+declare function fromPromise<T>(promise: Promise<T> | PromiseLike<T> | T): Producer<T>;
+/**
+ * Create an event source from an arbitrary subscribe/unsubscribe function
+ *
+ * The supplied "subscribe" function will be passed a 1-argument callback and
+ * must return an unsubscribe function.  The callback should be called with
+ * events of the appropriate type, and the unsubscribe function will be called
+ * when the connection is closed.
+ *
+ * (Note: it's okay if the act of subscribing causes an immediate callback, as
+ * the subscribe function will be called in a separate microtask.)
+ *
+ * @category Stream Producers
+ */
+declare function fromSubscribe<T>(subscribe: (cb: (val: T) => void) => DisposeFn): Producer<T>;
+/**
+ * Create a source that emits a single given value
+ *
+ * @category Stream Producers
+ */
+declare function fromValue<T>(val: T): Producer<T>;
+/**
+ * Create an event source that issues a number every `ms` milliseconds (starting
+ * with 0 after the first interval passes).
+ *
+ * @category Stream Producers
+ */
+declare function interval(ms: number): Producer<number>;
+/**
+ * Create a dynamic source that is created each time it's subscribed
+ *
+ * @param factory A function returning a source of the desired type.  It will be
+ * called whenever the lazy() stream is subscribed, and its result subscribed to.
+ *
+ * @returns A stream of the same type as the factory function returns
+ *
+ * @category Stream Producers
+ */
+declare function lazy<T>(factory: () => Source<T>): Producer<T>;
+/**
+ * An {@link Emitter} with a ready() method, that only supports a single active
+ * subscriber.  (Useful for testing stream operators and sinks.)
+ *
+ * Created using {@link mockSource}().
+ *
+ * @category Types and Interfaces
+ */
+interface MockSource<T> extends Emitter<T> {
+    ready: Backpressure;
+}
+/**
+ * Like {@link emitter}, but with a ready() backpressure method.  It also only
+ * supports a single active subscriber.  (Useful for testing stream operators
+ * and sinks.)
+ *
+ * @category Stream Producers
+ */
+declare function mockSource<T>(): MockSource<T>;
+/**
+ * A stream that never emits or closes
+ *
+ * @category Stream Producers
+ */
+declare function never(): Producer<never>;
+/**
+ * Wrap a source to allow multiple subscribers to the same underlying stream
+ *
+ * The input source will be susbcribed when the output has at least one
+ * subscriber, and unsubscribed when the output has no subscribers.  The input
+ * will be paused when any subscriber pauses, and will only be resumed when all
+ * subscribers are unpaused.  All subscribers are closed or thrown if the input
+ * source closes or throws.
+ *
+ * (Generally speaking, you should place the share call as late in your
+ * pipelines as possible, if you use it at all.  It adds some overhead that is
+ * wasted if the stream doesn't have multiple subscribers, and may be redundant
+ * if an upstream source is already shared.  It's mainly useful if there is a
+ * lot of mapping, filtering, or other complicated processing taking place
+ * upstream of the share, and you know for a fact there will be enough
+ * subscribers to make it a bottleneck.  You should probably also consider
+ * putting some {@link slack}() either upstream or downstream of the share, if
+ * the upstream supports backpressure.)
+ *
+ * @category Stream Operators
+ */
+declare function share<T>(source: Source<T>): Producer<T>;
+
+/**
+ * Output multiple streams' contents in order (from an array/iterable of stream
+ * sources)
+ *
+ * Streams are concatenated in order -- note that this means they need to not be
+ * infinite if any subsequent streams are to be processed!  The output is closed
+ * when all sources are finished or if any source throws (in which case the
+ * error propagates to the subscriber).
+ *
+ * Note: this function is just shorthand for {@link concatAll}({@link fromIterable}(*sources*)).
+ *
+ * @category Stream Operators
+ */
+declare function concat<T>(sources: Source<T>[] | Iterable<Source<T>>): Producer<T>;
+/**
+ * Flatten a source of sources by emitting their contents in series
+ *
+ * Streams are concatenated in order -- note that this means they need to not be
+ * infinite if any subsequent streams are to be processed!  The output is closed
+ * when all sources are finished or if any source throws (in which case the
+ * error propagates to the subscriber).
+ *
+ * If you want to switch to a new stream whenever a new source arrives from the
+ * input stream, use {@link switchAll} instead.
+ *
+ * @category Stream Operators
+ */
+declare function concatAll<T>(sources: Source<Source<T>>): Producer<T>;
+/**
+ * Map each value of a stream to a substream, then concatenate the resulting
+ * substreams
+ *
+ * (This is just shorthand for `compose(map(mapper), concatAll)`.)
+ *
+ * If you want to switch to a new stream whenever a new event arrives on the
+ * input stream, use {@link switchMap} instead.
+ *
+ * @category Stream Operators
+ */
+declare function concatMap<T, R>(mapper: (v: T, idx: number) => Source<R>): Transformer<T, R>;
+/**
+ * Create a subset of a stream, based on a filter function (like Array.filter)
+ *
+ * The filter function receives the current index (zero-based) as well as the
+ * current value.  If it returns truth, the value will be passed to the output,
+ * otherwise it will be skipped.
+ *
+ * If the filter function is typed as a Typescript type guard (i.e. as returning
+ * `v is SomeType`), then the resulting source will be typed as
+ * Source<SomeType>.
+ *
+ * @category Stream Operators
+ */
+declare function filter<T, R extends T>(filter: (v: T, idx: number) => v is R): Transformer<T, R>;
+declare function filter<T>(filter: (v: T, idx: number) => boolean): Transformer<T>;
+/**
+ * Replace each value in a stream using a function (like Array.map)
+ *
+ * The mapping function receives the current index (zero-based) as well as the
+ * current value.
+ *
+ * @category Stream Operators
+ */
+declare function map<T, R>(mapper: (v: T, idx: number) => R): Transformer<T, R>;
+/**
+ * Create an event source by merging an array or iterable of event sources.
+ *
+ * The resulting source issues events whenever any of the input sources do, and
+ * closes once they all do (or throws if any of them do).
+ *
+ * @category Stream Operators
+ */
+declare function merge<T>(sources: Source<T>[] | Iterable<Source<T>>): Producer<T>;
+/**
+ * Create an event source by merging sources from a stream of event sources
+ *
+ * The resulting source issues events whenever any of the input sources do, and
+ * closes once they all do (or throws if any of them do).
+ *
+ * @category Stream Operators
+ */
+declare function mergeAll<T>(sources: Source<Source<T>>): Producer<T>;
+/**
+ * Create an event source by merging sources created by mapping events to sources
+ *
+ * The resulting source issues events whenever any of the input sources do, and
+ * closes once they all do (or throws if any of them do).
+ *
+ * (Note: this is just shorthand for `compose(map(mapper), mergeAll)`.)
+ *
+ * @category Stream Operators
+ */
+declare function mergeMap<T, R>(mapper: (v: T, idx: number) => Source<R>): Transformer<T, R>;
+/**
+ * Skip the first N items from a source
+ *
+ * (Equivalent to {@link skipWhile}() with a function that checks the index is < n.)
+ *
+ * @category Stream Operators
+ */
+declare function skip<T>(n: number): Transformer<T>;
+/**
+ * Skip items from a stream until another source produces a value.
+ *
+ * If the notifier closes without producing a value, the output will
+ * be empty.  If the notifier throws, so will the output.
+ *
+ * @category Stream Operators
+ */
+declare function skipUntil<T>(notifier: Source<any>): Transformer<T>;
+/**
+ * Skip items from a stream until a given condition is false, then output all
+ * remaining items.  The condition function is not called again once it returns
+ * false.
+ *
+ * @category Stream Operators
+ */
+declare function skipWhile<T>(condition: (v: T, index: number) => boolean): Transformer<T>;
+/**
+ * Add job control and buffering to a stream
+ *
+ * This lets you block events from a stream that can't be paused, or allow for
+ * some slack for a source that can sometimes get ahead of its sink.
+ *
+ * @param size The number of items to buffer when the sink is busy (i.e., the
+ * sink is running or the connection is paused).  If positive, the most recent N
+ * items are kept (a "sliding" buffer), and if negative, the oldest N item are
+ * kept (a "dropping" buffer). If zero, no items are buffered, and items are
+ * dropped if received while the sink is busy.
+ *
+ * @param dropped Optional: a callback that will receive items when they are
+ * dropped.  (Useful for testing, performance instrumentation, error logging,
+ * etc.)
+ *
+ * @category Stream Operators
+ */
+declare function slack<T>(size: number, dropped?: Sink<T>): Transformer<T>;
+/**
+ * Flatten a source of sources by emitting their contents until a new one
+ * arrives.
+ *
+ * As each source arrives from the input stream, its values are sent to the
+ * output, closing the previous one (if any).  The output is closed when both
+ * the input stream and the most-recently-arrived stream are finished.  Errors
+ * propagate to the output if any stream throws.
+ *
+ * (If you want to send *all* the values of each stream to the output without
+ * stopping, input stream, use {@link concatAll} or {@link mergeAll} instead.)
+ *
+ * @category Stream Operators
+ */
+declare function switchAll<T>(sources: Source<Source<T>>): Producer<T>;
+/**
+ * Map each value of a stream to a substream, then output the resulting
+ * substreams until a new value arrives.
+ *
+ * (This is just shorthand for `compose(map(mapper),`{@link switchAll `switchAll)`}.)
+ *
+ * (If you want to send *all* the values of each stream to the output without
+ * stopping, input stream, use {@link concatMap} or {@link mergeMap} instead.)
+ *
+ * @category Stream Operators
+ */
+declare function switchMap<T, R>(mapper: (v: T, idx: number) => Source<R>): Transformer<T, R>;
+/**
+ * Take the first N items from a source
+ *
+ * (Equivalent to {@link takeWhile}() with a function that checks the index is < n.)
+ *
+ * @category Stream Operators
+ */
+declare function take<T>(n: number): Transformer<T>;
+/**
+ * Take items from a source until another source produces a value.
+ *
+ * If the notifier closes without producing a value, this will output all
+ * elements of the input.  But if the notifier throws, so will the output.
+ *
+ * @category Stream Operators
+ */
+declare function takeUntil<T>(notifier: Source<any>): Transformer<T>;
+/**
+ * Take items from a stream until a given condition is false, then close the
+ * output.  The condition function is not called again after it returns false.
+ *
+ * If the condition function is typed as a Typescript type guard (i.e. as
+ * returning `v is SomeType`), then the resulting source will be typed as
+ * Source<SomeType>.
+ *
+ * @category Stream Operators
+ */
+declare function takeWhile<T, R extends T>(condition: (v: T, idx: number) => v is R): Transformer<T, R>;
+declare function takeWhile<T>(condition: (v: T, idx: number) => boolean): Transformer<T>;
+
+/**
+ * Add a cleanup function to the active job. Non-function values are ignored.
+ * Equivalent to {@link getJob}().{@link Job.must must}() -- see
+ * {@link Job.must}() for more details.
+ *
+ * @category Jobs
+ */
+declare function must<T>(cleanup?: OptionalCleanup<T>): Job<T>;
+/**
+ * Start a nested job within the currently-active job.  (Shorthand for
+ * {@link getJob}().{@link Job.start start}(...).)
+ *
+ * This function can be called with zero, one, or two arguments:
+ *
+ * - When called with zero arguments, the new job is returned without any other
+ *   initialization.
+ *
+ * - When called with one argument that's a function (either a {@link SyncStart}
+ *   or {@link AsyncStart}): the function is run inside the new job and receives
+ *   it as an argument.  It can return a {@link Yielding} iterator (such as a
+ *   generator or job), a promise, or void.  A returned iterator or promise will
+ *   be treated as if the method was called with that to begin with; a returned
+ *   job will be awaited and its result transferred to the new job
+ *   asynchronously.
+ *
+ * - When called with one argument that's a {@link Yielding} iterator (such as a
+ *   generator or an existing job): it's attached to the new job and executed
+ *   asynchronously. (Starting in the next available microtask.)
+ *
+ * - When called with one argument that's a Promise, it's converted to a job
+ *   that will end when the promise settles.  The resulting job is returned.
+ *
+ * - When called with two arguments -- a "this" object and a function -- it
+ *   works the same as one argument that's a function, except the function is
+ *   bound to the supplied "this" before being called.
+ *
+ *   This last signature is needed because you can't make generator arrows in JS
+ *   yet: if you want to start() a generator function bound to the current
+ *   `this`, you'll want to use `.start(this, function*() { ...whatever  })`.
+ *
+ *   (Note, however, that TypeScript and/or VSCode may require that you give
+ *   such a function an explicit `this` parameter (e.g. `.start(this, function
+ *   *(this) {...}));`) in order to correctly infer types inside a generator
+ *   function.)
+ *
+ * In any of the above cases, if a supplied function throws an error when
+ * starting, the new job will be ended, and the error synchronously re-thrown.
+ *
+ * @returns the created {@link Job}
+ *
+ * @category Jobs
+ */
+declare function start<T>(init?: StartFn<T> | StartObj<T>): Job<T>;
+/**
+ * The two-argument variant of start() allows you to pass a "this" object that
+ * will be bound to the initialization function.  (It's mostly useful for
+ * generator functions, since generator arrows aren't a thing yet.)
+ */
+declare function start<T, This>(thisArg: This, fn: StartFn<T, This>): Job<T>;
+/**
+ * Is there a currently active job? (i.e., can you safely use {@link must}(),
+ * or {@link getJob}() right now?)
+ *
+ * @category Jobs
+ */
+declare function isJobActive(): boolean;
+/**
+ * Set the cancellation timeout for a job.
+ *
+ * When the timeout is reached, the job is canceled (throwing
+ * {@link CancelError} to any waiting promises or jobs), unless a new timeout
+ * is set before then.  You may set a new timeout value for a job as many times
+ * as desired.  A timeout value of zero disables the timeout. Timers are
+ * disposed of if the job is canceled or restarted.
+ *
+ * @param ms Optional: Number of milliseconds after which the job will be
+ * canceled. Defaults to zero if not given.
+ *
+ * @param job Optional: the job to apply the timeout to.  If none is given, the
+ * active job is used.
+ *
+ * @returns the job to which the timeout was added or removed.
+ *
+ * @category Scheduling
+ */
+declare function timeout<T>(ms: number, job?: Job<T>): Job<T>;
+/**
+ * Get an AbortSignal that aborts when the job ends or is restarted.
+ *
+ * @param job Optional: the job to get an AbortSignal for.  If none is given,
+ * the active job is used.
+ *
+ * @returns the AbortSignal
+ *
+ * @category Jobs
+ */
+declare function abortSignal(job?: Job): AbortSignal;
+/**
+ * Wrap a function in a {@link Job} that restarts each time the resulting
+ * function is called, thereby canceling any nested jobs and cleaning up any
+ * resources used by previous calls. (This can be useful for such things as
+ * canceling an in-progress search when the user types more text in a field.)
+ *
+ * The restarting job will be ended when the job that invoked `restarting()`
+ * is finished, canceled, or restarted.  Calling the wrapped function after its
+ * job has ended will result in an error.  You can wrap any function any number
+ * of times: each call to `restarting()` creates a new, distinct "restarting
+ * job" and function wrapper to go with it.
+ *
+ * @param task (Optional) The function to be wrapped. This can be any function:
+ * the returned wrapper function will match its call signature exactly, including
+ * overloads.  (So for example you could wrap the {@link start} API via
+ * `restarting(start)`, to create a function you can pass job-start functions to.
+ * When called, the function would cancel any outstanding job from a previous
+ * call, and start the new one in its place.)
+ *
+ * @returns A function of identical type to the input function.  If no input
+ * function was given, the returned function will just take one argument (a
+ * zero-argument function optionally returning a {@link CleanupFn}).
+ *
+ * @category Jobs
+ */
+declare function restarting<F extends AnyFunction>(task: F): F;
+declare function restarting(): (task: () => OptionalCleanup<never>) => void;
+
+export { type AnyFunction, type AsyncStart, type Backpressure, CancelError, CancelResult, CircularDependency, type CleanupFn, type Connection, type DisposeFn, type Each, type EachResult, type Emitter, ErrorResult, type HandledError, type Inlet, IsStream, type Job, type JobIterator, type JobResult, type MockSource, type Nothing, type OptionalCleanup, type PlainFunction, type Producer, type RecalcSource, type Request, RuleScheduler, Signal, type Sink, type Source, type StartFn, type StartObj, type Suspend, type SyncStart, type Throttle, type Transformer, type UnhandledError, type UntilMethod, ValueResult, type Waitable, Writable, WriteConflict, type Yielding, abortSignal, backpressure, cached, compose, concat, concatAll, concatMap, connect, defer, detached, each, emitter, empty, filter, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, getResult, interval, into, isCancel, isError, isFunction, isHandled, isJobActive, isUnhandled, isValue, lazy, makeJob, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, nativePromise, never, noDeps, noop, pipe, propagateResult, recalcWhen, reject, rejecter, resolve, resolver, restarting, rule, runRules, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, timeout, to, until, value };