@zapier/zapier-sdk-cli 0.59.0 → 0.59.2

package/dist/src/plugins/bundleCode/index.d.ts

@@ -1,23 +0,0 @@
-export declare const bundleCodePlugin: (sdk: {
-    context: import("@zapier/zapier-sdk").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
-    };
-}) => {
-    bundleCode: (options?: {
-        input: string;
-        output?: string | undefined;
-        string?: boolean | undefined;
-        minify?: boolean | undefined;
-        target?: string | undefined;
-        cjs?: boolean | undefined;
-    } | undefined) => Promise<string>;
-} & {
-    context: {
-        meta: {
-            bundleCode: import("@zapier/zapier-sdk").PluginMeta<unknown>;
-        };
-    };
-};
-export type BundleCodePluginProvides = ReturnType<typeof bundleCodePlugin>;

package/dist/src/plugins/bundleCode/index.js

@@ -1,62 +0,0 @@
-import { BundleCodeSchema } from "./schemas";
-import { createPluginMethod, definePlugin, ZapierBundleError, } from "@zapier/zapier-sdk";
-import { buildSync } from "esbuild";
-import * as fs from "fs";
-import * as path from "path";
-export const bundleCodePlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "bundleCode",
-    categories: ["utility"],
-    deprecation: { message: "bundleCode is no longer maintained." },
-    inputSchema: BundleCodeSchema,
-    handler: async ({ options }) => bundleCode(options),
-}));
-/**
- * Bundle TypeScript code into executable JavaScript (CLI version)
- */
-async function bundleCode(options) {
-    const { input, output, target = "es2020", cjs = false, minify = false, string: returnString = false, } = options;
-    // Resolve input path
-    const resolvedInput = path.resolve(process.cwd(), input);
-    try {
-        // Bundle with esbuild
-        const result = buildSync({
-            entryPoints: [resolvedInput],
-            bundle: true,
-            platform: "node",
-            target: target,
-            format: cjs ? "cjs" : "esm",
-            minify: minify,
-            write: false,
-            external: [], // Bundle everything
-            banner: {
-                js: "#!/usr/bin/env node",
-            },
-        });
-        if (result.errors.length > 0) {
-            const errorMessages = result.errors.map((e) => e.text);
-            throw new ZapierBundleError(`Bundle failed: ${errorMessages.join(", ")}`, { buildErrors: errorMessages });
-        }
-        const bundledCode = result.outputFiles?.[0]?.text;
-        if (!bundledCode) {
-            throw new ZapierBundleError("No output generated");
-        }
-        let finalOutput = bundledCode;
-        if (returnString) {
-            // Output as quoted string for node -e using JSON.stringify
-            finalOutput = JSON.stringify(bundledCode);
-        }
-        // Write to file if output path specified
-        if (output) {
-            fs.mkdirSync(path.dirname(output), { recursive: true });
-            fs.writeFileSync(output, finalOutput, "utf8");
-        }
-        return finalOutput;
-    }
-    catch (error) {
-        // If it's already a ZapierBundleError, re-throw as-is
-        if (error instanceof ZapierBundleError) {
-            throw error;
-        }
-        throw new ZapierBundleError(`Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`, { cause: error instanceof Error ? error : undefined });
-    }
-}

