@zapier/zapier-sdk 0.0.2 → 0.1.0

package/dist/functions/listFields/info.d.ts

@@ -0,0 +1,24 @@
+import { listFields } from "./index";
+export declare const listFieldsInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodString;
+        actionType: import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+        actionKey: import("zod").ZodString;
+        authenticationId: import("zod").ZodOptional<import("zod").ZodNumber>;
+        params: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        params?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        params?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }>;
+    implementation: typeof listFields;
+};

package/dist/functions/listFields/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFieldsInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.listFieldsInfo = {
+    name: index_1.listFields.name,
+    inputSchema: schemas_1.ListFieldsSchema,
+    implementation: index_1.listFields,
+};

package/dist/functions/listFields/schemas.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { ActionField } from "../../types/domain";
+export declare const ListFieldsSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    params?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    params?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}>;
+export type ListFieldsOptions = z.infer<typeof ListFieldsSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface ListFieldsSdkFunction {
+    listFields: (options: ListFieldsOptions) => Promise<ActionField[]>;
+}

package/dist/functions/listFields/schemas.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFieldsSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Field_1 = require("../../schemas/Field");
+// Pure Zod schema - no resolver metadata!
+exports.ListFieldsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema,
+    actionType: properties_1.ActionTypePropertySchema,
+    actionKey: properties_1.ActionKeyPropertySchema,
+    authenticationId: properties_1.AuthenticationIdPropertySchema.optional(),
+    params: properties_1.ParamsPropertySchema.optional().describe("Additional parameters that may affect available fields"),
+})
+    .describe("Get the input fields required for a specific action"), Field_1.FieldItemSchema);

package/dist/functions/runAction/index.d.ts

@@ -0,0 +1,12 @@
+import type { ActionExecutionResult } from "../../types/domain";
+import type { RunActionOptions } from "./schemas";
+/**
+ * Execute an action
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Action execution parameters and API configuration options
+ * @returns Promise<ActionExecutionResult>
+ */
+export declare function runAction(options: RunActionOptions): Promise<ActionExecutionResult>;

