@reacon-io/sdk 0.1.0-beta.3

package/dist/Http.d.ts

@@ -0,0 +1,45 @@
+export interface RetryOptions {
+    /** Additional attempts, from zero to three. Retries are disabled by default. */
+    maxRetries: number;
+    /** Initial exponential-backoff bound, in milliseconds. Defaults to 100. */
+    baseDelayMs?: number;
+    /** Maximum wait, in milliseconds. Defaults to 2000. Longer Retry-After returns the final error. */
+    maxDelayMs?: number;
+}
+/** Options accepted by every generated JSON/CSV method. */
+export interface RequestOptions extends RequestInit {
+    /** Total network deadline, including response body reads. Defaults to 30s. */
+    timeoutMs?: number;
+    /** Overrides safeRetries for this request. Only audited read routes may retry. */
+    retry?: RetryOptions | false;
+}
+export declare class ReaconRetryPolicyError extends Error {
+    constructor(message: string);
+}
+export declare class ReaconRequestTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+export declare class ReaconRequestAbortedError extends Error {
+    readonly reason?: unknown;
+    constructor(reason?: unknown);
+}
+export declare class ReaconTransportError extends Error {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export declare class ReaconResponseDecodeError extends Error {
+    readonly body: string;
+    readonly status: number;
+    readonly headers: Headers;
+    readonly requestId?: string;
+    constructor(response: Response, body: string, message: string);
+}
+export declare function isReaconRequestError(error: unknown): boolean;
+/** The API uses both flat errors and an error envelope. Keep the full body too. */
+export declare function responseErrorCode(body: unknown): string | undefined;
+/** One attempt by default, bounded opt-in retries on audited reads only; the deadline remains active until
+ * the body ends or is cancelled, including when callers use a Raw method. */
+export declare function fetchWithRequestPolicy(fetchApi: typeof fetch, url: string, options: RequestOptions, defaultTimeoutMs: number, defaultRetries?: RetryOptions): Promise<Response>;
+export declare function responseErrorBody(response: Response): Promise<unknown>;
+export declare function responseJson(response: Response): Promise<unknown>;

package/dist/Http.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaconResponseDecodeError = exports.ReaconTransportError = exports.ReaconRequestAbortedError = exports.ReaconRequestTimeoutError = exports.ReaconRetryPolicyError = void 0;
+exports.isReaconRequestError = isReaconRequestError;
+exports.responseErrorCode = responseErrorCode;
+exports.fetchWithRequestPolicy = fetchWithRequestPolicy;
+exports.responseErrorBody = responseErrorBody;
+exports.responseJson = responseJson;
+// Copyright Reacon contributors. Licensed under Apache-2.0.
+const RetryPolicy_js_1 = require("./RetryPolicy.js");
+class ReaconRetryPolicyError extends Error {
+    constructor(message) { super(message); this.name = 'ReaconRetryPolicyError'; }
+}
+exports.ReaconRetryPolicyError = ReaconRetryPolicyError;
+class ReaconRequestTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super('Reacon request deadline exceeded');
+        this.timeoutMs = timeoutMs;
+        this.name = 'ReaconRequestTimeoutError';
+    }
+}
+exports.ReaconRequestTimeoutError = ReaconRequestTimeoutError;
+class ReaconRequestAbortedError extends Error {
+    constructor(reason) {
+        super('Reacon request cancelled');
+        this.reason = reason;
+        this.name = 'AbortError';
+    }
+}
+exports.ReaconRequestAbortedError = ReaconRequestAbortedError;
+class ReaconTransportError extends Error {
+    constructor(cause) {
+        super('Reacon request transport failed');
+        this.cause = cause;
+        this.name = 'ReaconTransportError';
+    }
+}
+exports.ReaconTransportError = ReaconTransportError;
+class ReaconResponseDecodeError extends Error {
+    constructor(response, body, message) {
+        super(message);
+        this.body = body;
+        this.name = 'ReaconResponseDecodeError';
+        this.status = response.status;
+        this.headers = new Headers(response.headers);
+        this.requestId = response.headers.get('x-request-id') ?? undefined;
+    }
+}
+exports.ReaconResponseDecodeError = ReaconResponseDecodeError;
+function isReaconRequestError(error) {
+    return error instanceof ReaconRequestTimeoutError || error instanceof ReaconRequestAbortedError || error instanceof ReaconTransportError || error instanceof ReaconRetryPolicyError;
+}
+function retryAfterMs(value) {
+    if (value === null)
+        return undefined;
+    if (/^\d+$/.test(value.trim()))
+        return Number(value.trim()) * 1000;
+    if (!/^(Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} [A-Z][a-z]{2} \d{4} \d{2}:\d{2}:\d{2} GMT$/.test(value))
+        return undefined;
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - Date.now()) : undefined;
+}
+function backoff(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        const stop = () => { clearTimeout(timer); signal.removeEventListener('abort', stop); reject(signal.reason); };
+        const timer = setTimeout(() => { signal.removeEventListener('abort', stop); resolve(); }, milliseconds);
+        signal.addEventListener('abort', stop, { once: true });
+        if (signal.aborted)
+            stop();
+    });
+}
+/** The API uses both flat errors and an error envelope. Keep the full body too. */
+function responseErrorCode(body) {
+    if (body === null || typeof body !== 'object')
+        return undefined;
+    const record = body;
+    if (typeof record.code === 'string')
+        return record.code;
+    if (record.error !== null && typeof record.error === 'object') {
+        const code = record.error.code;
+        if (typeof code === 'string')
+            return code;
+    }
+    return undefined;
+}
+/** One attempt by default, bounded opt-in retries on audited reads only; the deadline remains active until
+ * the body ends or is cancelled, including when callers use a Raw method. */
+async function fetchWithRequestPolicy(fetchApi, url, options, defaultTimeoutMs, defaultRetries) {
+    const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647)
+        throw new RangeError('timeoutMs must be positive and at most 2147483647');
+    const eligible = (0, RetryPolicy_js_1.auditedRead)(options.method ?? 'GET', url) && options.body == null;
+    const retry = options.retry === undefined ? (eligible ? defaultRetries : undefined) : options.retry;
+    const maxRetries = retry ? retry.maxRetries : 0;
+    const baseDelay = retry ? retry.baseDelayMs ?? 100 : 100, maxDelay = retry ? retry.maxDelayMs ?? 2000 : 2000;
+    if (!Number.isSafeInteger(maxRetries) || maxRetries < 0 || maxRetries > RetryPolicy_js_1.maximumMaxRetries ||
+        !Number.isFinite(baseDelay) || baseDelay < 1 || !Number.isFinite(maxDelay) || maxDelay < baseDelay || maxDelay > 60000)
+        throw new ReaconRetryPolicyError('Invalid bounded retry settings');
+    if (maxRetries > 0 && !eligible)
+        throw new ReaconRetryPolicyError('Automatic retries are not allowed for this operation');
+    const deadline = Date.now() + timeoutMs;
+    const controller = new AbortController(), parent = options.signal;
+    let reader;
+    let bodyController;
+    let finished = false;
+    const cleanup = () => { finished = true; clearTimeout(timer); parent?.removeEventListener('abort', onAbort); };
+    const stop = (reason) => {
+        if (finished)
+            return;
+        controller.abort(reason);
+        try {
+            bodyController?.error(reason);
+        }
+        catch { /* already terminal */ }
+        void reader?.cancel(reason).catch(() => { });
+        cleanup();
+    };
+    const onAbort = () => stop(new ReaconRequestAbortedError(parent?.reason));
+    const timer = setTimeout(() => stop(new ReaconRequestTimeoutError(timeoutMs)), timeoutMs);
+    parent?.addEventListener('abort', onAbort, { once: true });
+    if (parent?.aborted)
+        onAbort();
+    try {
+        if (controller.signal.aborted)
+            throw controller.signal.reason;
+        const { timeoutMs: _timeout, retry: _retry, ...init } = options;
+        let response;
+        for (let attempt = 0;; attempt++) {
+            if (controller.signal.aborted)
+                throw controller.signal.reason;
+            response = await fetchApi(url, { ...init, redirect: 'manual', signal: controller.signal });
+            if (controller.signal.aborted) {
+                await response.body?.cancel();
+                throw controller.signal.reason;
+            }
+            if (attempt >= maxRetries || !RetryPolicy_js_1.retryableStatuses.includes(response.status))
+                break;
+            const exponential = Math.min(maxDelay, baseDelay * 2 ** attempt);
+            const delay = Math.max(exponential * (0.5 + Math.random() * 0.5), retryAfterMs(response.headers.get('retry-after')) ?? 0);
+            // Never shorten server Retry-After or start another attempt past the total deadline.
+            if (delay > maxDelay || delay >= deadline - Date.now())
+                break;
+            await response.body?.cancel();
+            await backoff(delay, controller.signal);
+        }
+        if (controller.signal.aborted) {
+            await response.body?.cancel();
+            throw controller.signal.reason;
+        }
+        if (!response.body) {
+            cleanup();
+            return response;
+        }
+        reader = response.body.getReader();
+        const body = new ReadableStream({
+            start(value) { bodyController = value; },
+            async pull(value) {
+                try {
+                    const item = await reader.read();
+                    if (controller.signal.aborted)
+                        throw controller.signal.reason;
+                    if (item.done) {
+                        cleanup();
+                        value.close();
+                    }
+                    else
+                        value.enqueue(item.value);
+                }
+                catch (cause) {
+                    const error = controller.signal.aborted ? controller.signal.reason : new ReaconTransportError(cause);
+                    cleanup();
+                    try {
+                        value.error(error);
+                    }
+                    catch { /* cancellation won */ }
+                    void reader?.cancel(error).catch(() => { });
+                }
+            },
+            async cancel(reason) { cleanup(); controller.abort(reason); try {
+                await reader?.cancel(reason);
+            }
+            catch { } },
+        });
+        const result = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+        Object.defineProperty(result, 'url', { value: response.url });
+        return result;
+    }
+    catch (cause) {
+        cleanup();
+        if (controller.signal.aborted)
+            throw controller.signal.reason;
+        throw new ReaconTransportError(cause);
+    }
+}
+async function responseErrorBody(response) {
+    const text = await response.clone().text();
+    if (/^(application\/json|[^;]+\+json)(\s*;|$)/i.test(response.headers.get('content-type') ?? '')) {
+        try {
+            return JSON.parse(text);
+        }
+        catch { /* retain malformed error bodies */ }
+    }
+    return text;
+}
+async function responseJson(response) {
+    const text = await response.text();
+    if (!/^(application\/json|[^;]+\+json)(\s*;|$)/i.test(response.headers.get('content-type') ?? ''))
+        throw new ReaconResponseDecodeError(response, text, 'Expected a JSON response');
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new ReaconResponseDecodeError(response, text, 'Malformed JSON response');
+    }
+}

