@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/api/client.methods.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=client.methods.test.d.ts.map

package/dist/api/client.methods.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.methods.test.d.ts","sourceRoot":"","sources":["../../src/api/client.methods.test.ts"],"names":[],"mappings":""}

package/dist/api/client.methods.test.js

@@ -1,158 +0,0 @@
-import { describe, it, expect, vi, beforeEach, } from "vitest";
-import { createZapierApi } from "./client";
-import * as router from "./router";
-vi.mock("./router");
-describe("ZapierApiClient Methods & Routing", () => {
-    let mockFetch;
-    let mockMatchRoute;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockFetch = vi.fn();
-        mockMatchRoute = vi.mocked(router.matchRoute);
-        // Default fetch implementation
-        mockFetch.mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({ data: "default-response" }),
-        });
-    });
-    const createClient = () => createZapierApi({
-        baseUrl: "https://api.zapier.com",
-        token: "test-token",
-        fetch: mockFetch,
-    });
-    describe("GET requests", () => {
-        it("should route GET requests to handler when matched", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ id: 1, name: "Test" });
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "123" },
-            });
-            const result = await client.get("/api/resource/123", {
-                searchParams: { include: "details" },
-            });
-            expect(mockMatchRoute).toHaveBeenCalledWith("GET", "/api/resource/123");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    id: "123",
-                    include: "details",
-                },
-                deps: expect.objectContaining({
-                    httpClient: expect.any(Object),
-                }),
-            });
-            expect(result).toEqual({ id: 1, name: "Test" });
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-        it("should fallback to plain fetch when no route matches", async () => {
-            const client = createClient();
-            mockMatchRoute.mockReturnValue(null);
-            await client.get("/api/unknown");
-            expect(mockMatchRoute).toHaveBeenCalledWith("GET", "/api/unknown");
-            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining("/api/unknown"), expect.objectContaining({
-                method: "GET",
-            }));
-        });
-    });
-    describe("POST requests", () => {
-        it("should route POST requests to handler with body", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ success: true });
-            const body = { name: "New Item" };
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: {},
-            });
-            await client.post("/api/resource", body);
-            expect(mockMatchRoute).toHaveBeenCalledWith("POST", "/api/resource");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    name: "New Item",
-                },
-                deps: expect.objectContaining({
-                    httpClient: expect.any(Object),
-                }),
-            });
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-        it("should merge body, params, and query params for handler", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ success: true });
-            const body = { name: "Updated Item" };
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "456" },
-            });
-            await client.post("/api/resource/456", body, {
-                searchParams: { version: "2" },
-            });
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    name: "Updated Item", // from body
-                    id: "456", // from route params
-                    version: "2", // from query params
-                },
-                deps: expect.any(Object),
-            });
-        });
-    });
-    describe("PUT requests", () => {
-        it("should route PUT requests to handler", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ updated: true });
-            const body = { status: "active" };
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "789" },
-            });
-            await client.put("/api/resource/789", body);
-            expect(mockMatchRoute).toHaveBeenCalledWith("PUT", "/api/resource/789");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    status: "active",
-                    id: "789",
-                },
-                deps: expect.any(Object),
-            });
-        });
-    });
-    describe("DELETE requests", () => {
-        it("should route DELETE requests to handler", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({ deleted: true });
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: { id: "999" },
-            });
-            await client.delete("/api/resource/999");
-            expect(mockMatchRoute).toHaveBeenCalledWith("DELETE", "/api/resource/999");
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {
-                    id: "999",
-                },
-                deps: expect.any(Object),
-            });
-        });
-    });
-    describe("Header handling", () => {
-        it("should pass headers to plain fetch but NOT to handler request object (by default)", async () => {
-            const client = createClient();
-            const mockHandler = vi.fn().mockResolvedValue({});
-            mockMatchRoute.mockReturnValue({
-                handler: mockHandler,
-                params: {},
-            });
-            await client.get("/api/test", {
-                headers: { "X-Custom": "Value" },
-            });
-            // The handler request object only includes params/body, not headers
-            // based on client.ts implementation:
-            // const handlerRequest = { ...data, ...options.searchParams, ...routeMatch.params };
-            expect(mockHandler).toHaveBeenCalledWith({
-                request: {},
-                deps: expect.any(Object),
-            });
-        });
-    });
-});

