@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/sdk.d.ts

@@ -1,146 +0,0 @@
-import type { BaseSdkOptions } from "./types/sdk";
-import type { ZapierSdk } from "./types/sdk";
-import type { Sdk, Plugin, ExtractContextProperties, ExtractSdkProperties, PluginProvides, PluginMeta } from "./types/plugin";
-export interface ZapierSdkOptions extends BaseSdkOptions {
-}
-export declare function createSdk<TCurrentSdk = {}, TCurrentContext extends {
-    meta: Record<string, PluginMeta>;
-} = {
-    meta: Record<string, PluginMeta>;
-}>(options?: ZapierSdkOptions, initialSdk?: TCurrentSdk, initialContext?: TCurrentContext): TCurrentSdk & {
-    getContext: () => TCurrentContext;
-    addPlugin<TRequiresContext, TProvides extends PluginProvides>(plugin: Plugin<TCurrentSdk & {
-        getContext(): TCurrentContext;
-    }, TRequiresContext, TProvides>, addPluginOptions?: Record<string, unknown>): Sdk<TCurrentSdk & ExtractSdkProperties<TProvides>, TCurrentContext & NonNullable<ExtractContextProperties<TProvides>>>;
-};
-export declare function createZapierSdkWithoutRegistry(options?: ZapierSdkOptions): Sdk<ExtractSdkProperties<import("./plugins/eventEmission").EventEmissionProvides> & ExtractSdkProperties<import(".").ApiPluginProvides> & ExtractSdkProperties<import(".").ManifestPluginProvides> & ExtractSdkProperties<import(".").ListAppsPluginProvides> & ExtractSdkProperties<import(".").GetAppPluginProvides> & ExtractSdkProperties<import(".").ListActionsPluginProvides> & ExtractSdkProperties<import(".").GetActionPluginProvides> & ExtractSdkProperties<import(".").ListInputFieldsPluginProvides> & ExtractSdkProperties<import("./plugins/getInputFieldsSchema").GetInputFieldsSchemaPluginProvides> & ExtractSdkProperties<import("./plugins/listInputFieldChoices").ListInputFieldChoicesPluginProvides> & ExtractSdkProperties<import(".").RunActionPluginProvides> & ExtractSdkProperties<import(".").ListAuthenticationsPluginProvides> & ExtractSdkProperties<import(".").GetAuthenticationPluginProvides> & ExtractSdkProperties<import(".").FindFirstAuthenticationPluginProvides> & ExtractSdkProperties<import(".").FindUniqueAuthenticationPluginProvides> & ExtractSdkProperties<import(".").RequestPluginProvides> & ExtractSdkProperties<import(".").FetchPluginProvides> & ExtractSdkProperties<import(".").AppsPluginProvides> & ExtractSdkProperties<import(".").GetProfilePluginProvides>, {
-    meta: Record<string, PluginMeta>;
-} & import(".").EventEmissionContext & {
-    api: import("./api").ApiClient;
-} & {
-    getVersionedImplementationId: import("./plugins/manifest/schemas").GetVersionedImplementationId;
-    resolveAppKeys: import("./plugins/manifest/schemas").ResolveAppKeys;
-    updateManifestEntry: (options: import(".").UpdateManifestEntryOptions) => Promise<import(".").UpdateManifestEntryResult>;
-    addActionEntry: (options: import(".").AddActionEntryOptions) => Promise<import(".").AddActionEntryResult>;
-    findActionEntry: (options: {
-        name: string;
-        manifest: import(".").Manifest;
-    }) => import(".").ActionEntry | null;
-    listActionEntries: (options?: {
-        configPath?: string;
-    }) => Promise<Array<[string, import(".").ActionEntry]>>;
-    deleteActionEntry: (options: {
-        name: string;
-        configPath?: string;
-        skipWrite?: boolean;
-    }) => Promise<import(".").Manifest>;
-    hasActionEntry: (options: {
-        name: string;
-        manifest: import(".").Manifest;
-    }) => boolean;
-    findManifestEntry: (options: {
-        appKey: string;
-        manifest: import(".").Manifest;
-    }) => [string, import(".").ManifestEntry] | null;
-    readManifestFromFile: (filePath: string) => Promise<import(".").Manifest | null>;
-} & {
-    meta: {
-        listApps: {
-            inputSchema: typeof import("./temporary-internal-core").ListAppsOptionsSchema;
-        };
-    };
-} & {
-    meta: {
-        getApp: {
-            inputSchema: typeof import("./plugins/getApp/schemas").GetAppSchema;
-        };
-    };
-} & {
-    meta: {
-        listActions: {
-            inputSchema: typeof import("./plugins/listActions/schemas").ListActionsSchema;
-        };
-    };
-} & {
-    meta: {
-        getAction: {
-            inputSchema: typeof import("./plugins/getAction/schemas").GetActionSchema;
-        };
-    };
-} & {
-    meta: {
-        listInputFields: {
-            inputSchema: typeof import("./plugins/listInputFields/schemas").ListInputFieldsSchema;
-        };
-    };
-} & {
-    meta: {
-        getInputFieldsSchema: {
-            inputSchema: typeof import("./plugins/getInputFieldsSchema/schemas").GetInputFieldsSchemaSchema;
-        };
-    };
-} & {
-    meta: {
-        listInputFieldChoices: {
-            inputSchema: typeof import("./plugins/listInputFieldChoices/schemas").ListInputFieldChoicesSchema;
-        };
-    };
-} & {
-    meta: {
-        runAction: {
-            inputSchema: typeof import("./plugins/runAction/schemas").RunActionSchema;
-        };
-    };
-} & {
-    meta: {
-        listAuthentications: {
-            inputSchema: typeof import("./plugins/listAuthentications/schemas").ListAuthenticationsQuerySchema;
-        };
-    };
-} & {
-    meta: {
-        getAuthentication: {
-            inputSchema: import("zod").ZodObject<{
-                authenticationId: import("zod").ZodString;
-            }, import("zod/v4/core").$strip>;
-        };
-    };
-} & {
-    meta: {
-        findFirstAuthentication: {
-            inputSchema: typeof import("./plugins/findFirstAuthentication/schemas").FindFirstAuthenticationSchema;
-        };
-    };
-} & {
-    meta: {
-        findUniqueAuthentication: {
-            inputSchema: typeof import("./plugins/findUniqueAuthentication/schemas").FindUniqueAuthenticationSchema;
-        };
-    };
-} & {
-    meta: {
-        request: {
-            inputSchema: typeof import(".").RelayRequestSchema;
-        };
-    };
-} & {
-    meta: {
-        fetch: {
-            packages: string[];
-            categories: string[];
-            returnType: string;
-            inputParameters: Array<{
-                name: string;
-                schema: import("zod").ZodType;
-            }>;
-        };
-    };
-} & {
-    meta: {
-        getProfile: {
-            inputSchema: typeof import("./plugins/getProfile/schemas").GetProfileSchema;
-        };
-    };
-}>;
-export declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;
-//# sourceMappingURL=sdk.d.ts.map

