@agent-api/sdk 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog — @agent-api/sdk
+
+## 1.0.0
+
+### Added
+
+- Modular package layout with retries, typed errors, pagination, and streaming.
+- CI via `.github/workflows/sdk.yml` and npm publish via `sdk-javascript-release.yml`.
+- Route coverage check via `scripts/check-routes.mjs`.
+
+### Notes
+
+- Independent from the Python `cloudsway-agent` package; version and release tags are separate.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentsWay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+# JavaScript SDK
+
+Production JavaScript/TypeScript SDK for the Managed Agent API.
+
+## Install
+
+```bash
+npm install @agent-api/sdk
+```
+
+For local development from this repository:
+
+```bash
+cd sdk/javascript
+npm install
+npm run build
+```
+
+## Quick start
+
+```javascript
+import { AgentAPI } from "@agent-api/sdk";
+
+const client = new AgentAPI({
+  apiKey: process.env.AGENT_API_KEY,
+  baseURL: "https://api.agentsway.dev",
+});
+
+const response = await client.responses.create({
+  preset: "pro-search",
+  input: "What changed in AI this week?",
+});
+console.log(response.output_text);
+```
+
+Environment variables `AGENT_API_KEY` and `AGENT_API_BASE_URL` are used by default.
+The default base URL is `https://api.agentsway.dev` when neither option nor env is set.
+
+## Package layout
+
+```
+src/
+  client.ts           # AgentAPI entrypoint
+  errors.ts           # Typed error hierarchy + retry helpers
+  pagination.ts       # Cursor pagination utilities
+  streaming.ts        # SSE parser
+  resources/          # responses, models, presets, tools
+  types/              # Request/response TypeScript types
+  internal/http.ts    # Retries, timeouts, User-Agent
+```
+
+## Resources
+
+| Resource | Methods |
+|----------|---------|
+| `client.responses` / `client.agent` | `create`, `list`, `listPage`, `listIterator`, `retrieve`, `cancel`, `listChildren`, `listEvents` |
+| `client.models` | `list` |
+| `client.presets` | `list` |
+| `client.tools` | `list` |
+
+## Production features
+
+- **Retries:** automatic exponential backoff for network failures, 429, and 5xx (default 2 retries).
+- **Timeouts:** 10 minute default for requests; 1 hour for streaming agent runs (configurable via `timeout` / `streamTimeout`).
+- **Typed errors:** `AuthenticationError`, `RateLimitError`, `NotFoundError`, `BadRequestError`, etc.
+- **Pagination:** `listPage` returns a cursor page; `listIterator` auto-fetches all pages.
+
+```typescript
+for await (const item of client.responses.listIterator({ limit: 20 })) {
+  console.log(item.id, item.status);
+}
+```
+
+## Streaming
+
+```typescript
+const stream = await client.responses.create({
+  preset: "fast-search",
+  input: "Summarize today's AI news.",
+  stream: true,
+});
+
+for await (const event of stream) {
+  if (event.type === "response.output_text.delta") {
+    process.stdout.write(event.delta ?? "");
+  }
+}
+```
+
+## Client options
+
+```typescript
+const client = new AgentAPI({
+  apiKey: "sk-...",
+  baseURL: "https://api.agentsway.dev",
+  timeout: 600_000,
+  streamTimeout: 3_600_000,
+  maxRetries: 2,
+  defaultHeaders: { "X-Custom": "value" },
+});
+```
+
+## Tests
+
+```bash
+npm run check:routes   # optional route manifest check
+npm test
+AGENT_API_INTEGRATION=1 AGENT_API_KEY=sk-... AGENT_API_BASE_URL=https://api.agentsway.dev npm run test:integration
+```
+
+## Scope
+
+The SDK covers the public agent/Responses API and discovery endpoints. Console
+auth, workspace administration, and internal audit records are intentionally
+out of scope.

package/dist/client.d.ts