package/dist/functions/runAction/index.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAction = runAction;
+const api_1 = require("../../api");
+const getAction_1 = require("../getAction");
+const getApp_1 = require("../getApp");
+/**
+ * Execute an action
+ *
+ * This function can be used standalone without instantiating a full SDK,
+ * which enables better tree-shaking in applications that only need this functionality.
+ *
+ * @param options - Action execution parameters and API configuration options
+ * @returns Promise<ActionExecutionResult>
+ */
+async function runAction(options) {
+    const { appKey, actionType, actionKey, inputs, authenticationId: providedAuthenticationId, token, } = options;
+    if (!token && !process.env.ZAPIER_TOKEN) {
+        throw new Error("Authentication token is required to run actions. Please provide token in options or set ZAPIER_TOKEN environment variable.");
+    }
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    // Validate that the action exists
+    const actionData = await (0, getAction_1.getAction)({
+        ...options,
+        appKey: appKey,
+        actionKey: actionKey,
+        actionType: actionType,
+    });
+    // Validate action type matches
+    if (actionData.type !== actionType) {
+        throw new Error(`Action type mismatch: expected ${actionType}, got ${actionData.type}`);
+    }
+    // Execute the action using the appropriate API based on action type
+    const startTime = Date.now();
+    const result = await executeActionWithStrategy({
+        api,
+        appSlug: appKey,
+        actionKey: actionKey,
+        actionType: actionData.type,
+        executionOptions: { inputs: inputs || {} },
+        auth: token
+            ? { token: token, authentication_id: providedAuthenticationId }
+            : undefined,
+        options,
+    });
+    const executionTime = Date.now() - startTime;
+    return {
+        success: true,
+        data: result,
+        metadata: {
+            executionTime,
+            requestId: (0, api_1.generateRequestId)(),
+        },
+    };
+}
+async function executeActionWithStrategy(strategyOptions) {
+    const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = strategyOptions;
+    // Actions API supports: read, read_bulk, write
+    // Invoke API supports: search, read, write, read_bulk, and more
+    const actionsApiTypes = ["read", "read_bulk", "write"];
+    const useActionsApi = actionsApiTypes.includes(actionType);
+    if (useActionsApi) {
+        return executeActionViaActionsApi({
+            api,
+            appSlug,
+            actionKey,
+            actionType,
+            executionOptions,
+            auth,
+            options,
+        });
+    }
+    else {
+        return executeActionViaInvokeApi({
+            api,
+            appSlug,
+            actionKey,
+            actionType,
+            executionOptions,
+            auth,
+            options,
+        });
+    }
+}
+async function executeActionViaActionsApi(apiOptions) {
+    const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = apiOptions;
+    // Use the standalone getApp function
+    const appData = await (0, getApp_1.getApp)({
+        appKey: appSlug,
+        api,
+        token: options.token,
+        baseUrl: options.baseUrl,
+        debug: options.debug,
+        fetch: options.fetch,
+    });
+    const selectedApi = appData.current_implementation_id;
+    if (!selectedApi) {
+        throw new Error("No current_implementation_id found for app");
+    }
+    if (!auth?.token) {
+        throw new Error("Authentication token is required. Please provide token when creating the SDK.");
+    }
+    // Step 1: POST to /actions/v1/runs to start execution
+    const runRequest = {
+        data: {
+            authentication_id: auth.authentication_id || 1,
+            selected_api: selectedApi,
+            action_key: actionKey,
+            action_type: actionType,
+            inputs: executionOptions.inputs || {},
+        },
+    };
+    const runData = await api.post("/api/actions/v1/runs", runRequest);
+    const runId = runData.data.id;
+    // Step 2: Poll GET /actions/v1/runs/{run_id} for results
+    return await api.poll(`/api/actions/v1/runs/${runId}`, {
+        successStatus: 200,
+        pendingStatus: 202,
+        resultExtractor: (result) => result.data,
+    });
+}
+async function executeActionViaInvokeApi(apiOptions) {
+    const { api, appSlug, actionKey, actionType, executionOptions, auth, options, } = apiOptions;
+    // Use the standalone getApp function
+    const appData = await (0, getApp_1.getApp)({
+        appKey: appSlug,
+        api,
+        token: options.token,
+        baseUrl: options.baseUrl,
+        debug: options.debug,
+        fetch: options.fetch,
+    });
+    const selectedApi = appData.current_implementation_id;
+    if (!selectedApi) {
+        throw new Error("No current_implementation_id found for app");
+    }
+    if (!auth?.token) {
+        throw new Error("Authentication token is required. Please provide token when creating the SDK.");
+    }
+    // Step 1: POST to /invoke/v1/invoke to start execution
+    const invokeRequest = {
+        selected_api: selectedApi,
+        action: actionKey,
+        type_of: actionType,
+        authentication_id: auth.authentication_id || 1,
+        params: executionOptions.inputs || {},
+    };
+    const invokeData = await api.post("/api/invoke/v1/invoke", invokeRequest);
+    const invocationId = invokeData.invocation_id;
+    // Step 2: Poll GET /invoke/v1/invoke/{invocation_id} for results
+    return await api.poll(`/api/invoke/v1/invoke/${invocationId}`, {
+        successStatus: 200,
+        pendingStatus: 202,
+        resultExtractor: (result) => result.results || result,
+    });
+}
+// No registry info here - moved to info.ts for proper tree-shaking

package/dist/functions/runAction/info.d.ts

@@ -0,0 +1,24 @@
+import { runAction } from "./index";
+export declare const runActionInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodString;
+        actionType: import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+        actionKey: import("zod").ZodString;
+        inputs: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+        authenticationId: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        inputs?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+        inputs?: Record<string, any> | undefined;
+        authenticationId?: number | undefined;
+    }>;
+    implementation: typeof runAction;
+};

package/dist/functions/runAction/info.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runActionInfo = void 0;
+const index_1 = require("./index");
+const schemas_1 = require("./schemas");
+// Function registry info - imports both function and schema
+exports.runActionInfo = {
+    name: index_1.runAction.name,
+    inputSchema: schemas_1.RunActionSchema,
+    implementation: index_1.runAction,
+};

package/dist/functions/runAction/schemas.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import type { ActionExecutionResult } from "../../types/domain";
+export declare const RunActionSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    actionKey: z.ZodString;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    inputs?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+    inputs?: Record<string, any> | undefined;
+    authenticationId?: number | undefined;
+}>;
+export type RunActionOptions = z.infer<typeof RunActionSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface RunActionSdkFunction {
+    runAction: (options: RunActionOptions) => Promise<ActionExecutionResult>;
+}

package/dist/functions/runAction/schemas.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunActionSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+// Pure Zod schema - no resolver metadata!
+exports.RunActionSchema = zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema,
+    actionType: properties_1.ActionTypePropertySchema,
+    actionKey: properties_1.ActionKeyPropertySchema,
+    inputs: properties_1.InputsPropertySchema.optional().describe("Input parameters for the action"),
+    authenticationId: properties_1.AuthenticationIdPropertySchema.optional(),
+})
+    .describe("Execute an action with the given inputs");

package/dist/index.d.ts