package/dist/sdk.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdk.d.ts","sourceRoot":"","sources":["../src/sdk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EACV,GAAG,EACH,MAAM,EACN,wBAAwB,EACxB,oBAAoB,EACpB,cAAc,EACd,UAAU,EACX,MAAM,gBAAgB,CAAC;AA2BxB,MAAM,WAAW,gBAAiB,SAAQ,cAAc;CAAG;AAG3D,wBAAgB,SAAS,CACvB,WAAW,GAAG,EAAE,EAChB,eAAe,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CAAE,GAAG;IAC7D,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAClC,EAED,OAAO,GAAE,gBAAqB,EAC9B,UAAU,GAAE,WAA+B,EAC3C,cAAc,GAAE,eAAiD;;cAKrD,gBAAgB,EAAE,SAAS,SAAS,cAAc,UAClD,MAAM,CACZ,WAAW,GAAG;QAAE,UAAU,IAAI,eAAe,CAAA;KAAE,EAC/C,gBAAgB,EAChB,SAAS,CACV,qBACiB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACxC,GAAG,CACJ,WAAW,GAAG,oBAAoB,CAAC,SAAS,CAAC,EAC7C,eAAe,GAAG,WAAW,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC,CACnE;EA8DJ;AAED,wBAAgB,8BAA8B,CAAC,OAAO,GAAE,gBAAqB;UApFnE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC;;;;;;;;;;;;+BAD2B,CAAC;kBAC/C,CAAC;;;;kBAKG,CAAC;iBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuH/C;AAED,wBAAgB,eAAe,CAAC,OAAO,GAAE,gBAAqB,GAAG,SAAS,CAMzE"}

package/dist/sdk.js

