@zapier/zapier-sdk 0.77.1 → 0.78.0

package/dist/plugins/eventEmission/utils.d.ts

@@ -1,56 +0,0 @@
-/**
- * Simple utility functions for event emission
- * These are pure functions that can be used to populate common event fields
- */
-/**
- * Generate a unique event ID
- */
-export declare function generateEventId(): string;
-/**
- * Get current timestamp in milliseconds since epoch
- */
-export declare function getCurrentTimestamp(): number;
-/**
- * Get release ID (git SHA) - in production this would come from build process
- */
-export declare function getReleaseId(): string;
-/**
- * Get operating system information
- */
-export declare function getOsInfo(): {
-    platform: string | null;
-    release: string | null;
-    architecture: string | null;
-};
-/**
- * Get platform versions (Node.js, npm, etc.)
- */
-export declare function getPlatformVersions(): Record<string, string | null>;
-/**
- * Check if running in CI environment
- */
-export declare function isCi(): boolean;
-/**
- * Get CI platform name if running in CI
- */
-export declare function getCiPlatform(): string | null;
-/**
- * Get memory usage in bytes
- */
-export declare function getMemoryUsage(): number | null;
-/**
- * Get CPU time in milliseconds
- */
-export declare function getCpuTime(): number | null;
-/**
- * Whether stdin and stdout are each attached to an interactive terminal (TTY).
- * Both fields resolve to null together when process is unavailable.
- *
- * Never throws — try/catch guards event emission from monkeypatched streams or
- * other exotic environments.
- */
-export declare function getTtyContext(): {
-    stdin_is_tty: boolean | null;
-    stdout_is_tty: boolean | null;
-};
-//# sourceMappingURL=utils.d.ts.map

package/dist/plugins/eventEmission/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/plugins/eventEmission/utils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAaA;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAQnE;AAED;;GAEG;AACH,wBAAgB,IAAI,IAAI,OAAO,CAa9B;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAgB7C;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAM9C;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAM1C;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI;IAC/B,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,aAAa,EAAE,OAAO,GAAG,IAAI,CAAC;CAC/B,CAWA"}

package/dist/plugins/eventEmission/utils.js