@@ -0,0 +1,25 @@
+import { ModelsResource } from "./resources/models.js";
+import { PresetsResource } from "./resources/presets.js";
+import { ResponsesResource } from "./resources/responses.js";
+import { ToolsResource } from "./resources/tools.js";
+import type { ClientOptions } from "./types/common.js";
+import { VERSION } from "./version.js";
+export declare const DEFAULT_TIMEOUT_MS = 600000;
+export declare const DEFAULT_STREAM_TIMEOUT_MS = 3600000;
+export declare const DEFAULT_MAX_RETRIES = 2;
+export declare class AgentAPI {
+    readonly apiKey?: string;
+    readonly baseURL: string;
+    readonly timeout: number;
+    readonly streamTimeout: number;
+    readonly maxRetries: number;
+    readonly defaultHeaders: Record<string, string>;
+    readonly responses: ResponsesResource;
+    readonly agent: ResponsesResource;
+    readonly models: ModelsResource;
+    readonly presets: PresetsResource;
+    readonly tools: ToolsResource;
+    private readonly http;
+    constructor(options?: ClientOptions);
+}
+export { VERSION };

package/dist/client.js

@@ -0,0 +1,52 @@
+import { APIConnectionError } from "./errors.js";
+import { readEnv } from "./internal/env.js";
+import { HTTPClient } from "./internal/http.js";
+import { ModelsResource } from "./resources/models.js";
+import { PresetsResource } from "./resources/presets.js";
+import { ResponsesResource } from "./resources/responses.js";
+import { ToolsResource } from "./resources/tools.js";
+import { VERSION } from "./version.js";
+export const DEFAULT_TIMEOUT_MS = 600_000;
+export const DEFAULT_STREAM_TIMEOUT_MS = 3_600_000;
+export const DEFAULT_MAX_RETRIES = 2;
+export class AgentAPI {
+    apiKey;
+    baseURL;
+    timeout;
+    streamTimeout;
+    maxRetries;
+    defaultHeaders;
+    responses;
+    agent;
+    models;
+    presets;
+    tools;
+    http;
+    constructor(options = {}) {
+        this.apiKey = options.apiKey ?? readEnv("AGENT_API_KEY");
+        this.baseURL = (options.baseURL ?? readEnv("AGENT_API_BASE_URL") ?? "https://api.agentsway.dev").replace(/\/+$/, "");
+        this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.streamTimeout = options.streamTimeout ?? DEFAULT_STREAM_TIMEOUT_MS;
+        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.defaultHeaders = options.defaultHeaders ?? {};
+        const fetchImpl = options.fetch ?? globalThis.fetch;
+        if (!fetchImpl) {
+            throw new APIConnectionError("No fetch implementation is available");
+        }
+        this.http = new HTTPClient({
+            baseURL: this.baseURL,
+            apiKey: this.apiKey,
+            timeout: this.timeout,
+            streamTimeout: this.streamTimeout,
+            maxRetries: this.maxRetries,
+            defaultHeaders: this.defaultHeaders,
+            fetchImpl,
+        });
+        this.responses = new ResponsesResource(this.http, "/v1/responses");
+        this.agent = new ResponsesResource(this.http, "/v1/agent");
+        this.models = new ModelsResource(this.http);
+        this.presets = new PresetsResource(this.http);
+        this.tools = new ToolsResource(this.http);
+    }
+}
+export { VERSION };

package/dist/errors.d.ts

@@ -0,0 +1,61 @@
+export interface APIErrorBody {
+    error?: {
+        message?: string;
+        code?: string;
+        type?: string;
+    };
+}
+export declare class APIError extends Error {
+    readonly status?: number;
+    readonly headers?: Headers;
+    readonly body?: unknown;
+    readonly code?: string;
+    readonly errorType?: string;
+    readonly requestID?: string;
+    constructor(message: string, options?: {
+        status?: number;
+        headers?: Headers;
+        body?: unknown;
+        code?: string;
+        errorType?: string;
+        requestID?: string;
+    });
+}
+export declare class APIConnectionError extends APIError {
+    constructor(message: string, cause?: unknown);
+}
+export declare class APIStatusError extends APIError {
+    readonly status: number;
+    constructor(message: string, status: number, headers: Headers, body: unknown, options?: {
+        code?: string;
+        errorType?: string;
+        requestID?: string;
+    });
+}
+export declare class AuthenticationError extends APIStatusError {
+    constructor(message: string, status: number, headers: Headers, body: unknown, options?: {});
+}
+export declare class PermissionDeniedError extends APIStatusError {
+    constructor(message: string, status: number, headers: Headers, body: unknown, options?: {});
+}
+export declare class NotFoundError extends APIStatusError {
+    constructor(message: string, status: number, headers: Headers, body: unknown, options?: {});
+}
+export declare class BadRequestError extends APIStatusError {
+    constructor(message: string, status: number, headers: Headers, body: unknown, options?: {});
+}
+export declare class RateLimitError extends APIStatusError {
+    readonly retryAfterMs?: number;
+    constructor(message: string, status: number, headers: Headers, body: unknown, retryAfterMs?: number, options?: {
+        code?: string;
+        errorType?: string;
+        requestID?: string;
+    });
+}
+export declare class InternalServerError extends APIStatusError {
+    constructor(message: string, status: number, headers: Headers, body: unknown, options?: {});
+}
+export declare function requestIDFromHeaders(headers: Headers): string | undefined;
+export declare function retryAfterMsFromHeaders(headers: Headers): number | undefined;
+export declare function parseResponseError(response: Response): Promise<APIStatusError>;
+export declare function isRetryableStatus(status: number): boolean;