@@ -1,112 +0,0 @@
-// Import plugin functions
-import { appsPlugin } from "./plugins/apps/index";
-import { fetchPlugin } from "./plugins/fetch/index";
-import { registryPlugin } from "./plugins/registry/index";
-import { apiPlugin } from "./plugins/api/index";
-import { getProfilePlugin } from "./plugins/getProfile";
-import { listAppsPlugin } from "./plugins/listApps";
-import { getAppPlugin } from "./plugins/getApp";
-import { listActionsPlugin } from "./plugins/listActions";
-import { getActionPlugin } from "./plugins/getAction";
-import { runActionPlugin } from "./plugins/runAction";
-import { listAuthenticationsPlugin } from "./plugins/listAuthentications";
-import { getAuthenticationPlugin } from "./plugins/getAuthentication";
-import { findFirstAuthenticationPlugin } from "./plugins/findFirstAuthentication";
-import { findUniqueAuthenticationPlugin } from "./plugins/findUniqueAuthentication";
-import { listInputFieldsPlugin } from "./plugins/listInputFields";
-import { getInputFieldsSchemaPlugin } from "./plugins/getInputFieldsSchema";
-import { listInputFieldChoicesPlugin } from "./plugins/listInputFieldChoices";
-import { requestPlugin } from "./plugins/request";
-import { manifestPlugin } from "./plugins/manifest";
-import { eventEmissionPlugin } from "./plugins/eventEmission";
-// Create SDK that supports flat plugins - returns an SDK, not a builder
-export function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} }) {
-    return {
-        ...initialSdk,
-        getContext: () => initialContext,
-        addPlugin(plugin, addPluginOptions = {}) {
-            // Create SDK with getContext method for plugins to use
-            const currentSdkWithContext = {
-                ...initialSdk,
-                getContext: () => initialContext,
-            };
-            // Apply the plugin with options merged in
-            const pluginResult = plugin({
-                sdk: currentSdkWithContext,
-                context: {
-                    ...initialContext,
-                    // Add the options that createSdk was called with to context
-                    options,
-                },
-                ...addPluginOptions,
-            });
-            // Extract context from plugin result if present
-            const { context: pluginContext, ...sdkProperties } = pluginResult;
-            // Merge SDK properties directly (flat structure)
-            const newSdk = { ...initialSdk, ...sdkProperties };
-            // Merge context additions if plugin returned any
-            // Ensure meta is always present, starting with existing or empty object
-            let newContext = {
-                ...initialContext,
-                ...addPluginOptions,
-                meta: initialContext.meta || {},
-            };
-            if (pluginContext) {
-                // Extract meta from plugin context for special merging
-                const { meta: pluginMeta, ...otherPluginContext } = pluginContext;
-                newContext = {
-                    ...newContext,
-                    ...otherPluginContext,
-                };
-                // Merge meta separately to avoid overwriting
-                if (pluginMeta) {
-                    newContext = {
-                        ...newContext,
-                        meta: {
-                            ...newContext.meta, // Existing meta (now guaranteed to exist)
-                            ...pluginMeta, // New meta from plugin
-                        },
-                    };
-                }
-            }
-            // Recursively create new SDK with updated properties
-            return createSdk(options, newSdk, newContext);
-        },
-    };
-}
-export function createZapierSdkWithoutRegistry(options = {}) {
-    return (createSdk(options)
-        // Event emission (must be first to be available to other plugins)
-        .addPlugin(eventEmissionPlugin)
-        // Provides the API client in context
-        .addPlugin(apiPlugin)
-        // Manifest plugin (provides version locking context) - must come after apiPlugin
-        .addPlugin(manifestPlugin)
-        // Apps/actions/fields
-        .addPlugin(listAppsPlugin)
-        .addPlugin(getAppPlugin)
-        .addPlugin(listActionsPlugin)
-        .addPlugin(getActionPlugin)
-        .addPlugin(listInputFieldsPlugin)
-        .addPlugin(getInputFieldsSchemaPlugin)
-        .addPlugin(listInputFieldChoicesPlugin)
-        // Run action
-        .addPlugin(runActionPlugin)
-        // Authentications
-        .addPlugin(listAuthenticationsPlugin)
-        .addPlugin(getAuthenticationPlugin)
-        .addPlugin(findFirstAuthenticationPlugin)
-        .addPlugin(findUniqueAuthenticationPlugin)
-        // Relay fetching
-        .addPlugin(requestPlugin)
-        .addPlugin(fetchPlugin)
-        // Magic apps plugin
-        .addPlugin(appsPlugin)
-        // Profile
-        .addPlugin(getProfilePlugin));
-}
-export function createZapierSdk(options = {}) {
-    return (createZapierSdkWithoutRegistry(options)
-        // Register plugins for CLI/MCP metadata
-        .addPlugin(registryPlugin));
-}