@@ -1,142 +0,0 @@
-/**
- * Simple utility functions for event emission
- * These are pure functions that can be used to populate common event fields
- */
-// Intentional dynamic require for browser compatibility. The os module is only
-// available in Node; in browser environments this gracefully falls back to nulls.
-let osModule = null;
-try {
-    osModule = require("os");
-}
-catch {
-    osModule = null;
-}
-/**
- * Generate a unique event ID
- */
-export function generateEventId() {
-    return crypto.randomUUID();
-}
-/**
- * Get current timestamp in milliseconds since epoch
- */
-export function getCurrentTimestamp() {
-    return Date.now();
-}
-/**
- * Get release ID (git SHA) - in production this would come from build process
- */
-export function getReleaseId() {
-    return globalThis.process?.env?.SDK_RELEASE_ID || "development";
-}
-/**
- * Get operating system information
- */
-export function getOsInfo() {
-    if (!osModule) {
-        return { platform: null, release: null, architecture: null };
-    }
-    try {
-        return {
-            platform: osModule.platform() || null,
-            release: osModule.release() || null,
-            architecture: osModule.arch() || null,
-        };
-    }
-    catch {
-        return { platform: null, release: null, architecture: null };
-    }
-}
-/**
- * Get platform versions (Node.js, npm, etc.)
- */
-export function getPlatformVersions() {
-    const versions = {};
-    if (typeof globalThis.process?.versions === "object") {
-        for (const [key, value] of Object.entries(globalThis.process.versions)) {
-            versions[key] = value || null;
-        }
-    }
-    return versions;
-}
-/**
- * Check if running in CI environment
- */
-export function isCi() {
-    return !!(globalThis.process?.env?.CI ||
-        globalThis.process?.env?.CONTINUOUS_INTEGRATION ||
-        globalThis.process?.env?.GITHUB_ACTIONS ||
-        globalThis.process?.env?.JENKINS_URL ||
-        globalThis.process?.env?.GITLAB_CI ||
-        globalThis.process?.env?.CIRCLECI ||
-        globalThis.process?.env?.TRAVIS ||
-        globalThis.process?.env?.BUILDKITE ||
-        globalThis.process?.env?.DRONE ||
-        globalThis.process?.env?.BITBUCKET_PIPELINES_UUID);
-}
-/**
- * Get CI platform name if running in CI
- */
-export function getCiPlatform() {
-    if (globalThis.process?.env?.GITHUB_ACTIONS)
-        return "github-actions";
-    if (globalThis.process?.env?.JENKINS_URL)
-        return "jenkins";
-    if (globalThis.process?.env?.GITLAB_CI)
-        return "gitlab-ci";
-    if (globalThis.process?.env?.CIRCLECI)
-        return "circleci";
-    if (globalThis.process?.env?.TRAVIS)
-        return "travis";
-    if (globalThis.process?.env?.BUILDKITE)
-        return "buildkite";
-    if (globalThis.process?.env?.DRONE)
-        return "drone";
-    if (globalThis.process?.env?.BITBUCKET_PIPELINES_UUID)
-        return "bitbucket-pipelines";
-    if (globalThis.process?.env?.CI ||
-        globalThis.process?.env?.CONTINUOUS_INTEGRATION)
-        return "unknown-ci";
-    return null;
-}
-/**
- * Get memory usage in bytes
- */
-export function getMemoryUsage() {
-    if (globalThis.process?.memoryUsage) {
-        const usage = globalThis.process.memoryUsage();
-        return usage.rss || null; // Resident Set Size
-    }
-    return null;
-}
-/**
- * Get CPU time in milliseconds
- */
-export function getCpuTime() {
-    if (globalThis.process?.cpuUsage) {
-        const usage = globalThis.process.cpuUsage();
-        return Math.round((usage.user + usage.system) / 1000); // Convert to milliseconds
-    }
-    return null;
-}
-/**
- * Whether stdin and stdout are each attached to an interactive terminal (TTY).
- * Both fields resolve to null together when process is unavailable.
- *
- * Never throws — try/catch guards event emission from monkeypatched streams or
- * other exotic environments.
- */
-export function getTtyContext() {
-    try {
-        const proc = globalThis.process;
-        if (!proc)
-            return { stdin_is_tty: null, stdout_is_tty: null };
-        return {
-            stdin_is_tty: proc.stdin?.isTTY === true,
-            stdout_is_tty: proc.stdout?.isTTY === true,
-        };
-    }
-    catch {
-        return { stdin_is_tty: null, stdout_is_tty: null };
-    }
-}

package/dist/plugins/fetch/index.d.ts