@@ -1,3 +1,15 @@
-export * from "./types";
-export * from "./actions-sdk";
-export { createZapierSdk, ZapierSdk, ZapierSdkOptions } from "./sdk";
+export * from "./types/domain";
+export * from "./types/properties";
+export * from "./plugins/apps";
+export * from "./resolvers";
+export { listAuths } from "./functions/listAuths";
+export { listApps } from "./functions/listApps";
+export { getApp } from "./functions/getApp";
+export { listActions } from "./functions/listActions";
+export { getAction } from "./functions/getAction";
+export { runAction } from "./functions/runAction";
+export { listFields } from "./functions/listFields";
+export { generateTypes } from "./functions/generateTypes";
+export { bundleCode } from "./functions/bundleCode";
+export { createZapierSdk, ZapierSdkOptions } from "./sdk";
+export type { ZapierSdk } from "./types/sdk";

package/dist/index.js

@@ -14,10 +14,33 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createZapierSdk = void 0;
-// Export everything from types and actions-sdk
-__exportStar(require("./types"), exports);
-__exportStar(require("./actions-sdk"), exports);
+exports.createZapierSdk = exports.bundleCode = exports.generateTypes = exports.listFields = exports.runAction = exports.getAction = exports.listActions = exports.getApp = exports.listApps = exports.listAuths = void 0;
+// Export everything from types and plugins
+__exportStar(require("./types/domain"), exports);
+__exportStar(require("./types/properties"), exports);
+__exportStar(require("./plugins/apps"), exports);
+// Export resolvers for CLI use
+__exportStar(require("./resolvers"), exports);
+// Note: SdkSchemas is now available via SDK.__registry
+// Export individual functions for tree-shaking
+var listAuths_1 = require("./functions/listAuths");
+Object.defineProperty(exports, "listAuths", { enumerable: true, get: function () { return listAuths_1.listAuths; } });
+var listApps_1 = require("./functions/listApps");
+Object.defineProperty(exports, "listApps", { enumerable: true, get: function () { return listApps_1.listApps; } });
+var getApp_1 = require("./functions/getApp");
+Object.defineProperty(exports, "getApp", { enumerable: true, get: function () { return getApp_1.getApp; } });
+var listActions_1 = require("./functions/listActions");
+Object.defineProperty(exports, "listActions", { enumerable: true, get: function () { return listActions_1.listActions; } });
+var getAction_1 = require("./functions/getAction");
+Object.defineProperty(exports, "getAction", { enumerable: true, get: function () { return getAction_1.getAction; } });
+var runAction_1 = require("./functions/runAction");
+Object.defineProperty(exports, "runAction", { enumerable: true, get: function () { return runAction_1.runAction; } });
+var listFields_1 = require("./functions/listFields");
+Object.defineProperty(exports, "listFields", { enumerable: true, get: function () { return listFields_1.listFields; } });
+var generateTypes_1 = require("./functions/generateTypes");
+Object.defineProperty(exports, "generateTypes", { enumerable: true, get: function () { return generateTypes_1.generateTypes; } });
+var bundleCode_1 = require("./functions/bundleCode");
+Object.defineProperty(exports, "bundleCode", { enumerable: true, get: function () { return bundleCode_1.bundleCode; } });
 // Export the main combined SDK
 var sdk_1 = require("./sdk");
 Object.defineProperty(exports, "createZapierSdk", { enumerable: true, get: function () { return sdk_1.createZapierSdk; } });

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

@@ -0,0 +1,8 @@
+import { type ApiClient } from "../../api";
+import type { ActionProxy } from "./types";
+export interface AppsPluginOptions {
+    api: ApiClient;
+    token?: string;
+}
+export declare function createAppsPlugin(options: AppsPluginOptions): ActionProxy;
+export type { ActionProxy, AppsPluginSdkExtension } from "./types";

package/dist/plugins/apps/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppsPlugin = createAppsPlugin;
+const runAction_1 = require("../../functions/runAction");
+function createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId) {
+    return async (actionOptions = {}) => {
+        const { api, token } = options;
+        const { inputs, authenticationId: providedAuthenticationId } = actionOptions;
+        // Use pinned auth ID first, then provided auth ID
+        const authenticationId = pinnedAuthId || providedAuthenticationId;
+        if (!authenticationId) {
+            throw new Error(`Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`);
+        }
+        // Call runAction with the resolved parameters
+        return (0, runAction_1.runAction)({
+            appKey,
+            actionType: actionType,
+            actionKey,
+            inputs,
+            authenticationId,
+            api: api,
+            token,
+        });
+    };
+}
+function createActionTypeProxy(appKey, actionType, options, pinnedAuthId) {
+    return new Proxy({}, {
+        get(_, actionKey) {
+            if (typeof actionKey === "string") {
+                return createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId);
+            }
+            return undefined;
+        },
+    });
+}
+function createPinnedAppProxy(appKey, options, pinnedAuthId) {
+    return new Proxy({}, {
+        get(_, actionType) {
+            if (typeof actionType === "string") {
+                return createActionTypeProxy(appKey, actionType, options, pinnedAuthId);
+            }
+            return undefined;
+        },
+    });
+}
+function createAppProxy(appKey, options) {
+    // Create the factory function that returns a pinned version
+    const appFactory = (factoryOptions) => {
+        return createPinnedAppProxy(appKey, options, factoryOptions.authenticationId);
+    };
+    // Add properties for direct usage (backward compatibility)
+    return new Proxy(appFactory, {
+        get(_, actionType) {
+            if (typeof actionType === "string") {
+                return createActionTypeProxy(appKey, actionType, options);
+            }
+            return undefined;
+        },
+    });
+}
+function createAppsProxy(options) {
+    // Create a proxy object that intercepts property access
+    const appsProxy = new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === "string") {
+                // First level: App names (e.g., 'slack')
+                return createAppProxy(prop, options);
+            }
+            return undefined;
+        },
+    });
+    return appsProxy;
+}
+// Export the plugin creation function
+function createAppsPlugin(options) {
+    return createAppsProxy(options);
+}