package/dist/sdk.test.d.ts

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

package/dist/sdk.test.d.ts.map

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

package/dist/sdk.test.js

@@ -1,255 +0,0 @@
-// Test the flat plugin system
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { createZapierSdk, createSdk } from "./sdk";
-describe("Flat Plugin System", () => {
-    it("should create SDK with all expected methods", () => {
-        const sdk = createZapierSdk();
-        // Test that all core methods are available
-        expect(sdk.listApps).toBeDefined();
-        expect(sdk.listAuthentications).toBeDefined();
-        expect(sdk.getAuthentication).toBeDefined();
-        expect(sdk.runAction).toBeDefined();
-        expect(sdk.request).toBeDefined();
-        // Test that plugin methods are available
-        expect(sdk.fetch).toBeDefined();
-        expect(sdk.apps).toBeDefined();
-        expect(sdk.getProfile).toBeDefined();
-        // Test that getContext method is available
-        expect(sdk.getContext).toBeDefined();
-        expect(typeof sdk.getContext).toBe("function");
-    });
-    it("should have getContext method that returns context", () => {
-        const sdk = createZapierSdk();
-        const context = sdk.getContext(); // Type assertion to work around complex context inference
-        // Context should be an object
-        expect(typeof context).toBe("object");
-        expect(context).not.toBeNull();
-        // Context should have some properties (specific properties depend on plugin composition)
-        expect(Object.keys(context).length).toBeGreaterThan(0);
-        // Should have meta object
-        expect(context.meta).toBeDefined();
-        expect(typeof context.meta).toBe("object");
-        // Should have getProfile metadata from the plugin (verify it exists in meta)
-        expect("getProfile" in context.meta).toBe(true);
-        expect(context.meta.getProfile).toBeDefined();
-        expect(context.meta.getProfile.inputSchema).toBeDefined();
-    });
-    it("should have plugins return flat structure", () => {
-        const sdk = createZapierSdk();
-        // fetch should be directly available (not sdk.plugins.fetch or sdk.fetch.fetch)
-        expect(typeof sdk.fetch).toBe("function");
-        // apps should be directly available
-        expect(typeof sdk.apps).toBe("object");
-        // getProfile should be directly available
-        expect(typeof sdk.getProfile).toBe("function");
-    });
-    it("should support fluent plugin chaining with createSdk", () => {
-        // Test that createSdk().addPlugin().addPlugin() works and returns properly typed SDK
-        const testPlugin = () => ({
-            testMethod: () => "test result",
-        });
-        const sdk = createSdk().addPlugin(testPlugin);
-        // Should have getContext method
-        expect(typeof sdk.getContext).toBe("function");
-        // Should have addPlugin method for further chaining
-        expect(typeof sdk.addPlugin).toBe("function");
-        // Should have the plugin method
-        expect(typeof sdk.testMethod).toBe("function");
-        expect(sdk.testMethod()).toBe("test result");
-    });
-    it("should support fluent plugin chaining without .getSdk()", () => {
-        // This demonstrates the simplified API - no .getSdk() needed!
-        const plugin1 = () => ({ method1: () => "method1" });
-        const plugin2 = () => ({ method2: () => "method2" });
-        // Fluent chaining - each addPlugin returns a new SDK
-        const sdk = createSdk().addPlugin(plugin1).addPlugin(plugin2);
-        expect(sdk.method1()).toBe("method1");
-        expect(sdk.method2()).toBe("method2");
-        expect(typeof sdk.getContext).toBe("function");
-        expect(typeof sdk.addPlugin).toBe("function"); // Can still add more plugins!
-    });
-    it("should support plugins with options", () => {
-        // Test that addPlugin(pluginFn, options) works correctly
-        const pluginWithOptions = (params) => ({
-            getMessage: () => params.message,
-        });
-        const sdk = createSdk().addPlugin(pluginWithOptions, {
-            message: "Hello from options!",
-        });
-        expect(typeof sdk.getMessage).toBe("function");
-        expect(sdk.getMessage()).toBe("Hello from options!");
-    });
-    it("should merge context.meta from multiple plugins", () => {
-        // Test that multiple plugins can provide meta without overwriting each other
-        const plugin1 = () => ({
-            method1: () => "method1",
-            context: {
-                meta: {
-                    plugin1: { info: "Plugin 1 metadata" },
-                },
-            },
-        });
-        const plugin2 = () => ({
-            method2: () => "method2",
-            context: {
-                meta: {
-                    plugin2: { info: "Plugin 2 metadata" },
-                },
-            },
-        });
-        const sdk = createSdk().addPlugin(plugin1).addPlugin(plugin2);
-        const context = sdk.getContext();
-        // Both plugins should have their meta preserved
-        expect(context.meta.plugin1.info).toBe("Plugin 1 metadata");
-        expect(context.meta.plugin2.info).toBe("Plugin 2 metadata");
-        // Both methods should work
-        expect(sdk.method1()).toBe("method1");
-        expect(sdk.method2()).toBe("method2");
-    });
-    it("should support context requirements for cleaner plugin definitions", () => {
-        // Test context requirements work correctly
-        const pluginWithHelper = ({ sdk, context }) => ({
-            helperMethod: () => `Helper: ${sdk.existingMethod()} + ${context.customContext}`,
-        });
-        const baseSdk = { existingMethod: () => "base" };
-        const baseContext = { customContext: "custom", meta: {} };
-        const sdk = createSdk({}, baseSdk, baseContext).addPlugin(pluginWithHelper);
-        expect(sdk.helperMethod()).toBe("Helper: base + custom");
-        expect(sdk.existingMethod()).toBe("base"); // Original method still works
-    });
-    it("should ensure context.meta is always available", () => {
-        // Test that context.meta is always at least an empty object, even without explicit initialization
-        const plugin = ({ context }) => ({
-            testMethod: () => `Meta keys: ${Object.keys(context.meta).length}`,
-        });
-        // Create SDK without explicitly providing meta
-        const sdk = createSdk({}).addPlugin(plugin);
-        // Should work without error - meta should be at least an empty object
-        expect(sdk.testMethod()).toBe("Meta keys: 0");
-        // getContext() should also provide meta
-        const context = sdk.getContext();
-        expect(context.meta).toBeDefined();
-        expect(typeof context.meta).toBe("object");
-        expect(context.meta).not.toBeNull();
-    });
-});
-describe("Environment Variable Support", () => {
-    let originalEnv;
-    beforeEach(() => {
-        // Save original environment variable
-        originalEnv = process.env.ZAPIER_BASE_URL;
-    });
-    afterEach(() => {
-        // Restore original environment variable
-        if (originalEnv !== undefined) {
-            process.env.ZAPIER_BASE_URL = originalEnv;
-        }
-        else {
-            delete process.env.ZAPIER_BASE_URL;
-        }
-        // Clear module cache to ensure constants are re-evaluated
-        vi.resetModules();
-    });
-    it("should use custom base URL from ZAPIER_BASE_URL environment variable", async () => {
-        // Set custom base URL via environment variable
-        const customBaseUrl = "https://custom-zapier.example.com";
-        process.env.ZAPIER_BASE_URL = customBaseUrl;
-        // Clear module cache and re-import to get fresh constants
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        // Create mock fetch function to capture requests
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                results: [],
-                meta: { next_cursor: null },
-            }),
-            headers: new Headers(),
-        });
-        // Create SDK instance with mock fetch
-        const sdk = createZapierSdk({
-            token: "test-token",
-            fetch: mockFetch,
-        });
-        // Make an API call that should use the custom base URL
-        await sdk.listApps();
-        // Verify that the request was made to the custom base URL
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-        const [actualUrl] = mockFetch.mock.calls[0];
-        expect(actualUrl).toMatch(new RegExp(`^${customBaseUrl}`));
-        expect(actualUrl).toContain("/api/v4/");
-    });
-    it("should use default base URL when ZAPIER_BASE_URL is not set", async () => {
-        // Ensure environment variable is not set
-        delete process.env.ZAPIER_BASE_URL;
-        // Clear module cache and re-import to get fresh constants
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        // Create mock fetch function to capture requests
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                results: [],
-                meta: { next_cursor: null },
-            }),
-            headers: new Headers(),
-        });
-        // Create SDK instance with mock fetch
-        const sdk = createZapierSdk({
-            token: "test-token",
-            fetch: mockFetch,
-        });
-        // Make an API call that should use the default base URL
-        await sdk.listApps();
-        // Verify that the request was made to the default base URL
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-        const [actualUrl] = mockFetch.mock.calls[0];
-        expect(actualUrl).toMatch(/^https:\/\/sdkapi\.zapier\.com/);
-        expect(actualUrl).toContain("/api/v4/");
-    });
-    it("should use explicit baseUrl option for SDK API requests", async () => {
-        // Clear environment variable to ensure we're testing the explicit option
-        delete process.env.ZAPIER_BASE_URL;
-        // Clear module cache and re-import to get fresh constants
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        const customBaseUrl = "https://staging.zapier.com";
-        // Create mock fetch function to capture requests
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                results: [],
-                meta: { next_cursor: null },
-            }),
-            headers: new Headers(),
-        });
-        // Create SDK instance with explicit baseUrl option and mock fetch
-        const sdk = createZapierSdk({
-            baseUrl: customBaseUrl,
-            token: "test-token",
-            fetch: mockFetch,
-        });
-        // Make an API call that should use the custom base URL
-        await sdk.listApps();
-        // Verify that the request was made to the custom base URL
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-        const [actualUrl] = mockFetch.mock.calls[0];
-        expect(actualUrl).toMatch(new RegExp(`^${customBaseUrl}`));
-        expect(actualUrl).toContain("/api/v4/");
-    });
-    it("should accept authClientId in SDK options", async () => {
-        delete process.env.ZAPIER_BASE_URL;
-        vi.resetModules();
-        const { createZapierSdk } = await import("./sdk");
-        const sdk = createZapierSdk({
-            authClientId: "test-client-id",
-            token: "test-token",
-        });
-        // Verify SDK was created successfully with authClientId option
-        expect(sdk).toBeDefined();
-        expect(sdk.listApps).toBeDefined();
-    });
-});