package/dist/Reacon.d.ts

@@ -0,0 +1,87 @@
+import { ConfigurationParameters } from './runtime.js';
+import { DomainsApi, EmailsApi, LeadsApi, VerificationApi, ListLeadsRequest, ListEmailsRequest, ListEmailMentionsRequest } from './apis/index.js';
+import { VerificationStage, VerificationProgress, VerificationFinal, VerificationStreamError } from './models/index.js';
+export type VerificationEvent = {
+    type: 'stage';
+    data: VerificationStage;
+    raw: Record<string, unknown>;
+} | {
+    type: 'progress';
+    data: VerificationProgress;
+    raw: Record<string, unknown>;
+} | {
+    type: 'final';
+    data: VerificationFinal;
+    raw: Record<string, unknown>;
+} | {
+    type: 'unknown';
+    data: Record<string, unknown>;
+    raw: Record<string, unknown>;
+};
+export declare class ReaconProtocolError extends Error {
+    constructor(message: string);
+}
+export declare class ReaconTimeoutError extends Error {
+    readonly phase: 'idle' | 'total';
+    constructor(phase: 'idle' | 'total');
+}
+export declare class ReaconStreamApiError extends Error {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly body: unknown;
+    readonly event?: VerificationStreamError;
+    readonly requestId?: string;
+    constructor(status: number, headers: Headers, body: unknown, event?: VerificationStreamError);
+}
+export interface VerificationStreamOptions {
+    cacheMaxAge?: 'live' | '1d' | '1w' | '1m';
+    onlyIfFree?: 'true' | 'false';
+    signal?: AbortSignal;
+    /** Deadline from the first iteration through completion, including body reads. */
+    totalTimeoutMs?: number;
+    /** Maximum wait for the next network chunk; consumer processing does not reset the total deadline. */
+    idleTimeoutMs?: number;
+    /** Maximum buffered event characters. Defaults to 1 MiB. */
+    maxEventChars?: number;
+}
+/** Streaming is explicit, lazy and never reconnects or retries. */
+export declare class VerificationClient extends VerificationApi {
+    stream(email: string, options?: VerificationStreamOptions): AsyncGenerator<VerificationEvent>;
+}
+export interface PaginationOptions {
+    /** Maximum requests, including empty pages. Defaults to 100; zero makes no requests. */
+    maxPages?: number;
+    /** Maximum returned items. Each requested page is capped to the remaining bound. Defaults to 10000. */
+    maxItems?: number;
+    signal?: AbortSignal;
+    /** Deadline for each page, including reading its body. */
+    timeoutMs?: number;
+}
+export interface EmailPaginationOptions extends PaginationOptions {
+    /** Explicit acknowledgement that listEmails may spend credits on every page. Not a spending cap. */
+    allowPaidRequests?: boolean;
+}
+export declare class LeadsClient extends LeadsApi {
+    pages(request: Omit<ListLeadsRequest, 'offset'>, options?: PaginationOptions): AsyncGenerator<import("./models/LeadPage.js").LeadPage, any, any>;
+    items(request: Omit<ListLeadsRequest, 'offset'>, options?: PaginationOptions): AsyncGenerator<import("./models/LeadPageResultsInner.js").LeadPageResultsInner, any, any>;
+}
+export declare class EmailsClient extends EmailsApi {
+    private pageOverrides;
+    private paginationRequest;
+    /** Every page may consume credits unless onlyIfFree is explicitly enabled. */
+    pages(request: Omit<ListEmailsRequest, 'offset'>, options?: EmailPaginationOptions): AsyncGenerator<import("./models/EmailPage.js").EmailPage, any, any>;
+    items(request: Omit<ListEmailsRequest, 'offset'>, options?: EmailPaginationOptions): AsyncGenerator<import("./models/EmailPageResultsInner.js").EmailPageResultsInner, any, any>;
+    mentionPages(request: ListEmailMentionsRequest, options?: PaginationOptions): AsyncGenerator<import("./models/EmailMentionsPage.js").EmailMentionsPage, any, any>;
+    mentionItems(request: ListEmailMentionsRequest, options?: PaginationOptions): AsyncGenerator<import("./models/EmailMention.js").EmailMention, any, any>;
+}
+export interface ReaconOptions extends Omit<ConfigurationParameters, 'apiKey'> {
+    apiKey: string;
+}
+/** Each client has its own credentials and transport. Generated one-page JSON methods remain available. */
+export declare class Reacon {
+    readonly domains: DomainsApi;
+    readonly emails: EmailsClient;
+    readonly leads: LeadsClient;
+    readonly verification: VerificationClient;
+    constructor(options: ReaconOptions);
+}

