import { FilesError } from "../internal/errors.js";
/**
 * Run `run`, passing a failure to `record` as a {@link FilesError} and
 * rethrowing that same normalized error, so the caller's `catch` and the
 * ambient `error` see one value.
 */
export declare const rememberCall: <T>(run: () => Promise<T>, record: (error: FilesError) => void) => Promise<T>;
/**
 * Delegate to `source`, passing any error thrown while it is iterated to
 * `record` (normalized to a {@link FilesError}) before rethrowing it, and
 * resolving to `source`'s own return value. Early `break`/`return` still
 * closes `source`.
 */
export declare const rememberIteration: <T, R>(source: AsyncGenerator<T, R>, record: (error: FilesError) => void) => AsyncGenerator<T, R>;
/**
 * `baseFetch` with every request run under `signalFor(init.signal)` — the
 * binding's controller merged with the caller's signals. A request that merged
 * signal cancelled rejects with an `aborted` {@link FilesError} rather than
 * the runtime's raw `AbortError` (or bare abort reason), which the client
 * could not otherwise tell apart from a network failure.
 */
export declare const signalledFetch: (baseFetch: typeof fetch, signalFor: (extra?: AbortSignal) => AbortSignal) => typeof fetch;
/**
 * Abort `controller` (with the same reason) when `external` aborts — at once
 * if it already has. Returns the detach, so a query run can drop its listener
 * from a long-lived signal once it settles or is replaced.
 */
export declare const followSignal: (controller: AbortController, external: AbortSignal | undefined) => (() => void);
//# sourceMappingURL=remember.d.ts.map