package/dist/src/plugins/bundleCode/schemas.d.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-export declare const BundleCodeSchema: z.ZodObject<{
-    input: z.ZodString;
-    output: z.ZodOptional<z.ZodString>;
-    string: z.ZodOptional<z.ZodBoolean>;
-    minify: z.ZodOptional<z.ZodBoolean>;
-    target: z.ZodOptional<z.ZodString>;
-    cjs: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;

package/dist/src/plugins/bundleCode/schemas.js

@@ -1,19 +0,0 @@
-import { z } from "zod";
-import { OutputPropertySchema } from "@zapier/zapier-sdk";
-// Bundle code schema - mirrors the original from SDK but for CLI use
-export const BundleCodeSchema = z
-    .object({
-    input: z.string().min(1).describe("Input TypeScript file path to bundle"),
-    output: OutputPropertySchema.optional().describe("Output file path (defaults to input with .js extension)"),
-    string: z
-        .boolean()
-        .optional()
-        .describe("Return bundled code as string instead of writing to file"),
-    minify: z.boolean().optional().describe("Minify the bundled output"),
-    target: z.string().optional().describe("ECMAScript target version"),
-    cjs: z
-        .boolean()
-        .optional()
-        .describe("Output CommonJS format instead of ESM"),
-})
-    .describe("Bundle TypeScript code into executable JavaScript");

package/dist/src/plugins/cliOverrides/index.d.ts

@@ -1,21 +0,0 @@
-import type { PluginMeta } from "@zapier/zapier-sdk";
-/**
- * CLI-specific metadata overrides. Tags `fetch` with a deprecation so the
- * CLI help hides it and a deprecation warning fires when it's invoked.
- */
-export declare const cliOverridesPlugin: (sdk: {
-    context: {
-        meta: {
-            fetch?: PluginMeta;
-        };
-    };
-} & {
-    context: {
-        meta: Record<string, PluginMeta>;
-    };
-}) => {
-    context: {
-        meta: Record<string, PluginMeta<unknown>>;
-    };
-};
-export type CliOverridesProvides = ReturnType<typeof cliOverridesPlugin>;

package/dist/src/plugins/cliOverrides/index.js

@@ -1,17 +0,0 @@
-import { definePlugin } from "@zapier/zapier-sdk";
-/**
- * CLI-specific metadata overrides. Tags `fetch` with a deprecation so the
- * CLI help hides it and a deprecation warning fires when it's invoked.
- */
-export const cliOverridesPlugin = definePlugin((sdk) => {
-    const meta = {};
-    if (sdk.context.meta.fetch) {
-        meta.fetch = {
-            ...sdk.context.meta.fetch,
-            deprecation: {
-                message: "This command is deprecated and will be removed soon. Use `curl` instead. Learn more: https://docs.zapier.com/sdk/cli-reference#curl",
-            },
-        };
-    }
-    return { context: { meta } };
-});

package/dist/src/plugins/curl/index.d.ts

@@ -1,76 +0,0 @@
-import { type CurlOptions } from "./schemas";
-export declare const curlPlugin: (sdk: {
-    fetch: (url: string | URL, init?: import("@zapier/zapier-sdk").ZapierFetchInitOptions) => Promise<Response>;
-} & {
-    context: {
-        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
-    };
-}) => {
-    curl: (options: CurlOptions) => Promise<undefined>;
-    context: {
-        meta: {
-            curl: {
-                description: string;
-                categories: string[];
-                inputSchema: import("zod").ZodObject<{
-                    url: import("zod").ZodString;
-                    request: import("zod").ZodOptional<import("zod").ZodEnum<{
-                        GET: "GET";
-                        POST: "POST";
-                        DELETE: "DELETE";
-                        PUT: "PUT";
-                        PATCH: "PATCH";
-                        HEAD: "HEAD";
-                        OPTIONS: "OPTIONS";
-                    }>>;
-                    header: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    data: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    dataRaw: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    dataAscii: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    dataBinary: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    dataUrlencode: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    json: import("zod").ZodOptional<import("zod").ZodString>;
-                    form: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    formString: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-                    get: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    head: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    location: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    include: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    output: import("zod").ZodOptional<import("zod").ZodString>;
-                    remoteName: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    verbose: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    silent: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    showError: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    fail: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    failWithBody: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    writeOut: import("zod").ZodOptional<import("zod").ZodString>;
-                    maxTime: import("zod").ZodOptional<import("zod").ZodNumber>;
-                    user: import("zod").ZodOptional<import("zod").ZodString>;
-                    compressed: import("zod").ZodOptional<import("zod").ZodBoolean>;
-                    connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
-                    connectionId: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
-                }, import("zod/v4/core").$strip>;
-                aliases: {
-                    request: string;
-                    header: string;
-                    data: string;
-                    form: string;
-                    get: string;
-                    head: string;
-                    location: string;
-                    include: string;
-                    output: string;
-                    remoteName: string;
-                    verbose: string;
-                    silent: string;
-                    showError: string;
-                    writeOut: string;
-                    maxTime: string;
-                    user: string;
-                    fail: string;
-                };
-            };
-        };
-    };
-};
-export type CurlPluginProvides = ReturnType<typeof curlPlugin>;

package/dist/src/plugins/curl/index.js

@@ -1,236 +0,0 @@
-import { definePlugin } from "@zapier/zapier-sdk";
-import { createWriteStream } from "fs";
-import { promises as fs } from "fs";
-import { dirname } from "path";
-import { CurlSchema } from "./schemas";
-import { ZapierCurlExitError, parseHeaderLine, basicAuthHeader, deriveRemoteFilename, formatWriteOut, appendQueryParams, readAllStdin, resolveDataArgText, resolveDataArgBinary, buildFormData, } from "./utils";
-export const curlPlugin = definePlugin((sdk) => {
-    async function curl(options) {
-        const { url: rawUrl, request, header = [], data = [], dataRaw = [], dataAscii = [], dataBinary = [], dataUrlencode = [], json, form = [], formString = [], get: forceGet, head: forceHead, location, include, output, remoteName, verbose, silent, showError, fail, failWithBody, writeOut, maxTime, user, compressed, connection: connectionParam, connectionId, } = options;
-        const connection = connectionParam ?? connectionId;
-        const parsedUrl = new URL(rawUrl);
-        const headers = {};
-        for (const h of header) {
-            const parsed = parseHeaderLine(h);
-            if (parsed) {
-                headers[parsed.key] = parsed.value;
-            }
-        }
-        if (user) {
-            headers["Authorization"] = basicAuthHeader(user);
-        }
-        if (compressed) {
-            headers["Accept-Encoding"] = "gzip, deflate, br";
-        }
-        const rawTextDataArgs = [...data, ...dataRaw, ...dataAscii];
-        const rawBinaryDataArgs = [...dataBinary];
-        const rawUrlencodeArgs = [...dataUrlencode];
-        const hasForm = form.length > 0 || formString.length > 0;
-        const hasJson = json !== undefined;
-        const hasAnyData = hasJson ||
-            hasForm ||
-            rawTextDataArgs.length > 0 ||
-            rawBinaryDataArgs.length > 0 ||
-            rawUrlencodeArgs.length > 0;
-        let method = "GET";
-        if (forceHead) {
-            method = "HEAD";
-        }
-        else if (request) {
-            method = request;
-        }
-        else if (forceGet) {
-            method = "GET";
-        }
-        else if (hasAnyData) {
-            method = "POST";
-        }
-        let body;
-        let effectiveUrl = parsedUrl;
-        if (hasJson) {
-            if (!headers["Content-Type"]) {
-                headers["Content-Type"] = "application/json";
-            }
-            if (!headers["Accept"]) {
-                headers["Accept"] = "application/json";
-            }
-            body = json;
-        }
-        else if (hasForm) {
-            body = await buildFormData(form, formString);
-        }
-        else {
-            const resolvedTextParts = [];
-            for (const raw of rawTextDataArgs) {
-                resolvedTextParts.push(await resolveDataArgText(raw));
-            }
-            const resolvedUrlEncodeParts = [];
-            for (const raw of rawUrlencodeArgs) {
-                // @file => read file, URL-encode contents
-                if (raw.startsWith("@")) {
-                    const content = await resolveDataArgText(raw);
-                    resolvedUrlEncodeParts.push(encodeURIComponent(content));
-                    continue;
-                }
-                const atIdx = raw.indexOf("@");
-                const eqIdx = raw.indexOf("=");
-                if (eqIdx !== -1) {
-                    // name=value => encode both
-                    const key = raw.slice(0, eqIdx);
-                    const value = raw.slice(eqIdx + 1);
-                    resolvedUrlEncodeParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-                }
-                else if (atIdx !== -1) {
-                    // name@file => read file, encode contents as value
-                    const key = raw.slice(0, atIdx);
-                    const filePath = raw.slice(atIdx + 1);
-                    const buf = filePath === "-"
-                        ? await readAllStdin()
-                        : await fs.readFile(filePath);
-                    resolvedUrlEncodeParts.push(`${encodeURIComponent(key)}=${encodeURIComponent(buf.toString("utf8"))}`);
-                }
-                else {
-                    resolvedUrlEncodeParts.push(encodeURIComponent(raw));
-                }
-            }
-            const resolvedBinaryParts = [];
-            for (const raw of rawBinaryDataArgs) {
-                resolvedBinaryParts.push(await resolveDataArgBinary(raw));
-            }
-            const allTextParts = [...resolvedTextParts, ...resolvedUrlEncodeParts];
-            if (forceGet && allTextParts.length > 0) {
-                effectiveUrl = appendQueryParams(parsedUrl, allTextParts);
-            }
-            else if (resolvedBinaryParts.length > 0) {
-                body = Buffer.concat(resolvedBinaryParts);
-            }
-            else if (allTextParts.length > 0) {
-                body = allTextParts.join("&");
-                if (!headers["Content-Type"]) {
-                    headers["Content-Type"] = "application/x-www-form-urlencoded";
-                }
-            }
-        }
-        // curl defaults to NOT following redirects
-        const redirect = location ? "follow" : "manual";
-        if (verbose && !silent) {
-            process.stderr.write(`> ${method} ${effectiveUrl.toString()}\n`);
-            for (const [k, v] of Object.entries(headers)) {
-                process.stderr.write(`> ${k}: ${v}\n`);
-            }
-            process.stderr.write(">\n");
-        }
-        const start = performance.now();
-        const response = await sdk.fetch(effectiveUrl.toString(), {
-            method,
-            headers,
-            body,
-            redirect,
-            connection,
-            maxTime,
-        });
-        const timeTotalSeconds = (performance.now() - start) / 1000;
-        if (verbose && !silent) {
-            process.stderr.write(`< HTTP ${response.status} ${response.statusText}\n`);
-            response.headers.forEach((value, key) => {
-                process.stderr.write(`< ${key}: ${value}\n`);
-            });
-            process.stderr.write("<\n");
-        }
-        const isHttpError = response.status >= 400;
-        const shouldFail = (fail || failWithBody) && isHttpError;
-        const shouldOutputBody = !shouldFail || !!failWithBody;
-        const headerText = include
-            ? `HTTP ${response.status} ${response.statusText}\n${Array.from(response.headers.entries())
-                .map(([k, v]) => `${k}: ${v}`)
-                .join("\n")}\n\n`
-            : "";
-        let bodyBytes = 0;
-        const buf = shouldOutputBody
-            ? Buffer.from(await response.arrayBuffer())
-            : Buffer.alloc(0);
-        bodyBytes = buf.length;
-        const outputFile = output && output !== "-"
-            ? output
-            : remoteName
-                ? deriveRemoteFilename(parsedUrl)
-                : undefined;
-        if (outputFile) {
-            const dir = dirname(outputFile);
-            if (dir !== ".") {
-                await fs.mkdir(dir, { recursive: true });
-            }
-            const ws = createWriteStream(outputFile);
-            if (headerText) {
-                ws.write(headerText);
-            }
-            if (buf.length) {
-                ws.write(buf);
-            }
-            await new Promise((resolve, reject) => {
-                ws.end(() => resolve());
-                ws.on("error", reject);
-            });
-        }
-        else {
-            if (headerText) {
-                process.stdout.write(headerText);
-            }
-            if (buf.length) {
-                process.stdout.write(buf);
-            }
-        }
-        if (writeOut) {
-            const formatted = formatWriteOut({
-                template: writeOut,
-                urlEffective: response.url || effectiveUrl.toString(),
-                httpCode: response.status,
-                timeTotalSeconds,
-                sizeDownloadBytes: bodyBytes,
-                contentType: response.headers.get("content-type"),
-            });
-            process.stdout.write(formatted);
-        }
-        if (shouldFail) {
-            if (!silent || showError) {
-                process.stderr.write(`curl: (22) The requested URL returned error: ${response.status}\n`);
-            }
-            throw new ZapierCurlExitError("HTTP request failed", 22);
-        }
-        return undefined;
-    }
-    return {
-        curl,
-        context: {
-            meta: {
-                curl: {
-                    description: "Make authenticated HTTP requests to any API through Zapier. " +
-                        "Pass a connection ID to automatically inject the user's stored credentials " +
-                        "(OAuth tokens, API keys, etc.) into the outgoing request. " +
-                        "Use it in place of the native curl command with additional Zapier-specific options.",
-                    categories: ["http"],
-                    inputSchema: CurlSchema,
-                    aliases: {
-                        request: "X",
-                        header: "H",
-                        data: "d",
-                        form: "F",
-                        get: "G",
-                        head: "I",
-                        location: "L",
-                        include: "i",
-                        output: "o",
-                        remoteName: "O",
-                        verbose: "v",
-                        silent: "s",
-                        showError: "S",
-                        writeOut: "w",
-                        maxTime: "m",
-                        user: "u",
-                        fail: "f",
-                    },
-                },
-            },
-        },
-    };
-});

package/dist/src/plugins/curl/schemas.d.ts

@@ -1,40 +0,0 @@
-import { z } from "zod";
-export declare const CurlSchema: z.ZodObject<{
-    url: z.ZodString;
-    request: z.ZodOptional<z.ZodEnum<{
-        GET: "GET";
-        POST: "POST";
-        DELETE: "DELETE";
-        PUT: "PUT";
-        PATCH: "PATCH";
-        HEAD: "HEAD";
-        OPTIONS: "OPTIONS";
-    }>>;
-    header: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    data: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dataRaw: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dataAscii: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dataBinary: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    dataUrlencode: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    json: z.ZodOptional<z.ZodString>;
-    form: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    formString: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    get: z.ZodOptional<z.ZodBoolean>;
-    head: z.ZodOptional<z.ZodBoolean>;
-    location: z.ZodOptional<z.ZodBoolean>;
-    include: z.ZodOptional<z.ZodBoolean>;
-    output: z.ZodOptional<z.ZodString>;
-    remoteName: z.ZodOptional<z.ZodBoolean>;
-    verbose: z.ZodOptional<z.ZodBoolean>;
-    silent: z.ZodOptional<z.ZodBoolean>;
-    showError: z.ZodOptional<z.ZodBoolean>;
-    fail: z.ZodOptional<z.ZodBoolean>;
-    failWithBody: z.ZodOptional<z.ZodBoolean>;
-    writeOut: z.ZodOptional<z.ZodString>;
-    maxTime: z.ZodOptional<z.ZodNumber>;
-    user: z.ZodOptional<z.ZodString>;
-    compressed: z.ZodOptional<z.ZodBoolean>;
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-}, z.core.$strip>;
-export type CurlOptions = z.infer<typeof CurlSchema>;

package/dist/src/plugins/curl/schemas.js

@@ -1,108 +0,0 @@
-import { z } from "zod";
-export const CurlSchema = z
-    .object({
-    url: z.string().describe("Request URL"),
-    request: z
-        .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-        .optional()
-        .describe("HTTP method (defaults to GET, or POST if data is provided)"),
-    header: z
-        .array(z.string())
-        .optional()
-        .describe("HTTP headers in 'Key: Value' format (repeatable)"),
-    data: z
-        .array(z.string())
-        .optional()
-        .describe("HTTP POST data (repeatable, joined with &)"),
-    dataRaw: z
-        .array(z.string())
-        .optional()
-        .describe("HTTP POST data without special interpretation (repeatable)"),
-    dataAscii: z
-        .array(z.string())
-        .optional()
-        .describe("HTTP POST ASCII data (repeatable)"),
-    dataBinary: z
-        .array(z.string())
-        .optional()
-        .describe("HTTP POST binary data (repeatable)"),
-    dataUrlencode: z
-        .array(z.string())
-        .optional()
-        .describe("HTTP POST data, URL-encoded (repeatable)"),
-    json: z
-        .string()
-        .optional()
-        .describe("Send JSON body (sets Content-Type and Accept headers)"),
-    form: z
-        .array(z.string())
-        .optional()
-        .describe("Multipart form data as 'name=value' (repeatable)"),
-    formString: z
-        .array(z.string())
-        .optional()
-        .describe("Multipart form string field (repeatable)"),
-    get: z
-        .boolean()
-        .optional()
-        .describe("Force GET method and append data to query string"),
-    head: z.boolean().optional().describe("Fetch headers only (HEAD request)"),
-    location: z.boolean().optional().describe("Follow redirects"),
-    include: z
-        .boolean()
-        .optional()
-        .describe("Include response headers in output"),
-    output: z
-        .string()
-        .optional()
-        .describe("Write output to file instead of stdout"),
-    remoteName: z
-        .boolean()
-        .optional()
-        .describe("Write output to file named like the remote file"),
-    verbose: z
-        .boolean()
-        .optional()
-        .describe("Verbose output (show request/response headers on stderr)"),
-    silent: z.boolean().optional().describe("Silent mode (suppress errors)"),
-    showError: z
-        .boolean()
-        .optional()
-        .describe("Show errors even when in silent mode"),
-    fail: z
-        .boolean()
-        .optional()
-        .describe("Fail silently on HTTP errors (exit code 22)"),
-    failWithBody: z
-        .boolean()
-        .optional()
-        .describe("Fail on HTTP errors but still output the body"),
-    writeOut: z
-        .string()
-        .optional()
-        .describe("Output format string after completion (e.g., '%{http_code}')"),
-    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."),
-    user: z
-        .string()
-        .optional()
-        .describe("Basic auth credentials as 'user:password'"),
-    compressed: z
-        .boolean()
-        .optional()
-        .describe("Request compressed response (sends Accept-Encoding header)"),
-    connection: z
-        .union([z.string(), z.number()])
-        .optional()
-        .describe("Zapier connection ID or alias for authentication"),
-    /** @deprecated Use `connection` instead. */
-    connectionId: z
-        .union([z.string(), z.number()])
-        .optional()
-        .meta({ deprecated: true }),
-})
-    .describe("Make HTTP requests through Zapier Relay with curl-like options");

package/dist/src/plugins/curl/utils.d.ts

@@ -1,34 +0,0 @@
-import { ZapierError } from "@zapier/zapier-sdk";
-/**
- * Thrown when a curl-style invocation fails — captures the exit code so
- * the CLI can surface it (mirrors curl's own non-zero exit codes for
- * different failure modes).
- */
-export declare class ZapierCurlExitError extends ZapierError {
-    readonly name = "ZapierCurlExitError";
-    readonly code: "ZAPIER_CURL_EXIT_ERROR";
-    exitCode: number;
-    constructor(message: string, exitCode: number);
-}
-/** @deprecated Use {@link ZapierCurlExitError} instead. */
-export declare const CurlExitError: typeof ZapierCurlExitError;
-export declare function parseHeaderLine(input: string): {
-    key: string;
-    value: string;
-} | null;
-export declare function basicAuthHeader(userpass: string): string;
-export declare function deriveRemoteFilename(url: URL): string;
-export declare function decodeWriteOutEscapes(input: string): string;
-export declare function formatWriteOut(params: {
-    template: string;
-    urlEffective: string;
-    httpCode: number;
-    timeTotalSeconds: number;
-    sizeDownloadBytes: number;
-    contentType?: string | null;
-}): string;
-export declare function appendQueryParams(url: URL, dataParts: string[]): URL;
-export declare function readAllStdin(): Promise<Buffer>;
-export declare function resolveDataArgText(raw: string): Promise<string>;
-export declare function resolveDataArgBinary(raw: string): Promise<Buffer>;
-export declare function buildFormData(formArgs: string[], formStringArgs: string[]): Promise<FormData>;