@zapier/zapier-sdk-cli 0.43.0 → 0.43.3

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

@@ -1,17 +1,76 @@
-import type { Plugin, FetchPluginProvides } from "@zapier/zapier-sdk";
-import { CurlSchema, type CurlOptions } from "./schemas";
-export interface CurlPluginProvides {
+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: {
-                inputSchema: typeof CurlSchema;
+                description: string;
+                categories: string[];
+                inputSchema: import("zod").ZodObject<{
+                    url: import("zod").ZodString;
+                    request: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        POST: "POST";
+                        GET: "GET";
+                        PUT: "PUT";
+                        DELETE: "DELETE";
+                        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;
+                };
             };
         };
     };
-}
-type SdkWithFetch = FetchPluginProvides["fetch"] extends infer F ? {
-    fetch: F;
-} : never;
-export declare const curlPlugin: Plugin<SdkWithFetch, CurlPluginProvides>;
-export {};
+};
+export type CurlPluginProvides = ReturnType<typeof curlPlugin>;

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

@@ -1,9 +1,10 @@
+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 { CurlExitError, parseHeaderLine, basicAuthHeader, deriveRemoteFilename, formatWriteOut, appendQueryParams, readAllStdin, resolveDataArgText, resolveDataArgBinary, buildFormData, } from "./utils";
-export const curlPlugin = (sdk) => {
+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;
@@ -232,4 +233,4 @@ export const curlPlugin = (sdk) => {
             },
         },
     };
-};
+});

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