package/dist/plugins/apps/info.d.ts

@@ -0,0 +1,6 @@
+import type { AppsPluginOptions } from "./index";
+export declare const appsPluginInfo: {
+    plugin: (_sdk: any, options: AppsPluginOptions) => {
+        apps: import("./types").ActionProxy;
+    };
+};

package/dist/plugins/apps/info.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appsPluginInfo = void 0;
+const index_1 = require("./index");
+// Plugin info object for registry (keeping for compatibility)
+exports.appsPluginInfo = {
+    plugin: (_sdk, options) => {
+        const appsProxy = (0, index_1.createAppsPlugin)(options);
+        return {
+            apps: appsProxy,
+        };
+    },
+};

package/dist/plugins/apps/types.d.ts

@@ -0,0 +1,21 @@
+import type { ActionExecutionOptions, ActionExecutionResult } from "../../types/domain";
+interface AppFactoryOptions {
+    authenticationId: number;
+}
+interface ActionTypeProxy {
+    [action: string]: (options?: ActionExecutionOptions) => Promise<ActionExecutionResult>;
+}
+interface AppProxy {
+    [type: string]: ActionTypeProxy;
+}
+interface AppFactory {
+    (options: AppFactoryOptions): AppProxy;
+}
+type AppProxyWithFactory = AppFactory & AppProxy;
+export interface ActionProxy {
+    [app: string]: AppProxyWithFactory;
+}
+export interface AppsPluginSdkExtension {
+    apps: ActionProxy;
+}
+export {};

package/dist/plugins/apps/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/resolvers/actionKey.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionKeyResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionKeyResolver: ActionKeyResolver;

package/dist/resolvers/actionKey.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionKeyResolver = void 0;
+exports.actionKeyResolver = {
+    type: "dynamic",
+    depends: ["appKey", "actionType"],
+    fetch: async (sdk, resolvedParams) => {
+        const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+        return actions.filter((action) => action.type === resolvedParams.actionType);
+    },
+    prompt: (actions) => ({
+        type: "list",
+        name: "actionKey",
+        message: "Select action:",
+        choices: actions.map((action) => ({
+            name: `${action.name || action.key} - ${action.description || "No description"}`,
+            value: action.key,
+        })),
+    }),
+};

package/dist/resolvers/actionType.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface ActionTypeResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const actionTypeResolver: ActionTypeResolver;

package/dist/resolvers/actionType.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionTypeResolver = void 0;
+exports.actionTypeResolver = {
+    type: "dynamic",
+    depends: ["appKey"],
+    fetch: async (sdk, resolvedParams) => {
+        const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+        const types = [...new Set(actions.map((action) => action.type))];
+        return types.map((type) => ({ key: type, name: type }));
+    },
+    prompt: (types) => ({
+        type: "list",
+        name: "actionType",
+        message: "Select action type:",
+        choices: types.map((type) => ({
+            name: type.name,
+            value: type.key,
+        })),
+    }),
+};

package/dist/resolvers/appKey.d.ts

@@ -0,0 +1,6 @@
+export interface AppKeyResolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+export declare const appKeyResolver: AppKeyResolver;

package/dist/resolvers/appKey.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appKeyResolver = void 0;
+exports.appKeyResolver = {
+    type: "static",
+    inputType: "text",
+    placeholder: "Enter app slug (e.g., 'slack', 'github')",
+};

package/dist/resolvers/authenticationId.d.ts

@@ -0,0 +1,8 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface AuthenticationIdResolver {
+    type: "dynamic";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+    prompt: (items: any[], params: Record<string, any>) => any;
+}
+export declare const authenticationIdResolver: AuthenticationIdResolver;