package/dist/api/client.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=client.test.d.ts.map

package/dist/api/client.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.test.d.ts","sourceRoot":"","sources":["../../src/api/client.test.ts"],"names":[],"mappings":""}

package/dist/api/client.test.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createZapierApi } from "./client";
-import * as auth from "../auth";
-vi.mock("../auth");
-describe("ApiClient", () => {
-    const mockResolveAuthToken = vi.mocked(auth.resolveAuthToken);
-    beforeEach(() => {
-        vi.clearAllMocks();
-        // Prevent any actual HTTP calls
-        global.fetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: () => Promise.resolve({ data: "test" }),
-        });
-    });
-    describe("authentication token resolution", () => {
-        it("should pass authBaseUrl to resolveAuthToken when provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: undefined,
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                authClientId: undefined,
-            });
-        });
-        it("should pass undefined authBaseUrl when not provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                // authBaseUrl intentionally omitted
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: undefined,
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: undefined,
-                authClientId: undefined,
-            });
-        });
-        it("should pass authClientId to resolveAuthToken when provided", async () => {
-            mockResolveAuthToken.mockResolvedValue("test-token");
-            const client = createZapierApi({
-                baseUrl: "https://api.custom.zapier.dev",
-                authClientId: "custom-client-id",
-                debug: false,
-            });
-            // Make a request that would trigger token resolution
-            await client.get("/test", { authRequired: true });
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: undefined,
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: undefined,
-                authClientId: "custom-client-id",
-            });
-        });
-        it("should not call resolveAuthToken when token is provided directly", async () => {
-            mockResolveAuthToken.mockResolvedValue("direct-token");
-            const client = createZapierApi({
-                token: "direct-token",
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                debug: false,
-            });
-            // Make a request that would use the direct token
-            await client.get("/test", { authRequired: true });
-            // resolveAuthToken is still called, but it returns the direct token immediately
-            expect(mockResolveAuthToken).toHaveBeenCalledWith({
-                token: "direct-token",
-                getToken: undefined,
-                onEvent: undefined,
-                fetch: expect.any(Function),
-                baseUrl: "https://api.custom.zapier.dev",
-                authBaseUrl: "https://auth.custom.zapier.dev",
-                authClientId: undefined,
-            });
-        });
-    });
-});

package/dist/api/debug.d.ts

@@ -1,14 +0,0 @@
-/**
- * Debug Logging Utilities
- *
- * This module provides debug logging capabilities for API requests and responses,
- * including request timing and detailed logging of HTTP interactions.
- */
-import type { DebugLogger } from "./types";
-export declare function createDebugLogger(enabled: boolean): DebugLogger;
-export declare function censorHeaders(headers?: HeadersInit): Record<string, string> | undefined;
-export declare function createDebugFetch(options: {
-    originalFetch: typeof globalThis.fetch;
-    debugLog: DebugLogger;
-}): (input: RequestInfo | URL, options?: RequestInit) => Promise<Response>;
-//# sourceMappingURL=debug.d.ts.map

package/dist/api/debug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/api/debug.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAa3C,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,WAAW,CAwC/D;AAED,wBAAgB,aAAa,CAC3B,OAAO,CAAC,EAAE,WAAW,GACpB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAwCpC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IACxC,aAAa,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACvC,QAAQ,EAAE,WAAW,CAAC;CACvB,IAEe,OAAO,WAAW,GAAG,GAAG,EAAE,UAAU,WAAW,uBA0C9D"}

package/dist/api/debug.js