@@ -1,19 +1,24 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { FeedbackSchema, type FeedbackOptions } from "./schemas";
-export interface FeedbackPluginProvides {
-    feedback: (options: FeedbackOptions) => Promise<string>;
+export declare const feedbackPlugin: (sdk: {
     context: {
-        meta: {
-            feedback: {
-                inputSchema: typeof FeedbackSchema;
-            };
+        options?: {
+            debug?: boolean;
         };
     };
-}
-export declare const feedbackPlugin: Plugin<{
+} & {
+    context: import("@zapier/zapier-sdk").EventEmissionContext;
+} & {
     context: {
-        options?: {
-            debug?: boolean;
+        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
+    };
+}) => {
+    feedback: (options?: {
+        feedback: string;
+    } | undefined) => Promise<string>;
+} & {
+    context: {
+        meta: {
+            feedback: import("@zapier/zapier-sdk").PluginMeta;
         };
     };
-}, FeedbackPluginProvides>;
+};
+export type FeedbackPluginProvides = ReturnType<typeof feedbackPlugin>;

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

@@ -1,5 +1,5 @@
 import { FeedbackSchema } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
+import { createPluginMethod, definePlugin, } from "@zapier/zapier-sdk";
 import { getLoggedInUser } from "../../login";
 const feedbackResolver = {
     type: "static",
@@ -12,9 +12,9 @@ const RETRY_DELAY_MS = 1000;
 function getFeedbackWebhookUrl() {
     return (process.env.ZAPIER_FEEDBACK_WEBHOOK_URL || DEFAULT_FEEDBACK_WEBHOOK_URL);
 }
-// This is a feedback-specific retry wrapper. A generic fetchWithRetry util
-// would be the better long-term solution but should be a separate MR so it's
-// built with broader use cases in mind.
+// Feedback-specific retry wrapper. A generic fetchWithRetry util would be
+// the better long-term solution but should be a separate MR so it's built
+// with broader use cases in mind.
 async function postWithRetry({ body, attemptsLeft, }) {
     const response = await fetch(getFeedbackWebhookUrl(), {
         method: "POST",
@@ -27,34 +27,26 @@ async function postWithRetry({ body, attemptsLeft, }) {
     }
     return response;
 }
-export const feedbackPlugin = (sdk) => {
-    const debug = sdk.context.options?.debug;
-    const feedbackWithSdk = createFunction(async function feedback(options) {
+export const feedbackPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    name: "feedback",
+    categories: ["utility"],
+    inputSchema: FeedbackSchema,
+    resolvers: { feedback: feedbackResolver },
+    handler: async ({ sdk, options }) => {
         const user = await getLoggedInUser();
         const body = JSON.stringify({
             email: user.email,
             customuser_id: user.customUserId,
             feedback: options.feedback,
         });
-        const response = await postWithRetry({ body, attemptsLeft: MAX_RETRIES });
-        if (debug) {
+        const response = await postWithRetry({
+            body,
+            attemptsLeft: MAX_RETRIES,
+        });
+        if (sdk.context.options?.debug) {
             const text = await response.text();
             console.error("[debug] Webhook response:", text);
         }
         return "Thank you for your feedback!";
-    }, FeedbackSchema);
-    return {
-        feedback: feedbackWithSdk,
-        context: {
-            meta: {
-                feedback: {
-                    categories: ["utility"],
-                    inputSchema: FeedbackSchema,
-                    resolvers: {
-                        feedback: feedbackResolver,
-                    },
-                },
-            },
-        },
-    };
-};
+    },
+}));

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

@@ -1,13 +1,265 @@
-import type { Plugin, ListActionsPluginProvides, ListAppsPluginProvides, ListInputFieldsPluginProvides, ListConnectionsPluginProvides, ManifestPluginProvides } from "@zapier/zapier-sdk";
-import { GenerateAppTypesSchema, type GenerateAppTypesOptions, type GenerateAppTypesResult } from "./schemas";
-export interface GenerateAppTypesPluginProvides {
-    generateAppTypes: (options: GenerateAppTypesOptions) => Promise<GenerateAppTypesResult>;
+import { type GenerateAppTypesOptions, type GenerateAppTypesResult } from "./schemas";
+export declare const generateAppTypesPlugin: (sdk: {
+    listApps: (options?: ({
+        search?: string | undefined;
+        apps?: string[] | undefined;
+        appKeys?: string[] | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("@zapier/zapier-sdk").PaginatedSdkResult<{
+        slug: string;
+        title: string;
+        key: string;
+        implementation_id: string;
+        description?: string | undefined;
+        is_hidden?: boolean | undefined;
+        auth_type?: string | undefined;
+        actions?: {
+            read?: number | undefined;
+            read_bulk?: number | undefined;
+            write?: number | undefined;
+            search?: number | undefined;
+            search_or_write?: number | undefined;
+            search_and_write?: number | undefined;
+            filter?: number | undefined;
+        } | undefined;
+        is_deprecated?: boolean | undefined;
+        is_beta?: boolean | undefined;
+        is_premium?: boolean | undefined;
+        age_in_days?: number | undefined;
+        banner?: string | undefined;
+        categories?: {
+            id: number;
+            name: string;
+            slug: string;
+        }[] | undefined;
+        images?: {
+            url_16x16?: string | undefined;
+            url_32x32?: string | undefined;
+            url_64x64?: string | undefined;
+            url_128x128?: string | undefined;
+        } | undefined;
+        popularity?: number | undefined;
+        has_filters?: boolean | undefined;
+        has_reads?: boolean | undefined;
+        has_searches?: boolean | undefined;
+        has_searches_or_writes?: boolean | undefined;
+        has_upfront_fields?: boolean | undefined;
+        has_writes?: boolean | undefined;
+        is_built_in?: boolean | undefined;
+        is_featured?: boolean | undefined;
+        is_invite?: boolean | undefined;
+        is_public?: boolean | undefined;
+        is_upcoming?: boolean | undefined;
+        visibility?: string | undefined;
+        primary_color?: string | undefined;
+        secondary_color?: string | undefined;
+        classification?: string | undefined;
+        api_docs_url?: string | undefined;
+        image?: string | undefined;
+        version?: string | undefined;
+    }>;
+} & {
     context: {
         meta: {
-            generateAppTypes: {
-                inputSchema: typeof GenerateAppTypesSchema;
-            };
+            listApps: import("@zapier/zapier-sdk").PluginMeta;
         };
     };
-}
-export declare const generateAppTypesPlugin: Plugin<ListAppsPluginProvides & ListActionsPluginProvides & ListInputFieldsPluginProvides & ListConnectionsPluginProvides & ManifestPluginProvides, GenerateAppTypesPluginProvides>;
+} & {
+    listActions: (options?: (({
+        app: string;
+        actionType?: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write" | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType?: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write" | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("@zapier/zapier-sdk").PaginatedSdkResult<{
+        description: string;
+        key: string;
+        app_key: string;
+        action_type: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        title: string;
+        type: "action";
+        id?: string | undefined;
+        is_important?: boolean | undefined;
+        is_hidden?: boolean | undefined;
+        app_version?: string | undefined;
+    }>;
+} & {
+    context: {
+        meta: {
+            listActions: import("@zapier/zapier-sdk").PluginMeta;
+        };
+    };
+} & {
+    listInputFields: (options?: (({
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("@zapier/zapier-sdk").PaginatedSdkResult<{
+        key: string;
+        type: "input_field";
+        default_value: string;
+        depends_on: string[];
+        description: string;
+        invalidates_input_fields: boolean;
+        is_required: boolean;
+        placeholder: string;
+        title: string;
+        value_type: string;
+        format?: string | undefined;
+        items?: {
+            type: string;
+        } | undefined;
+    } | {
+        key: string;
+        type: "info_field";
+        description: string;
+        title?: string | undefined;
+    } | import("@zapier/zapier-sdk").FieldsetItem>;
+} & {
+    context: {
+        meta: {
+            listInputFields: import("@zapier/zapier-sdk").PluginMeta;
+        };
+    };
+} & {
+    listConnections: (options?: ({
+        title?: string | undefined;
+        search?: string | undefined;
+        owner?: string | undefined;
+        app?: string | undefined;
+        appKey?: string | undefined;
+        connections?: string[] | undefined;
+        connectionIds?: string[] | undefined;
+        authenticationIds?: string[] | undefined;
+        account?: string | undefined;
+        accountId?: string | undefined;
+        includeShared?: boolean | undefined;
+        isExpired?: boolean | undefined;
+        expired?: boolean | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("@zapier/zapier-sdk").PaginatedSdkResult<{
+        date: string;
+        is_invite_only: boolean;
+        is_private: boolean;
+        shared_with_all: boolean;
+        id: string;
+        account_id: string;
+        title?: string | null | undefined;
+        lastchanged?: string | undefined;
+        destination_selected_api?: string | null | undefined;
+        is_stale?: string | undefined;
+        is_shared?: string | undefined;
+        marked_stale_at?: string | null | undefined;
+        label?: string | null | undefined;
+        identifier?: string | null | undefined;
+        url?: string | undefined;
+        groups?: Record<string, unknown>[] | undefined;
+        members?: string | undefined;
+        permissions?: Record<string, boolean> | undefined;
+        public_id?: string | undefined;
+        account_public_id?: string | undefined;
+        customuser_public_id?: string | undefined;
+        implementation_id?: string | undefined;
+        profile_id?: string | undefined;
+        is_expired?: string | undefined;
+        expired_at?: string | null | undefined;
+        app_key?: string | undefined;
+        app_version?: string | undefined;
+    }>;
+} & {
+    context: {
+        meta: {
+            listConnections: import("@zapier/zapier-sdk").PluginMeta;
+        };
+    };
+} & {
+    context: {
+        getResolvedManifest: () => Promise<import("@zapier/zapier-sdk").Manifest | null>;
+        getVersionedImplementationId: (appKey: string) => Promise<string | null>;
+        resolveAppKeys: ({ appKeys }: {
+            appKeys: string[];
+        }) => Promise<import("@zapier/zapier-sdk").ResolvedAppLocator[]>;
+        updateManifestEntry: (options: import("@zapier/zapier-sdk").UpdateManifestEntryOptions) => Promise<import("@zapier/zapier-sdk").UpdateManifestEntryResult>;
+        addActionEntry: (options: import("@zapier/zapier-sdk").AddActionEntryOptions) => Promise<import("@zapier/zapier-sdk").AddActionEntryResult>;
+        findActionEntry: ({ name, manifest, }: {
+            name: string;
+            manifest: import("@zapier/zapier-sdk").Manifest;
+        }) => import("@zapier/zapier-sdk").ActionEntry | null;
+        listActionEntries: ({ configPath, }?: {
+            configPath?: string;
+        }) => Promise<Array<[string, import("@zapier/zapier-sdk").ActionEntry]>>;
+        deleteActionEntry: ({ name, configPath, skipWrite, }: {
+            name: string;
+            configPath?: string;
+            skipWrite?: boolean;
+        }) => Promise<import("@zapier/zapier-sdk").Manifest>;
+        hasActionEntry: ({ name, manifest, }: {
+            name: string;
+            manifest: import("@zapier/zapier-sdk").Manifest;
+        }) => boolean;
+        findManifestEntry: typeof import("@zapier/zapier-sdk").findManifestEntry;
+        readManifestFromFile: typeof import("@zapier/zapier-sdk").readManifestFromFile;
+        getManifestConnections: () => Promise<Record<string, {
+            connectionId: string | number;
+        }> | null>;
+    };
+} & {
+    context: import("@zapier/zapier-sdk").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
+    };
+}) => {
+    generateAppTypes: (options?: GenerateAppTypesOptions | undefined) => Promise<GenerateAppTypesResult>;
+} & {
+    context: {
+        meta: {
+            generateAppTypes: import("@zapier/zapier-sdk").PluginMeta;
+        };
+    };
+};
+export type GenerateAppTypesPluginProvides = ReturnType<typeof generateAppTypesPlugin>;

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

@@ -1,18 +1,21 @@
-import { createFunction, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
+import { createPluginMethod, definePlugin, ZapierValidationError, ZapierUnknownError, } from "@zapier/zapier-sdk";
 import { GenerateAppTypesSchema, } from "./schemas";
 import { AstTypeGenerator } from "../../generators/ast-generator";
 import { getManifestKey } from "../../utils/manifest-helpers";
 import { mkdir, writeFile } from "fs/promises";
 import { join, resolve } from "path";
 import { detectTypesOutputDirectory } from "../../utils/directory-detection";
-export const generateAppTypesPlugin = (sdk) => {
-    const generateAppTypes = createFunction(async function generateAppTypes(options) {
+export const generateAppTypesPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    name: "generateAppTypes",
+    categories: ["utility"],
+    // Cast: schema validates JSON fields only; GenerateAppTypesOptions adds
+    // the runtime-only `onProgress` callback (passthrough via createFunction).
+    inputSchema: GenerateAppTypesSchema,
+    handler: async ({ sdk, options }) => {
         const { apps: appKeys, connections: connectionIds, skipWrite = false, typesOutputDirectory = await detectTypesOutputDirectory(), onProgress, } = options;
         const resolvedTypesOutput = resolve(typesOutputDirectory);
-        const result = {
-            typeDefinitions: {},
-        };
-        // Get apps using listApps (which respects existing manifest for version locking)
+        const result = { typeDefinitions: {} };
+        // Get apps via listApps (respects existing manifest for version locking).
         onProgress?.({ type: "apps_lookup_start", count: appKeys.length });
         const appsIterable = sdk.listApps({ apps: appKeys }).items();
         const apps = [];
@@ -24,7 +27,6 @@ export const generateAppTypesPlugin = (sdk) => {
         if (apps.length === 0) {
             return result;
         }
-        // Fetch connections if provided
         const connections = [];
         if (connectionIds && connectionIds.length > 0) {
             onProgress?.({
@@ -42,15 +44,12 @@ export const generateAppTypesPlugin = (sdk) => {
                 count: connections.length,
             });
         }
-        // Ensure output directory exists if we're writing files
         if (!skipWrite && resolvedTypesOutput) {
             await mkdir(resolvedTypesOutput, { recursive: true });
         }
-        // Initialize writtenFiles if we're writing to disk
         if (!skipWrite) {
             result.writtenFiles = {};
         }
-        // Process each app
         for (const app of apps) {
             onProgress?.({
                 type: "app_processing_start",
@@ -72,12 +71,9 @@ export const generateAppTypesPlugin = (sdk) => {
                         },
                     });
                 }
-                // Find matching connection for this app if connections were provided
                 let connectionId;
                 if (connections.length > 0) {
-                    const matchingConnection = connections.find((conn) => {
-                        return conn.app_key === app.key;
-                    });
+                    const matchingConnection = connections.find((conn) => conn.app_key === app.key);
                     if (matchingConnection) {
                         connectionId = matchingConnection.id;
                         onProgress?.({
@@ -95,7 +91,6 @@ export const generateAppTypesPlugin = (sdk) => {
                     }
                 }
                 const manifestKey = getManifestKey(app);
-                // Generate type definitions
                 const generator = new AstTypeGenerator();
                 const typeDefinitionString = await generator.generateTypes({
                     app,
@@ -108,21 +103,13 @@ export const generateAppTypesPlugin = (sdk) => {
                     manifestKey,
                     sizeBytes: typeDefinitionString.length,
                 });
-                // Write to file if skipWrite is false
                 if (!skipWrite && resolvedTypesOutput && result.writtenFiles) {
                     const filePath = join(resolvedTypesOutput, `${manifestKey}.d.ts`);
                     await writeFile(filePath, typeDefinitionString, "utf8");
                     result.writtenFiles[manifestKey] = filePath;
-                    onProgress?.({
-                        type: "file_written",
-                        manifestKey,
-                        filePath,
-                    });
+                    onProgress?.({ type: "file_written", manifestKey, filePath });
                 }
-                onProgress?.({
-                    type: "app_processing_complete",
-                    app: app.key,
-                });
+                onProgress?.({ type: "app_processing_complete", app: app.key });
             }
             catch (error) {
                 const errorMessage = `Failed to process app ${app.key}: ${error instanceof Error ? error.message : String(error)}`;
@@ -132,26 +119,11 @@ export const generateAppTypesPlugin = (sdk) => {
                     error: errorMessage,
                 });
                 if (error instanceof ZapierValidationError) {
-                    throw error; // Preserve the specific error type
-                }
-                else {
-                    throw new ZapierUnknownError(errorMessage, {
-                        cause: error, // Works for both Error and non-Error
-                    });
+                    throw error;
                 }
+                throw new ZapierUnknownError(errorMessage, { cause: error });
             }
         }
         return result;
-    }, GenerateAppTypesSchema);
-    return {
-        generateAppTypes,
-        context: {
-            meta: {
-                generateAppTypes: {
-                    categories: ["utility"],
-                    inputSchema: GenerateAppTypesSchema,
-                },
-            },
-        },
-    };
-};
+    },
+}));

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

@@ -1,14 +1,16 @@
-import type { Plugin } from "@zapier/zapier-sdk";
-import { GetLoginConfigPathSchema, type GetLoginConfigPathOptions } from "./schemas";
-export interface GetLoginConfigPathPluginProvides {
-    getLoginConfigPath: (options?: GetLoginConfigPathOptions) => Promise<string>;
+export declare const getLoginConfigPathPlugin: (sdk: {
+    context: import("@zapier/zapier-sdk").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("@zapier/zapier-sdk").PluginMeta>;
+    };
+}) => {
+    getLoginConfigPath: (options?: Record<string, never> | undefined) => Promise<string>;
+} & {
     context: {
         meta: {
-            getLoginConfigPath: {
-                inputSchema: typeof GetLoginConfigPathSchema;
-            };
+            getLoginConfigPath: import("@zapier/zapier-sdk").PluginMeta;
         };
     };
-}
-export declare const getLoginConfigPathPlugin: Plugin<{}, // requires no existing SDK methods
-GetLoginConfigPathPluginProvides>;
+};
+export type GetLoginConfigPathPluginProvides = ReturnType<typeof getLoginConfigPathPlugin>;

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

@@ -1,19 +1,9 @@
-import { GetLoginConfigPathSchema, } from "./schemas";
-import { createFunction } from "@zapier/zapier-sdk";
+import { GetLoginConfigPathSchema } from "./schemas";
+import { createPluginMethod, definePlugin, } from "@zapier/zapier-sdk";
 import { getConfigPath } from "../../login";
-export const getLoginConfigPathPlugin = () => {
-    const getLoginConfigPathWithSdk = createFunction(async function getLoginConfigPathWithSdk(_options) {
-        return getConfigPath();
-    }, GetLoginConfigPathSchema);
-    return {
-        getLoginConfigPath: getLoginConfigPathWithSdk,
-        context: {
-            meta: {
-                getLoginConfigPath: {
-                    categories: ["utility"],
-                    inputSchema: GetLoginConfigPathSchema,
-                },
-            },
-        },
-    };
-};
+export const getLoginConfigPathPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    name: "getLoginConfigPath",
+    categories: ["utility"],
+    inputSchema: GetLoginConfigPathSchema,
+    handler: async () => getConfigPath(),
+}));