package/dist/services/implementations.d.ts

@@ -1,63 +0,0 @@
-/**
- * Implementation Services
- *
- * This module provides domain-specific service functions for interacting with
- * the /api/v4/implementations/* endpoints. These services handle request building,
- * validation, error handling, and authentication for implementation-related API calls.
- *
- * Services are consumed by plugins to avoid code duplication while maintaining
- * separation between the generic HTTP client layer and business logic.
- */
-import type { ApiClient } from "../api";
-import type { NeedsResponse, NeedChoicesResponse } from "../api/types";
-/**
- * Fetches implementation needs (input fields) for a specific action.
- *
- * This service calls the /api/v4/implementations/needs/ endpoint and returns
- * the raw response after validating success. The response includes all field
- * metadata including static choices, field types, and validation rules.
- *
- * @param params - Request parameters
- * @param params.api - API client instance
- * @param params.selectedApi - Versioned implementation ID (e.g., "SlackCLIAPI@1.21.1")
- * @param params.action - Action key
- * @param params.actionType - Action type (read, write, etc.)
- * @param params.authenticationId - Authentication ID (null to skip authentication)
- * @param params.inputs - Input values that may affect available fields
- * @returns Promise resolving to NeedsResponse
- * @throws {ZapierApiError} When the API request fails or returns success: false
- */
-export declare function fetchImplementationNeeds({ api, selectedApi, action, actionType, authenticationId, inputs, }: {
-    api: ApiClient;
-    selectedApi: string;
-    action: string;
-    actionType: string;
-    authenticationId: string | number | null;
-    inputs?: Record<string, unknown>;
-}): Promise<NeedsResponse>;
-/**
- * Fetches dynamic choices for a specific input field.
- *
- * This service calls the /api/v4/implementations/choices/ endpoint and returns
- * the raw response after validating success. The response includes available
- * choices for dropdown fields with pagination support.
- *
- * @param params - Request parameters
- * @param params.api - API client instance
- * @param params.actionId - Action ID (e.g., "core:123")
- * @param params.inputFieldId - Input field key
- * @param params.authenticationId - Authentication ID (null to skip authentication)
- * @param params.inputs - Input values that may affect available choices
- * @param params.page - Page number for pagination (0-indexed)
- * @returns Promise resolving to NeedChoicesResponse
- * @throws {ZapierApiError} When the API request fails or returns success: false
- */
-export declare function fetchImplementationChoices({ api, actionId, inputFieldId, authenticationId, inputs, page, }: {
-    api: ApiClient;
-    actionId: string;
-    inputFieldId: string;
-    authenticationId: string | number | null;
-    inputs?: Record<string, unknown>;
-    page: number;
-}): Promise<NeedChoicesResponse>;
-//# sourceMappingURL=implementations.d.ts.map