package/dist/errors.js

@@ -0,0 +1,130 @@
+export class APIError extends Error {
+    status;
+    headers;
+    body;
+    code;
+    errorType;
+    requestID;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "APIError";
+        this.status = options.status;
+        this.headers = options.headers;
+        this.body = options.body;
+        this.code = options.code;
+        this.errorType = options.errorType;
+        this.requestID = options.requestID;
+    }
+}
+export class APIConnectionError extends APIError {
+    constructor(message, cause) {
+        super(message, { body: cause });
+        this.name = "APIConnectionError";
+    }
+}
+export class APIStatusError extends APIError {
+    status;
+    constructor(message, status, headers, body, options = {}) {
+        super(message, { status, headers, body, ...options });
+        this.name = "APIStatusError";
+        this.status = status;
+    }
+}
+export class AuthenticationError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "AuthenticationError";
+    }
+}
+export class PermissionDeniedError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "PermissionDeniedError";
+    }
+}
+export class NotFoundError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "NotFoundError";
+    }
+}
+export class BadRequestError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "BadRequestError";
+    }
+}
+export class RateLimitError extends APIStatusError {
+    retryAfterMs;
+    constructor(message, status, headers, body, retryAfterMs, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "RateLimitError";
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export class InternalServerError extends APIStatusError {
+    constructor(message, status, headers, body, options = {}) {
+        super(message, status, headers, body, options);
+        this.name = "InternalServerError";
+    }
+}
+export function requestIDFromHeaders(headers) {
+    return headers.get("x-request-id") ?? headers.get("request-id") ?? undefined;
+}
+export function retryAfterMsFromHeaders(headers) {
+    const raw = headers.get("retry-after");
+    if (!raw) {
+        return undefined;
+    }
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(raw);
+    if (Number.isFinite(date)) {
+        return Math.max(0, date - Date.now());
+    }
+    return undefined;
+}
+function errorFields(body) {
+    if (typeof body === "object" && body !== null && "error" in body) {
+        const err = body.error;
+        if (err && typeof err.message === "string") {
+            return { message: err.message, code: err.code, errorType: err.type };
+        }
+    }
+    return { message: "" };
+}
+export async function parseResponseError(response) {
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch {
+        body = await response.text().catch(() => "");
+    }
+    const { message, code, errorType } = errorFields(body);
+    const requestID = requestIDFromHeaders(response.headers);
+    const finalMessage = message || `API request failed with status ${response.status}`;
+    const common = { code, errorType, requestID };
+    switch (response.status) {
+        case 400:
+            return new BadRequestError(finalMessage, response.status, response.headers, body, common);
+        case 401:
+            return new AuthenticationError(finalMessage, response.status, response.headers, body, common);
+        case 403:
+            return new PermissionDeniedError(finalMessage, response.status, response.headers, body, common);
+        case 404:
+            return new NotFoundError(finalMessage, response.status, response.headers, body, common);
+        case 429:
+            return new RateLimitError(finalMessage, response.status, response.headers, body, retryAfterMsFromHeaders(response.headers), common);
+        default:
+            if (response.status >= 500) {
+                return new InternalServerError(finalMessage, response.status, response.headers, body, common);
+            }
+            return new APIStatusError(finalMessage, response.status, response.headers, body, common);
+    }
+}
+export function isRetryableStatus(status) {
+    return status === 408 || status === 409 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { AgentAPI, DEFAULT_MAX_RETRIES, DEFAULT_STREAM_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, VERSION } from "./client.js";
+export { Page, collectPage } from "./pagination.js";
+export type { PageParams, PageResult } from "./pagination.js";
+export { APIError, APIConnectionError, APIStatusError, AuthenticationError, BadRequestError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, isRetryableStatus, parseResponseError, } from "./errors.js";
+export * from "./types/index.js";
+export { functionCallOutputInput, pendingFunctionCalls, runLocalFunctionHandlers, } from "./local-functions.js";
+export type { LocalFunctionHandler, LocalFunctionHandlers } from "./local-functions.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { AgentAPI, DEFAULT_MAX_RETRIES, DEFAULT_STREAM_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, VERSION } from "./client.js";
+export { Page, collectPage } from "./pagination.js";
+export { APIError, APIConnectionError, APIStatusError, AuthenticationError, BadRequestError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, isRetryableStatus, parseResponseError, } from "./errors.js";
+export * from "./types/index.js";
+export { functionCallOutputInput, pendingFunctionCalls, runLocalFunctionHandlers, } from "./local-functions.js";

package/dist/internal/env.d.ts

@@ -0,0 +1 @@
+export declare function readEnv(name: string): string | undefined;

package/dist/internal/env.js

@@ -0,0 +1,4 @@
+export function readEnv(name) {
+    const env = globalThis.process?.env;
+    return env?.[name];
+}

package/dist/internal/http.d.ts

@@ -0,0 +1,18 @@
+import type { RequestOptions } from "../types/common.js";
+export interface HTTPClientOptions {
+    baseURL: string;
+    apiKey?: string;
+    timeout: number;
+    streamTimeout: number;
+    maxRetries: number;
+    defaultHeaders: Record<string, string>;
+    fetchImpl: typeof fetch;
+}
+export declare class HTTPClient {
+    private readonly options;
+    constructor(options: HTTPClientOptions);
+    request<T>(method: string, path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    stream<T>(path: string, body: unknown, options?: RequestOptions): Promise<AsyncIterable<T>>;
+    private fetchWithRetry;
+    private fetchOnce;
+}

package/dist/internal/http.js

@@ -0,0 +1,93 @@
+import { APIConnectionError, APIError, isRetryableStatus, parseResponseError, RateLimitError, } from "../errors.js";
+import { parseSSE } from "../streaming.js";
+import { USER_AGENT } from "../version.js";
+export class HTTPClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async request(method, path, body, options = {}) {
+        const response = await this.fetchWithRetry(method, path, body, options, false);
+        return (await response.json());
+    }
+    async stream(path, body, options = {}) {
+        const response = await this.fetchWithRetry("POST", path, body, options, true);
+        return parseSSE(response);
+    }
+    async fetchWithRetry(method, path, body, options, stream) {
+        const maxRetries = options.maxRetries ?? this.options.maxRetries;
+        let attempt = 0;
+        for (;;) {
+            try {
+                return await this.fetchOnce(method, path, body, options, stream);
+            }
+            catch (error) {
+                if (!(error instanceof APIError) || attempt >= maxRetries) {
+                    throw error;
+                }
+                const retryable = error instanceof APIConnectionError ||
+                    (error.status !== undefined && isRetryableStatus(error.status));
+                if (!retryable) {
+                    throw error;
+                }
+                attempt += 1;
+                const delayMs = retryDelayMs(error, attempt);
+                await sleep(delayMs);
+            }
+        }
+    }
+    async fetchOnce(method, path, body, options, stream) {
+        const controller = new AbortController();
+        const timeout = options.timeout ?? (stream ? this.options.streamTimeout : this.options.timeout);
+        const timeoutID = setTimeout(() => controller.abort(), timeout);
+        try {
+            const headers = {
+                Accept: stream ? "text/event-stream" : "application/json",
+                "User-Agent": USER_AGENT,
+                ...this.options.defaultHeaders,
+                ...options.headers,
+            };
+            if (body !== undefined) {
+                headers["Content-Type"] = "application/json";
+            }
+            if (this.options.apiKey) {
+                headers.Authorization = `Bearer ${this.options.apiKey}`;
+            }
+            const response = await this.options.fetchImpl(`${this.options.baseURL}${path}`, {
+                method,
+                headers,
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw await parseResponseError(response);
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof APIError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new APIConnectionError(`Request timed out after ${timeout}ms`, error);
+            }
+            throw new APIConnectionError("Request failed", error);
+        }
+        finally {
+            clearTimeout(timeoutID);
+        }
+    }
+}
+function retryDelayMs(error, attempt) {
+    if (error instanceof RateLimitError && error.retryAfterMs !== undefined) {
+        return error.retryAfterMs;
+    }
+    const base = 250;
+    const cap = 8000;
+    const exponential = Math.min(cap, base * 2 ** (attempt - 1));
+    const jitter = Math.floor(Math.random() * 100);
+    return exponential + jitter;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/internal/output-text.d.ts

@@ -0,0 +1,2 @@
+import type { AgentResponse } from "../types/responses.js";
+export declare function addOutputText(response: AgentResponse): AgentResponse;

package/dist/internal/output-text.js

@@ -0,0 +1,12 @@
+export function addOutputText(response) {
+    if (response.output_text !== undefined) {
+        return response;
+    }
+    response.output_text = response.output
+        .filter((item) => item.type === "message")
+        .flatMap((item) => item.content)
+        .filter((part) => part.type === "output_text")
+        .map((part) => part.text ?? "")
+        .join("");
+    return response;
+}

package/dist/internal/query.d.ts

@@ -0,0 +1 @@
+export declare function buildQuery(params: Record<string, string | number | undefined>): string;

package/dist/internal/query.js

@@ -0,0 +1,10 @@
+export function buildQuery(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== "") {
+            search.set(key, String(value));
+        }
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : "";
+}

package/dist/local-functions.d.ts

@@ -0,0 +1,9 @@
+import type { FunctionCallOutputInput } from "./types/input.js";
+import type { AgentResponse, FunctionCallOutputItem } from "./types/responses.js";
+/** Pending client-executed function calls from a requires_action response. */
+export declare function pendingFunctionCalls(response: AgentResponse): FunctionCallOutputItem[];
+export declare function functionCallOutputInput(callID: string, output: string | Record<string, unknown>): FunctionCallOutputInput;
+export type LocalFunctionHandler = (args: Record<string, unknown>) => string | Record<string, unknown> | Promise<string | Record<string, unknown>>;
+export type LocalFunctionHandlers = Record<string, LocalFunctionHandler>;
+/** Run local handlers for pending function calls and return function_call_output input items. */
+export declare function runLocalFunctionHandlers(response: AgentResponse, handlers: LocalFunctionHandlers): Promise<FunctionCallOutputInput[]>;

package/dist/local-functions.js

@@ -0,0 +1,32 @@
+/** Pending client-executed function calls from a requires_action response. */
+export function pendingFunctionCalls(response) {
+    if (response.status !== "requires_action") {
+        return [];
+    }
+    return response.output.filter((item) => item.type === "function_call");
+}
+export function functionCallOutputInput(callID, output) {
+    return {
+        type: "function_call_output",
+        call_id: callID,
+        output: typeof output === "string" ? output : JSON.stringify(output),
+    };
+}
+/** Run local handlers for pending function calls and return function_call_output input items. */
+export async function runLocalFunctionHandlers(response, handlers) {
+    const pending = pendingFunctionCalls(response);
+    const outputs = [];
+    for (const call of pending) {
+        const handler = handlers[call.name];
+        if (!handler) {
+            throw new Error(`no local handler registered for function ${call.name}`);
+        }
+        let args = {};
+        if (call.arguments) {
+            args = JSON.parse(call.arguments);
+        }
+        const result = await handler(args);
+        outputs.push(functionCallOutputInput(call.call_id, result));
+    }
+    return outputs;
+}

package/dist/pagination.d.ts

@@ -0,0 +1,21 @@
+export interface PageParams {
+    limit?: number;
+    page_token?: string;
+}
+export interface PageResult<T> {
+    data: T[];
+    has_more: boolean;
+    next_page_token?: string;
+}
+export declare class Page<TItem, TParams extends PageParams> implements AsyncIterable<TItem> {
+    private readonly fetchPage;
+    readonly params: TParams;
+    readonly data: TItem[];
+    readonly hasMore: boolean;
+    readonly nextPageToken?: string | undefined;
+    constructor(fetchPage: (params: TParams) => Promise<PageResult<TItem>>, params: TParams, data: TItem[], hasMore: boolean, nextPageToken?: string | undefined);
+    [Symbol.asyncIterator](): AsyncIterator<TItem>;
+    getNextPage(): Promise<Page<TItem, TParams> | null>;
+    iterateAll(): AsyncGenerator<TItem, void, undefined>;
+}
+export declare function collectPage<TItem, TParams extends PageParams>(fetchPage: (params: TParams) => Promise<PageResult<TItem>>, params: TParams): Promise<Page<TItem, TParams>>;