@@ -1,131 +0,0 @@
-/**
- * Debug Logging Utilities
- *
- * This module provides debug logging capabilities for API requests and responses,
- * including request timing and detailed logging of HTTP interactions.
- */
-// We don't want to import util since it might not work in a browser. So we'll lazily load it and cache the result so
-// we can use it synchronously after that. The types above are just to make our linter happy.
-let utilModule = null;
-let utilPromise = null;
-export function createDebugLogger(enabled) {
-    if (!enabled) {
-        return () => { }; // No-op function when debug is disabled
-    }
-    // Try to load util module on first use.
-    if (!utilPromise) {
-        utilPromise = import("util")
-            .then((util) => {
-            utilModule = util;
-            return util;
-        })
-            .catch(() => {
-            utilModule = null;
-            return null;
-        });
-    }
-    return (message, data) => {
-        if (data === undefined || data === "") {
-            console.log(`[Zapier SDK] ${message}`);
-            return;
-        }
-        // Use cached module if available for sync logging. Yes, this means if the util module isn't yet loaded, we'll fall
-        // back to a plain old console.log, which might mean we don't see proper formatting/nesting. But that's unlikely
-        // since this logging happens during async fetching. Alternatively, we could switch to async logging, but this
-        // seems fine since we have to have a fallback anyway.
-        if (utilModule) {
-            const formatted = utilModule.inspect(data, {
-                colors: true,
-                depth: null,
-                breakLength: 80,
-            });
-            console.log(`[Zapier SDK] ${message}`, formatted);
-        }
-        else {
-            // Fallback - browser will handle formatting automatically
-            console.log(`[Zapier SDK] ${message}`, data);
-        }
-    };
-}
-export function censorHeaders(headers) {
-    if (!headers)
-        return headers;
-    const headersObj = new Headers(headers);
-    const authKeys = ["authorization", "x-api-key"];
-    for (const [key, value] of headersObj.entries()) {
-        if (authKeys.some((authKey) => key.toLowerCase() === authKey)) {
-            // Find space after prefix (like "Bearer ")
-            const spaceIndex = value.indexOf(" ");
-            if (spaceIndex > 0 && spaceIndex < value.length - 1) {
-                const prefix = value.substring(0, spaceIndex + 1); // Include the space
-                const token = value.substring(spaceIndex + 1);
-                if (token.length > 12) {
-                    // Show first 4 and last 4 chars, truncate middle
-                    const start = token.substring(0, 4);
-                    const end = token.substring(token.length - 4);
-                    headersObj.set(key, `${prefix}${start}...${end}`);
-                }
-                else {
-                    // Short token, use first character + three dots
-                    const firstChar = token.charAt(0);
-                    headersObj.set(key, `${prefix}${firstChar}...`);
-                }
-            }
-            else {
-                // No prefix found, truncate the whole value
-                if (value.length > 12) {
-                    const start = value.substring(0, 4);
-                    const end = value.substring(value.length - 4);
-                    headersObj.set(key, `${start}...${end}`);
-                }
-                else {
-                    // Short token, use first character + three dots
-                    const firstChar = value.charAt(0);
-                    headersObj.set(key, `${firstChar}...`);
-                }
-            }
-        }
-    }
-    return Object.fromEntries(headersObj);
-}
-export function createDebugFetch(options) {
-    const { originalFetch, debugLog } = options;
-    return async (input, options) => {
-        const startTime = Date.now();
-        // Convert input to URL string for logging
-        const url = typeof input === "string" ? input : input.toString();
-        const method = options?.method || "GET";
-        debugLog(`→ ${method} ${url}`, {
-            headers: censorHeaders(options?.headers),
-            body: options?.body && typeof options.body === "string"
-                ? (() => {
-                    try {
-                        return JSON.parse(options.body);
-                    }
-                    catch {
-                        return options.body;
-                    }
-                })()
-                : options?.body,
-        });
-        try {
-            const response = await originalFetch(input, options);
-            const duration = Date.now() - startTime;
-            debugLog(`← ${response.status} ${response.statusText} (${duration}ms)`, {
-                url,
-                method,
-                status: response.status,
-            });
-            return response;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            debugLog(`✖ Request failed (${duration}ms)`, {
-                url,
-                method,
-                error: error instanceof Error ? error.message : error,
-            });
-            throw error;
-        }
-    };
-}

package/dist/api/debug.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=debug.test.d.ts.map