package/dist/services/implementations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"implementations.d.ts","sourceRoot":"","sources":["../../src/services/implementations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,KAAK,EAEV,aAAa,EAEb,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAItB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,wBAAwB,CAAC,EAC7C,GAAG,EACH,WAAW,EACX,MAAM,EACN,UAAU,EACV,gBAAgB,EAChB,MAAM,GACP,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,GAAG,OAAO,CAAC,aAAa,CAAC,CA4BzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,0BAA0B,CAAC,EAC/C,GAAG,EACH,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,MAAM,EACN,IAAI,GACL,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA4B/B"}

package/dist/services/implementations.js

@@ -1,80 +0,0 @@
-/**
- * Implementation Services
- *
- * This module provides domain-specific service functions for interacting with
- * the /api/v4/implementations/* endpoints. These services handle request building,
- * validation, error handling, and authentication for implementation-related API calls.
- *
- * Services are consumed by plugins to avoid code duplication while maintaining
- * separation between the generic HTTP client layer and business logic.
- */
-import { ZapierApiError } from "../types/errors";
-import { coerceToNumericId } from "../utils/id-utils";
-/**
- * Fetches implementation needs (input fields) for a specific action.
- *
- * This service calls the /api/v4/implementations/needs/ endpoint and returns
- * the raw response after validating success. The response includes all field
- * metadata including static choices, field types, and validation rules.
- *
- * @param params - Request parameters
- * @param params.api - API client instance
- * @param params.selectedApi - Versioned implementation ID (e.g., "SlackCLIAPI@1.21.1")
- * @param params.action - Action key
- * @param params.actionType - Action type (read, write, etc.)
- * @param params.authenticationId - Authentication ID (null to skip authentication)
- * @param params.inputs - Input values that may affect available fields
- * @returns Promise resolving to NeedsResponse
- * @throws {ZapierApiError} When the API request fails or returns success: false
- */
-export async function fetchImplementationNeeds({ api, selectedApi, action, actionType, authenticationId, inputs, }) {
-    const request = {
-        selected_api: selectedApi,
-        action,
-        type_of: actionType,
-        params: inputs || {},
-    };
-    // Only include authentication_id if it's not null (skip authentication when null)
-    if (authenticationId !== null) {
-        request.authentication_id = coerceToNumericId("authentication_id", authenticationId);
-    }
-    const response = await api.post("/zapier/api/v4/implementations/needs/", request);
-    if (!response.success) {
-        throw new ZapierApiError(`Failed to get input fields: ${response.errors?.join(", ") || "Unknown error"}`);
-    }
-    return response;
-}
-/**
- * Fetches dynamic choices for a specific input field.
- *
- * This service calls the /api/v4/implementations/choices/ endpoint and returns
- * the raw response after validating success. The response includes available
- * choices for dropdown fields with pagination support.
- *
- * @param params - Request parameters
- * @param params.api - API client instance
- * @param params.actionId - Action ID (e.g., "core:123")
- * @param params.inputFieldId - Input field key
- * @param params.authenticationId - Authentication ID (null to skip authentication)
- * @param params.inputs - Input values that may affect available choices
- * @param params.page - Page number for pagination (0-indexed)
- * @returns Promise resolving to NeedChoicesResponse
- * @throws {ZapierApiError} When the API request fails or returns success: false
- */
-export async function fetchImplementationChoices({ api, actionId, inputFieldId, authenticationId, inputs, page, }) {
-    const request = {
-        action_id: actionId,
-        input_field_id: inputFieldId,
-        page,
-        params: inputs || {},
-    };
-    // Only include authentication_id if it's not null (skip authentication when null)
-    if (authenticationId !== null) {
-        request.authentication_id = coerceToNumericId("authentication_id", authenticationId);
-    }
-    const response = await api.post("/zapier/api/v4/implementations/choices/", request);
-    if (!response.success) {
-        throw new ZapierApiError(`Failed to get input field choices: ${response.errors?.join(", ") || "Unknown error"}`);
-    }
-    return response;
-}