import { type Deadline } from "./deadline.js";
import { type Outcome } from "./result.js";
export interface Page<T> {
    items: T[];
    /** Cursor for the next page, when more results exist. */
    cursor?: string;
}
interface RawResult<D> {
    data?: D | undefined;
    error?: unknown;
    response?: Response | undefined;
}
/**
 * A lazy, cursor-paginated list. `page()` / `all()` follow the resolved `throwOnError`
 * policy exactly like every other method: bare value (throwing on failure) when it is on,
 * `{ data, error }` envelope when it is off. The async iterator always throws on a
 * page-fetch error — a stream has no envelope form.
 *
 * `waitForReadiness` is not applied: list responses carry no `operations`.
 */
export interface Paginated<T, Throw extends boolean = false> extends AsyncIterable<T> {
    /** Fetch a single page (optionally from a cursor). */
    page(cursor?: string): Promise<Outcome<Page<T>, Throw>>;
    /** Fetch and concatenate every page. */
    all(): Promise<Outcome<T[], Throw>>;
}
/**
 * Build a {@link Paginated} list from a page fetcher and a page mapper. The response-body
 * type `D` is inferred and erased from the public `Paginated<T>` return.
 *
 * `newDeadline` is called once per consumption — each `page()`, each `all()`, each
 * iteration — because a `Paginated` is lazy and may be consumed more than once, so a
 * deadline created when the list was built would already be spent.
 *
 * `shouldThrow` is the policy resolved when the list is built (per-call override, else
 * the client default), the same rule the execution core uses for every other method.
 */
export declare function paginate<T, D>(fetchPage: (cursor: string | undefined, signal?: AbortSignal) => Promise<RawResult<D>>, mapPage: (data: D) => Page<T>, newDeadline: () => Deadline, shouldThrow: boolean): Paginated<T, boolean>;
export {};
//# sourceMappingURL=paginate.d.ts.map