package/dist/Reacon.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reacon = exports.EmailsClient = exports.LeadsClient = exports.VerificationClient = exports.ReaconStreamApiError = exports.ReaconTimeoutError = exports.ReaconProtocolError = void 0;
+// Copyright Reacon contributors. Licensed under Apache-2.0.
+const eventsource_parser_1 = require("eventsource-parser");
+const runtime_js_1 = require("./runtime.js");
+const index_js_1 = require("./apis/index.js");
+const Http_js_1 = require("./Http.js");
+const index_js_2 = require("./models/index.js");
+class ReaconProtocolError extends Error {
+    constructor(message) { super(message); this.name = 'ReaconProtocolError'; }
+}
+exports.ReaconProtocolError = ReaconProtocolError;
+class ReaconTimeoutError extends Error {
+    constructor(phase) {
+        super(`Reacon ${phase} timeout`);
+        this.phase = phase;
+        this.name = 'ReaconTimeoutError';
+    }
+}
+exports.ReaconTimeoutError = ReaconTimeoutError;
+class ReaconStreamApiError extends Error {
+    constructor(status, headers, body, event) {
+        super(event ? `Reacon stream failed: ${event.code}` : `Reacon returned HTTP ${status}`);
+        this.status = status;
+        this.headers = headers;
+        this.body = body;
+        this.event = event;
+        this.name = 'ReaconStreamApiError';
+        this.requestId = headers.get('x-request-id') ?? undefined;
+    }
+}
+exports.ReaconStreamApiError = ReaconStreamApiError;
+function positive(value, name) {
+    if (!Number.isFinite(value) || value <= 0)
+        throw new RangeError(`${name} must be positive and finite`);
+    return value;
+}
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function classify(raw) {
+    if ('result' in raw) {
+        const result = raw.result;
+        if (!object(result) || typeof raw.updatedAt !== 'string' || typeof result.status !== 'string' || typeof result.catchAll !== 'boolean' || typeof result.disposable !== 'boolean' || !(result.acceptsAll === null || typeof result.acceptsAll === 'boolean'))
+            throw new ReaconProtocolError('Malformed verification result event');
+        return { type: 'final', data: (0, index_js_2.VerificationFinalFromJSON)(raw), raw };
+    }
+    if ('stage' in raw) {
+        if (typeof raw.stage !== 'string' || typeof raw.updatedAt !== 'string')
+            throw new ReaconProtocolError('Malformed verification stage event');
+        return { type: 'stage', data: (0, index_js_2.VerificationStageFromJSON)(raw), raw };
+    }
+    if ('state' in raw) {
+        if (typeof raw.state !== 'string' || typeof raw.requestId !== 'string' || typeof raw.updatedAt !== 'string')
+            throw new ReaconProtocolError('Malformed verification progress event');
+        return { type: 'progress', data: (0, index_js_2.VerificationProgressFromJSON)(raw), raw };
+    }
+    return { type: 'unknown', data: raw, raw };
+}
+/** Streaming is explicit, lazy and never reconnects or retries. */
+class VerificationClient extends index_js_1.VerificationApi {
+    async *stream(email, options = {}) {
+        const total = positive(options.totalTimeoutMs ?? 300000, 'totalTimeoutMs');
+        const idle = positive(options.idleTimeoutMs ?? 30000, 'idleTimeoutMs');
+        const maxBufferSize = positive(options.maxEventChars ?? 1024 * 1024, 'maxEventChars');
+        if (typeof email !== 'string' || !email)
+            throw new TypeError('email is required');
+        if (options.onlyIfFree !== undefined && !['true', 'false'].includes(options.onlyIfFree))
+            throw new TypeError('Invalid onlyIfFree option');
+        if (options.cacheMaxAge !== undefined && !['live', '1d', '1w', '1m'].includes(options.cacheMaxAge))
+            throw new TypeError('Invalid cacheMaxAge option');
+        const controller = new AbortController();
+        const onAbort = () => controller.abort(options.signal?.reason ?? new DOMException('Aborted', 'AbortError'));
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        if (options.signal?.aborted)
+            onAbort();
+        const timer = setTimeout(() => controller.abort(new ReaconTimeoutError('total')), total);
+        let reader;
+        const close = async () => { if (reader) {
+            try {
+                await reader.cancel();
+            }
+            catch { }
+        } };
+        try {
+            if (controller.signal.aborted)
+                throw controller.signal.reason;
+            const url = new URL(this.configuration.basePath.replace(/\/$/, '') + '/v1/verify');
+            url.searchParams.set('email', email);
+            if (options.cacheMaxAge !== undefined)
+                url.searchParams.set('cacheMaxAge', options.cacheMaxAge);
+            if (options.onlyIfFree !== undefined)
+                url.searchParams.set('onlyIfFree', options.onlyIfFree);
+            const headers = new Headers(this.configuration.headers);
+            headers.set('Accept', 'text/event-stream');
+            if (this.configuration.apiKey)
+                headers.set('X-API-Key', await this.configuration.apiKey('X-API-Key'));
+            const response = await (this.configuration.fetchApi ?? fetch)(url.toString(), {
+                method: 'GET', headers, signal: controller.signal, redirect: 'manual', credentials: this.configuration.credentials,
+            });
+            reader = response.body?.getReader();
+            const read = async () => {
+                const idleTimer = setTimeout(() => controller.abort(new ReaconTimeoutError('idle')), idle);
+                try {
+                    return await reader.read();
+                }
+                finally {
+                    clearTimeout(idleTimer);
+                }
+            };
+            if (!response.ok) {
+                let body = '';
+                const decoder = new TextDecoder();
+                if (reader)
+                    while (body.length < 64 * 1024) {
+                        const chunk = await read();
+                        if (chunk.done)
+                            break;
+                        body += decoder.decode(chunk.value, { stream: true });
+                    }
+                body = body.slice(0, 64 * 1024);
+                let parsed = body;
+                try {
+                    parsed = JSON.parse(body);
+                }
+                catch { }
+                throw new ReaconStreamApiError(response.status, response.headers, parsed);
+            }
+            if (response.headers.get('content-type')?.split(';')[0].trim().toLowerCase() !== 'text/event-stream' || !reader)
+                throw new ReaconProtocolError('Expected a text/event-stream response body');
+            const pending = [];
+            const parser = (0, eventsource_parser_1.createParser)({ maxBufferSize, onEvent: event => pending.push(event.data),
+                onError: error => { if (error.type === 'max-buffer-size-exceeded')
+                    throw new ReaconProtocolError('SSE event exceeds configured buffer limit'); },
+            });
+            const decoder = new TextDecoder('utf-8', { fatal: true });
+            while (true) {
+                const chunk = await read();
+                if (chunk.done)
+                    throw new ReaconProtocolError('Verification stream ended before a terminal event');
+                parser.feed(decoder.decode(chunk.value, { stream: true }));
+                while (pending.length) {
+                    let raw;
+                    try {
+                        raw = JSON.parse(pending.shift());
+                    }
+                    catch {
+                        throw new ReaconProtocolError('Malformed SSE JSON payload');
+                    }
+                    if (!object(raw))
+                        throw new ReaconProtocolError('Expected an SSE JSON object');
+                    if ('error' in raw) {
+                        if (typeof raw.error !== 'string' || typeof raw.code !== 'string' || typeof raw.updatedAt !== 'string')
+                            throw new ReaconProtocolError('Malformed verification error event');
+                        throw new ReaconStreamApiError(response.status, response.headers, raw, (0, index_js_2.VerificationStreamErrorFromJSON)(raw));
+                    }
+                    const event = classify(raw);
+                    // Close before yielding final: the consumer need not call next again.
+                    if (event.type === 'final') {
+                        await close();
+                        clearTimeout(timer);
+                        options.signal?.removeEventListener('abort', onAbort);
+                        yield event;
+                        return;
+                    }
+                    yield event;
+                }
+            }
+        }
+        catch (error) {
+            if (controller.signal.aborted)
+                throw controller.signal.reason;
+            throw error;
+        }
+        finally {
+            await close();
+            reader?.releaseLock();
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', onAbort);
+            controller.abort();
+        }
+    }
+}
+exports.VerificationClient = VerificationClient;
+const bound = (value, name) => {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 1000000)
+        throw new RangeError(`${name} must be an integer from 0 to 1000000`);
+    return value;
+};
+function cancelled(signal) {
+    if (signal?.aborted)
+        throw new Http_js_1.ReaconRequestAbortedError(signal.reason);
+}
+/** Snapshot inputs immediately; make requests only as the caller advances. */
+function cursorPages(request, options, fetchPage) {
+    const query = { ...request }, settings = { ...options };
+    return (async function* () {
+        const maxPages = bound(settings.maxPages ?? 100, 'maxPages'), maxItems = bound(settings.maxItems ?? 10000, 'maxItems');
+        if (query.offset !== undefined)
+            throw new TypeError('Cursor iterators do not accept offset; use the one-page method for offset pagination');
+        const pageSize = Math.min(query.limit ?? 100, query.xLrLimit ?? 500);
+        if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > 500)
+            throw new RangeError('Page size must be an integer from 1 to 500');
+        const seen = new Set();
+        const firstCursor = query.xLrCursor ?? query.cursor;
+        if (firstCursor !== undefined)
+            seen.add(firstCursor);
+        let count = 0;
+        for (let index = 0; index < maxPages && count < maxItems; index++) {
+            cancelled(settings.signal);
+            const limit = Math.min(pageSize, maxItems - count);
+            const page = await fetchPage({ ...query, limit, ...(query.xLrLimit !== undefined ? { xLrLimit: limit } : {}) }, settings);
+            cancelled(settings.signal);
+            if (!Array.isArray(page.results) || page.results.length > limit)
+                throw new ReaconProtocolError('Pagination response exceeds requested item bound');
+            count += page.results.length;
+            const next = page.nextCursor;
+            if (next != null && (typeof next !== 'string' || !next))
+                throw new ReaconProtocolError('Invalid pagination cursor');
+            yield page;
+            if (next == null || index + 1 >= maxPages || count >= maxItems)
+                return;
+            if (seen.has(next))
+                throw new ReaconProtocolError('Repeated pagination cursor');
+            seen.add(next);
+            query.cursor = next;
+            if (query.xLrCursor !== undefined)
+                query.xLrCursor = next;
+        }
+    })();
+}
+async function* cursorItems(pages, signal) {
+    for await (const page of pages)
+        for (const item of page.results) {
+            cancelled(signal);
+            yield item;
+        }
+}
+class LeadsClient extends index_js_1.LeadsApi {
+    pages(request, options = {}) {
+        return cursorPages(request, options, (query, settings) => this.listLeads(query, { signal: settings.signal, timeoutMs: settings.timeoutMs, retry: false }));
+    }
+    items(request, options = {}) {
+        return cursorItems(this.pages(request, options), options.signal);
+    }
+}
+exports.LeadsClient = LeadsClient;
+class EmailsClient extends index_js_1.EmailsApi {
+    pageOverrides(query, settings) {
+        return async ({ init }) => {
+            const headers = new Headers(init.headers);
+            // Configuration headers may use different casing from generated headers.
+            // Replace the effective values, avoiding a stale comma-joined cursor.
+            if (query.xLrCursor !== undefined)
+                headers.set('X-LR-Cursor', query.xLrCursor);
+            if (query.xLrLimit !== undefined)
+                headers.set('X-LR-Limit', String(query.xLrLimit));
+            return { headers, signal: settings.signal, timeoutMs: settings.timeoutMs, retry: false };
+        };
+    }
+    paginationRequest(request) {
+        const headers = new Headers(this.configuration.headers);
+        const cursor = request.xLrCursor ?? headers.get('X-LR-Cursor') ?? undefined;
+        const limit = request.xLrLimit ?? (headers.has('X-LR-Limit') ? Number(headers.get('X-LR-Limit')) : undefined);
+        return { ...request, xLrCursor: cursor, xLrLimit: limit };
+    }
+    /** Every page may consume credits unless onlyIfFree is explicitly enabled. */
+    pages(request, options = {}) {
+        const query = this.paginationRequest(request), settings = { ...options };
+        return cursorPages(query, settings, (next, pageOptions) => {
+            if (query.onlyIfFree !== 'true' && settings.allowPaidRequests !== true)
+                throw new TypeError('Set onlyIfFree to true or acknowledge allowPaidRequests');
+            return this.listEmails(next, this.pageOverrides(next, pageOptions));
+        });
+    }
+    items(request, options = {}) {
+        return cursorItems(this.pages(request, options), options.signal);
+    }
+    mentionPages(request, options = {}) {
+        const query = this.paginationRequest(request);
+        if (query.xLrLimit !== undefined)
+            query.limit = query.xLrLimit; // Mentions use header precedence, not the email-list minimum rule.
+        return cursorPages(query, options, (next, settings) => this.listEmailMentions(next, this.pageOverrides(next, settings)));
+    }
+    mentionItems(request, options = {}) {
+        return cursorItems(this.mentionPages(request, options), options.signal);
+    }
+}
+exports.EmailsClient = EmailsClient;
+/** Each client has its own credentials and transport. Generated one-page JSON methods remain available. */
+class Reacon {
+    constructor(options) {
+        if (!options.apiKey)
+            throw new TypeError('apiKey is required');
+        const configuration = new runtime_js_1.Configuration({ ...options, headers: { ...options.headers } });
+        this.domains = new index_js_1.DomainsApi(configuration);
+        this.emails = new EmailsClient(configuration);
+        this.leads = new LeadsClient(configuration);
+        this.verification = new VerificationClient(configuration);
+    }
+}
+exports.Reacon = Reacon;

package/dist/RetryPolicy.d.ts

@@ -0,0 +1,3 @@
+export declare const maximumMaxRetries = 3;
+export declare const retryableStatuses: number[];
+export declare function auditedRead(method: string, url: string): boolean;

package/dist/RetryPolicy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryableStatuses = exports.maximumMaxRetries = void 0;
+exports.auditedRead = auditedRead;
+// Generated from the reviewed Reacon retry policy.
+exports.maximumMaxRetries = 3;
+exports.retryableStatuses = [429, 502, 503, 504];
+const routes = ["^/v1/whoami$", "^/v1/domains/[^/]+/counts$", "^/v1/teams/[^/]+/leads$"].map(pattern => new RegExp(pattern));
+function auditedRead(method, url) {
+    return method.toUpperCase() === 'GET' && routes.some(route => route.test(new URL(url).pathname));
+}