package/dist/api/debug.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"debug.test.d.ts","sourceRoot":"","sources":["../../src/api/debug.test.ts"],"names":[],"mappings":""}

package/dist/api/debug.test.js

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { censorHeaders } from "./debug";
-describe("censorHeaders", () => {
-    it("should return undefined for undefined headers", () => {
-        expect(censorHeaders(undefined)).toBeUndefined();
-    });
-    it("should return headers unchanged for non-auth headers", () => {
-        const headers = {
-            "Content-Type": "application/json",
-            "User-Agent": "test",
-        };
-        const result = censorHeaders(headers);
-        // Headers API normalizes header names to lowercase
-        expect(result["content-type"]).toBe("application/json");
-        expect(result["user-agent"]).toBe("test");
-    });
-    it("should censor authorization header with Bearer prefix - long token", () => {
-        const headers = { authorization: "Bearer abcdef1234567890xyz" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer abcd...0xyz");
-    });
-    it("should censor authorization header with Bearer prefix - short token", () => {
-        const headers = { authorization: "Bearer short123" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer s...");
-    });
-    it("should censor x-api-key header - long token", () => {
-        const headers = { "x-api-key": "sk-1234567890abcdefghij" };
-        const result = censorHeaders(headers);
-        expect(result["x-api-key"]).toBe("sk-1...ghij");
-    });
-    it("should censor x-api-key header - short token", () => {
-        const headers = { "x-api-key": "short" };
-        const result = censorHeaders(headers);
-        expect(result["x-api-key"]).toBe("s...");
-    });
-    it("should handle Headers object input", () => {
-        const headers = new Headers();
-        headers.set("authorization", "Bearer verylongtoken123456789");
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer very...6789");
-    });
-    it("should handle mixed case authorization headers", () => {
-        const headers = { Authorization: "Bearer mixedcasetoken123" };
-        const result = censorHeaders(headers);
-        expect(result.authorization).toBe("Bearer mixe...n123");
-    });
-    it("should preserve non-auth headers while censoring auth headers", () => {
-        const headers = {
-            "Content-Type": "application/json",
-            authorization: "Bearer shouldbecensored123456789",
-            "User-Agent": "test-agent",
-        };
-        const result = censorHeaders(headers);
-        expect(result["content-type"]).toBe("application/json");
-        expect(result["user-agent"]).toBe("test-agent");
-        expect(result.authorization).toBe("Bearer shou...6789");
-    });
-});

package/dist/api/index.d.ts

@@ -1,30 +0,0 @@
-/**
- * Zapier API Client Module
- *
- * This module provides a centralized API layer for all HTTP interactions
- * with Zapier's various APIs. It handles authentication, error handling,
- * polling, and provides consistent patterns across all services.
- */
-export type { ApiClient, ApiClientOptions, RequestOptions, PollOptions, DebugLogger, Action, Field, Choice, ActionExecutionResult, ActionField, ActionFieldChoice, NeedsRequest, NeedsResponse, Authentication, AuthenticationsResponse, Implementation, ImplementationsResponse, } from "./types";
-import type { ApiClient } from "./types";
-export { isJwt, getAuthorizationHeader } from "./auth";
-export { createDebugLogger, createDebugFetch } from "./debug";
-export { pollUntilComplete } from "./polling";
-export { createZapierApi } from "./client";
-export declare function generateRequestId(): string;
-/**
- * Utility function to get or create an API client for standalone functions
- *
- * @param config - Configuration that may include an existing API client
- * @returns ApiClient instance
- */
-export declare function getOrCreateApiClient(config: {
-    baseUrl?: string;
-    authBaseUrl?: string;
-    token?: string;
-    getToken?: () => Promise<string | undefined>;
-    api?: ApiClient;
-    debug?: boolean;
-    fetch?: typeof globalThis.fetch;
-}): ApiClient;
-//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,YAAY,EAEV,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,WAAW,EAEX,MAAM,EACN,KAAK,EACL,MAAM,EACN,qBAAqB,EACrB,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,aAAa,EACb,cAAc,EACd,uBAAuB,EACvB,cAAc,EACd,uBAAuB,GACxB,MAAM,SAAS,CAAC;AAGjB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAIzC,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE,MAAM,QAAQ,CAAC;AAGvD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAG9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAG9C,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAM3C,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAC7C,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC,GAAG,SAAS,CAwBZ"}

package/dist/api/index.js

@@ -1,43 +0,0 @@
-/**
- * Zapier API Client Module
- *
- * This module provides a centralized API layer for all HTTP interactions
- * with Zapier's various APIs. It handles authentication, error handling,
- * polling, and provides consistent patterns across all services.
- */
-import { ZAPIER_BASE_URL } from "../constants";
-// Re-export authentication utilities
-export { isJwt, getAuthorizationHeader } from "./auth";
-// Re-export debug utilities
-export { createDebugLogger, createDebugFetch } from "./debug";
-// Re-export polling utilities
-export { pollUntilComplete } from "./polling";
-// Re-export the main client factory
-export { createZapierApi } from "./client";
-// Import for local use
-import { createZapierApi } from "./client";
-// Utility Functions
-export function generateRequestId() {
-    return Math.random().toString(36).substring(2) + Date.now().toString(36);
-}
-/**
- * Utility function to get or create an API client for standalone functions
- *
- * @param config - Configuration that may include an existing API client
- * @returns ApiClient instance
- */
-export function getOrCreateApiClient(config) {
-    const { baseUrl = ZAPIER_BASE_URL, authBaseUrl, token, getToken, api: providedApi, debug = false, fetch: customFetch, } = config;
-    // Use provided API client or create a new one
-    if (providedApi) {
-        return providedApi;
-    }
-    return createZapierApi({
-        baseUrl,
-        authBaseUrl,
-        token,
-        getToken,
-        debug,
-        fetch: customFetch,
-    });
-}

package/dist/api/polling.d.ts

@@ -1,46 +0,0 @@
-/**
- * Polling Utilities
- *
- * This module provides utilities for polling HTTP endpoints until completion,
- * with configurable retry logic and exponential backoff.
- */
-/**
- * Options for the polling function
- */
-export interface PollOptions<TResult = unknown> {
-    /** Function that performs the HTTP request */
-    fetchPoll: () => Promise<Response>;
-    /** Maximum time to wait for completion (in milliseconds) */
-    timeoutMs?: number;
-    /** HTTP status code indicating successful completion */
-    successStatus?: number;
-    /** HTTP status code indicating the operation is still pending */
-    pendingStatus?: number;
-    /** Function to extract the result from the response */
-    resultExtractor?: (response: unknown) => TResult;
-    /** Initial delay before the first poll attempt (in milliseconds) */
-    initialDelay?: number;
-}
-declare const enum PollStatus {
-    Success = "success",
-    Continue = "continue"
-}
-/**
- * Result of a poll operation
- */
-export type PollResult<TResult = unknown> = {
-    result?: TResult;
-    status: PollStatus;
-    errorCount: number;
-};
-/**
- * Polls an endpoint until completion, timeout, or error
- * @param options Configuration options for polling
- * @returns The extracted result from the successful response
- * @throws {ZapierValidationError} When the input parameters are invalid
- * @throws {ZapierTimeoutError} When the operation times out
- * @throws {ZapierApiError} When the API returns consecutive errors
- */
-export declare function pollUntilComplete<TResult = unknown>(options: PollOptions<TResult>): Promise<TResult>;
-export {};
-//# sourceMappingURL=polling.d.ts.map

package/dist/api/polling.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"polling.d.ts","sourceRoot":"","sources":["../../src/api/polling.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAgCH;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,OAAO,GAAG,OAAO;IAC5C,8CAA8C;IAC9C,SAAS,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnC,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iEAAiE;IACjE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAC;IACjD,oEAAoE;IACpE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,mBAAW,UAAU;IACnB,OAAO,YAAY;IACnB,QAAQ,aAAa;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,GAAG,OAAO,IAAI;IAC1C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAwDF;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,GAAG,OAAO,EACvD,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC,CAyGlB"}