@@ -1,72 +0,0 @@
-import type { ApiClient } from "../../api";
-import type { ConnectionsPluginProvides } from "../connections";
-import { z } from "zod";
-import type { AdaptError, MethodHooks } from "kitcore";
-export interface ZapierFetchInitOptions extends RequestInit {
-    /** @deprecated Use `connection` instead. */
-    connectionId?: string | number;
-    connection?: string | number;
-    /** @deprecated Use `connection` instead. */
-    authenticationId?: string | number;
-    callbackUrl?: string;
-    /** Maximum seconds to wait for a response, subject to a server-side limit. */
-    maxTime?: number;
-}
-/**
- * Fetch plugin, the primary way to make authenticated HTTP requests through Zapier's Relay service.
- * Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.
- */
-export declare const fetchPlugin: (sdk: {
-    context: {
-        api: ApiClient;
-        hooks: MethodHooks;
-        core?: {
-            adaptError?: AdaptError;
-        };
-    } & ConnectionsPluginProvides["context"];
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    fetch: (url: string | URL, init?: ZapierFetchInitOptions) => Promise<Response>;
-    context: {
-        meta: {
-            fetch: {
-                description: string;
-                packages: string[];
-                categories: {
-                    key: string;
-                    title: string;
-                }[];
-                returnType: string;
-                inputParameters: ({
-                    name: string;
-                    schema: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
-                } | {
-                    name: string;
-                    schema: z.ZodOptional<z.ZodObject<{
-                        method: z.ZodOptional<z.ZodEnum<{
-                            POST: "POST";
-                            GET: "GET";
-                            DELETE: "DELETE";
-                            PUT: "PUT";
-                            PATCH: "PATCH";
-                            HEAD: "HEAD";
-                            OPTIONS: "OPTIONS";
-                        }>>;
-                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                        body: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<FormData, FormData>, z.ZodCustom<URLSearchParams, URLSearchParams>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-                        connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-                        connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-                        authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-                        callbackUrl: z.ZodOptional<z.ZodString>;
-                        maxTime: z.ZodOptional<z.ZodNumber>;
-                    }, z.core.$strip>>;
-                })[];
-            };
-        };
-    };
-};
-export type FetchPluginProvides = ReturnType<typeof fetchPlugin>;
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/fetch/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAMhE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEvD,MAAM,WAAW,sBAAuB,SAAQ,WAAW;IACzD,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAgHD;;;GAGG;AACH,eAAO,MAAM,WAAW;aAEX;QACP,GAAG,EAAE,SAAS,CAAC;QACf,KAAK,EAAE,WAAW,CAAC;QACnB,IAAI,CAAC,EAAE;YAAE,UAAU,CAAC,EAAE,UAAU,CAAA;SAAE,CAAC;KACpC,GAAG,yBAAyB,CAAC,SAAS,CAAC;;;;;;iBAU/B,MAAM,GAAG,GAAG,SACV,sBAAsB,KAC5B,OAAO,CAAC,QAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiKzB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/plugins/fetch/index.js

@@ -1,238 +0,0 @@
-import { definePlugin } from "kitcore";
-import { ZapierRelayError, ZapierTimeoutError } from "../../types/errors";
-import { FetchUrlSchema, FetchInitSchema, FetchInitZapierFieldsSchema, } from "./schemas";
-import { z } from "zod";
-import { resolveConnectionId } from "../../utils/domain-utils";
-import { combineAbortSignals, createTimeoutAbortSignal, } from "../../utils/abort-utils";
-import { isPlainObject } from "../../utils/type-guard-utils";
-import { buildHttpRequestContext } from "@zapier/policy-context";
-// fetch() doesn't go through createPluginMethod (its signature is variadic,
-// not single-options), so it enters its own method scope and fires
-// onMethodStart / onMethodEnd hooks directly.
-import { getCurrentDepth, runInMethodScope } from "kitcore";
-import { createValidator } from "kitcore";
-/**
- * Transforms full URLs into Relay format: /relay/{domain}/{path}
- */
-function transformUrlToRelayPath(url) {
-    const targetUrl = new URL(url);
-    return `/relay/${targetUrl.host}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
-}
-/**
- * Normalizes various header formats into a plain Record<string, string>.
- */
-function normalizeHeaders(optionsHeaders) {
-    const headers = {};
-    if (!optionsHeaders) {
-        return headers;
-    }
-    const headerEntries = optionsHeaders instanceof Headers
-        ? Array.from(optionsHeaders.entries())
-        : Array.isArray(optionsHeaders)
-            ? optionsHeaders
-            : Object.entries(optionsHeaders);
-    for (const [key, value] of headerEntries) {
-        headers[key] = value;
-    }
-    return headers;
-}
-function inferContentType(body) {
-    if (body instanceof URLSearchParams) {
-        return "application/x-www-form-urlencoded; charset=utf-8";
-    }
-    if (typeof body === "string") {
-        const trimmed = body.trimStart();
-        if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
-            return undefined;
-        }
-        try {
-            JSON.parse(trimmed);
-            return "application/json; charset=utf-8";
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (isPlainObject(body) || Array.isArray(body)) {
-        return "application/json; charset=utf-8";
-    }
-    return undefined;
-}
-/**
- * If the request aborted because the client-side `maxTime` timer fired, rewrap the
- * underlying error as a `ZapierTimeoutError` so callers (and telemetry) can
- * distinguish it from a caller-triggered abort or an unrelated network
- * cancellation. The original error is preserved as `cause`.
- *
- * Caller-triggered aborts are left unwrapped so the caller's own abort
- * semantics (reason, name) propagate.
- */
-function rewrapIfMaxTimeTimeout({ error, abortSignal, maxTimeSeconds, }) {
-    if (maxTimeSeconds === undefined || !abortSignal?.aborted)
-        return error;
-    const reason = abortSignal.reason;
-    if (!reason || reason.name !== "TimeoutError")
-        return error;
-    return new ZapierTimeoutError(`fetch timed out after ${maxTimeSeconds}s (maxTime)`, { cause: error });
-}
-/**
- * Builds an AbortSignal (and a dispose callback) from the optional maxTime
- * timeout and an optional caller-provided signal. Callers must invoke
- * `dispose()` when the request completes to release timers and listeners.
- */
-function buildAbortHandle({ maxTimeSeconds, callerSignal, }) {
-    const handles = [];
-    if (callerSignal)
-        handles.push({ signal: callerSignal, dispose: () => { } });
-    if (maxTimeSeconds !== undefined) {
-        handles.push(createTimeoutAbortSignal({ timeoutMs: maxTimeSeconds * 1000 }));
-    }
-    return combineAbortSignals({ handles });
-}
-const FetchInitSdkValidationSchema = z
-    .looseObject(FetchInitZapierFieldsSchema.shape)
-    .optional();
-/**
- * Fetch plugin, the primary way to make authenticated HTTP requests through Zapier's Relay service.
- * Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.
- */
-export const fetchPlugin = definePlugin((sdk) => {
-    // Bind the validator to the head's `adaptError` so validation
-    // failures surface as `ZapierValidationError` rather than the
-    // neutral `CoreError` kitcore would otherwise fall back to.
-    const validateFetchInit = createValidator(FetchInitSdkValidationSchema, {
-        adaptError: sdk.context.core?.adaptError,
-    });
-    return {
-        fetch: async function fetch(url, init) {
-            return runInMethodScope(async () => {
-                const { api } = sdk.context;
-                const { onMethodStart, onMethodEnd } = sdk.context.hooks;
-                const startTime = Date.now();
-                const depth = getCurrentDepth();
-                const args = init === undefined ? [url] : [url, init];
-                onMethodStart?.({
-                    methodName: "fetch",
-                    args,
-                    isPaginated: false,
-                    depth,
-                });
-                try {
-                    if (init) {
-                        validateFetchInit(init);
-                    }
-                    const { connectionId, connection, authenticationId, callbackUrl, maxTime, ...fetchInit } = init || {};
-                    const resolvedConnectionId = await resolveConnectionId({
-                        connectionId,
-                        connection,
-                        authenticationId,
-                        resolveConnection: sdk.context.resolveConnection,
-                        label: "fetch",
-                    });
-                    const relayPath = transformUrlToRelayPath(url);
-                    const headers = normalizeHeaders(fetchInit.headers);
-                    const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
-                    if (fetchInit.body && !hasContentType) {
-                        const inferred = inferContentType(fetchInit.body);
-                        if (inferred) {
-                            headers["Content-Type"] = inferred;
-                        }
-                    }
-                    if (resolvedConnectionId) {
-                        headers["X-Relay-Authentication-Id"] =
-                            String(resolvedConnectionId);
-                    }
-                    if (callbackUrl) {
-                        headers["X-Relay-Callback-Url"] = callbackUrl;
-                    }
-                    if (maxTime !== undefined) {
-                        headers["X-Zapier-Sdk-Max-Time"] = String(maxTime);
-                    }
-                    const upstreamUrl = new URL(url).toString();
-                    const method = (fetchInit.method ?? "GET").toUpperCase();
-                    const abortHandle = buildAbortHandle({
-                        maxTimeSeconds: maxTime,
-                        callerSignal: fetchInit.signal,
-                    });
-                    try {
-                        const result = await api.fetch(relayPath, {
-                            method,
-                            body: fetchInit.body,
-                            headers,
-                            redirect: fetchInit.redirect,
-                            signal: abortHandle?.signal,
-                            authRequired: true,
-                            approvalContext: () => buildHttpRequestContext({
-                                method,
-                                url: upstreamUrl,
-                                headers,
-                                body: typeof fetchInit.body === "string"
-                                    ? fetchInit.body
-                                    : undefined,
-                                connection_id: resolvedConnectionId
-                                    ? String(resolvedConnectionId)
-                                    : undefined,
-                            }),
-                        });
-                        const relayError = result.headers.get("x-relay-error");
-                        if (relayError) {
-                            throw new ZapierRelayError(relayError, {
-                                statusCode: result.status,
-                            });
-                        }
-                        onMethodEnd?.({
-                            methodName: "fetch",
-                            args,
-                            isPaginated: false,
-                            depth,
-                            durationMs: Date.now() - startTime,
-                        });
-                        return result;
-                    }
-                    catch (error) {
-                        throw rewrapIfMaxTimeTimeout({
-                            error,
-                            abortSignal: abortHandle?.signal,
-                            maxTimeSeconds: maxTime,
-                        });
-                    }
-                    finally {
-                        abortHandle?.dispose();
-                    }
-                }
-                catch (error) {
-                    onMethodEnd?.({
-                        methodName: "fetch",
-                        args,
-                        isPaginated: false,
-                        depth,
-                        durationMs: Date.now() - startTime,
-                        error: error instanceof Error ? error : new Error(String(error)),
-                    });
-                    throw error;
-                }
-            });
-        },
-        context: {
-            meta: {
-                fetch: {
-                    description: "Make authenticated HTTP requests to any API through Zapier. " +
-                        "Pass a connectionId to automatically inject the user's stored credentials " +
-                        "(OAuth tokens, API keys, etc.) into the outgoing request. " +
-                        "Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.",
-                    packages: ["sdk", "cli", "mcp"],
-                    // Auto-derive would produce "Http"/"Https" from the key alone;
-                    // declare the title explicitly here so the registry renders
-                    // "HTTP Request". Other plugins in this category use the bare
-                    // string "http"; the object form wins regardless of order.
-                    categories: [{ key: "http", title: "HTTP Request" }],
-                    returnType: "Response",
-                    inputParameters: [
-                        { name: "url", schema: FetchUrlSchema },
-                        { name: "init", schema: FetchInitSchema },
-                    ],
-                },
-            },
-        },
-    };
-});

package/dist/plugins/fetch/schemas.d.ts

@@ -1,28 +0,0 @@
-import { z } from "zod";
-export declare const FetchUrlSchema: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
-export declare const FetchInitZapierFieldsSchema: z.ZodObject<{
-    connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    callbackUrl: z.ZodOptional<z.ZodString>;
-    maxTime: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const FetchInitSchema: z.ZodOptional<z.ZodObject<{
-    method: z.ZodOptional<z.ZodEnum<{
-        POST: "POST";
-        GET: "GET";
-        DELETE: "DELETE";
-        PUT: "PUT";
-        PATCH: "PATCH";
-        HEAD: "HEAD";
-        OPTIONS: "OPTIONS";
-    }>>;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    body: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<FormData, FormData>, z.ZodCustom<URLSearchParams, URLSearchParams>, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
-    connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    callbackUrl: z.ZodOptional<z.ZodString>;
-    maxTime: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>>;
-//# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/fetch/schemas.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,cAAc,2DAIxB,CAAC;AAEJ,eAAO,MAAM,2BAA2B;;;;;;iBAqBtC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;kBA6BxB,CAAC"}

package/dist/plugins/fetch/schemas.js

@@ -1,52 +0,0 @@
-import { z } from "zod";
-import { ConnectionIdPropertySchema, ConnectionPropertySchema, AuthenticationIdPropertySchema, } from "../../types/properties";
-// Schemas for fetch function parameters
-export const FetchUrlSchema = z
-    .union([z.string(), z.instanceof(URL)])
-    .describe("The full URL of the API endpoint to call (proxied through Zapier's Relay service)");
-export const FetchInitZapierFieldsSchema = z.object({
-    connectionId: ConnectionIdPropertySchema.optional().meta({
-        deprecated: true,
-    }),
-    connection: ConnectionPropertySchema.optional(),
-    /** @deprecated Use connection instead */
-    authenticationId: AuthenticationIdPropertySchema.optional().meta({
-        deprecated: true,
-    }),
-    callbackUrl: z
-        .string()
-        .optional()
-        .describe("URL to send async response to (makes request async)"),
-    maxTime: z
-        .number()
-        .int()
-        .positive()
-        .optional()
-        .describe("Maximum seconds to wait for a response. Honored on a best-effort basis; the server may silently enforce a lower ceiling."),
-});
-export const FetchInitSchema = z
-    .object({
-    method: z
-        .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-        .optional()
-        .describe("HTTP method for the request (defaults to GET)"),
-    headers: z
-        .record(z.string(), z.string())
-        .optional()
-        .describe("HTTP headers to include in the request"),
-    body: z
-        .union([
-        z.string(),
-        z.instanceof(FormData),
-        z.instanceof(URLSearchParams),
-        z.record(z.string(), z.unknown()),
-    ])
-        .optional()
-        .describe("Request body — plain objects and JSON strings are auto-detected and Content-Type is set accordingly"),
-})
-    .extend(FetchInitZapierFieldsSchema.shape)
-    .optional()
-    .describe("Request options including method, headers, body, and authentication")
-    .meta({
-    aliases: { connectionId: "connection", authenticationId: "connection" },
-});