@zapier/zapier-sdk 0.4.1 → 0.5.1

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

@@ -0,0 +1,14 @@
+import type { ApiClient } from "../../api/types";
+import type { BaseSdkOptions } from "../../types/sdk";
+import type { Plugin } from "../../types/plugin";
+export interface ApiPluginOptions extends BaseSdkOptions {
+}
+export interface ApiPluginProvides {
+    context: {
+        api: ApiClient;
+    };
+}
+export declare const apiPlugin: Plugin<{}, // no SDK dependencies
+{}, // requires no context
+ApiPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/api/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,MAAM,WAAW,gBAAiB,SAAQ,cAAc;CAAG;AAG3D,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE;QACP,GAAG,EAAE,SAAS,CAAC;KAChB,CAAC;CACH;AAGD,eAAO,MAAM,SAAS,EAAE,MAAM,CAC5B,EAAE,EAAE,sBAAsB;AAC1B,EAAE,EAAE,sBAAsB;AAC1B,iBAAiB,CA4BlB,CAAC"}

package/dist/plugins/api/index.js

@@ -0,0 +1,21 @@
+import { createZapierApi } from "../../api";
+// API plugin requires no context and provides api in context
+export const apiPlugin = (params) => {
+    // Extract all options - everything passed to the plugin
+    const { fetch: customFetch = globalThis.fetch, baseUrl = "https://zapier.com", token, getToken, onEvent, debug = false, } = params;
+    // Create the API client - it will handle token resolution internally
+    const api = createZapierApi({
+        baseUrl,
+        token,
+        getToken,
+        debug,
+        fetch: customFetch,
+        onEvent,
+    });
+    // Return flat structure with context only
+    return {
+        context: {
+            api, // Provide API client in context for other plugins to use
+        },
+    };
+};

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

@@ -0,0 +1,11 @@
+import type { ActionProxy } from "./types";
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { FetchPluginProvides } from "../fetch/index";
+import type { RunActionPluginProvides } from "../runAction/index";
+export interface AppsPluginProvides {
+    apps: ActionProxy;
+}
+export declare const appsPlugin: Plugin<GetSdkType<FetchPluginProvides & RunActionPluginProvides>, // requires fetch + runAction in SDK
+{}, // no context requirements
+AppsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/apps/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC1D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAElE,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,WAAW,CAAC;CACnB;AA4JD,eAAO,MAAM,UAAU,EAAE,MAAM,CAC7B,UAAU,CAAC,mBAAmB,GAAG,uBAAuB,CAAC,EAAE,oCAAoC;AAC/F,EAAE,EAAE,0BAA0B;AAC9B,kBAAkB,CAMnB,CAAC"}

package/dist/plugins/apps/index.js

@@ -0,0 +1,91 @@
+import { ZapierValidationError } from "../../types/errors";
+function createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId) {
+    return (actionOptions = {}) => {
+        const { sdk } = options;
+        const { inputs, authenticationId: providedAuthenticationId } = actionOptions;
+        // Use pinned auth ID first, then provided auth ID
+        const authenticationId = pinnedAuthId || providedAuthenticationId;
+        if (!authenticationId) {
+            throw new ZapierValidationError(`Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`);
+        }
+        // Call sdk.runAction with the resolved parameters
+        return sdk.runAction({
+            appKey,
+            actionType: actionType,
+            actionKey,
+            inputs,
+            authenticationId,
+        });
+    };
+}
+function createActionTypeProxy(appKey, actionType, options, pinnedAuthId) {
+    // Special handling for "fetch" action type
+    if (actionType === "fetch") {
+        return async (url, init) => {
+            const { sdk } = options;
+            // Use pinned auth ID first, then provided auth ID
+            const authenticationId = pinnedAuthId || init?.authenticationId;
+            if (!authenticationId) {
+                throw new ZapierValidationError(`Authentication ID is required for fetch. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }).fetch(...) or provide authenticationId in the fetch call.`);
+            }
+            // Call sdk.fetch with the resolved authenticationId
+            return sdk.fetch(url, {
+                ...init,
+                authenticationId,
+            });
+        };
+    }
+    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;
+}
+// Direct plugin function - takes options + sdk + context in one object
+export const appsPlugin = ({ sdk }) => {
+    // Return flat structure - apps goes directly to SDK
+    return {
+        apps: createAppsProxy({ sdk }),
+    };
+};

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

@@ -0,0 +1,30 @@
+export interface ActionExecutionOptions {
+    inputs?: Record<string, any>;
+    authenticationId?: number;
+}
+interface AppFactoryOptions {
+    authenticationId: number;
+}
+interface BaseActionTypeProxy {
+    [action: string]: (options?: ActionExecutionOptions) => any;
+}
+interface FetchActionType {
+    fetch: (url: string | URL, init?: RequestInit & {
+        authenticationId?: number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+    }) => Promise<Response>;
+}
+type ActionTypeProxy = BaseActionTypeProxy & Partial<FetchActionType>;
+interface AppProxy {
+    [type: string]: ActionTypeProxy;
+}
+interface AppFactory {
+    (options: AppFactoryOptions): AppProxy;
+}
+type AppProxyWithFactory = AppFactory & AppProxy;
+export interface ActionProxy {
+    [app: string]: AppProxyWithFactory;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/plugins/apps/types.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,sBAAsB;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,iBAAiB;IACzB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAGD,UAAU,mBAAmB;IAC3B,CAAC,MAAM,EAAE,MAAM,GAAG,CAAC,OAAO,CAAC,EAAE,sBAAsB,KAAK,GAAG,CAAC;CAC7D;AAGD,UAAU,eAAe;IACvB,KAAK,EAAE,CACL,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,CAAC,EAAE,WAAW,GAAG;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,sBAAsB,CAAC,EAAE,MAAM,CAAC;KACjC,KACE,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxB;AAGD,KAAK,eAAe,GAAG,mBAAmB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAEtE,UAAU,QAAQ;IAChB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC;CACjC;AAED,UAAU,UAAU;IAClB,CAAC,OAAO,EAAE,iBAAiB,GAAG,QAAQ,CAAC;CACxC;AAGD,KAAK,mBAAmB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAEjD,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAAC;CACpC"}

package/dist/plugins/apps/types.js

@@ -0,0 +1,2 @@
+export {};
+// Note: AppsPluginSdkExtension removed - now using AppsPluginProvides in index.ts

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

@@ -0,0 +1,21 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { RequestPluginProvides } from "../request";
+export interface FetchPluginProvides {
+    fetch: (url: string | URL, init?: RequestInit & {
+        authenticationId?: number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+    }) => Promise<Response>;
+}
+/**
+ * Direct plugin function - takes options + sdk + context in one object
+ */
+export declare const fetchPlugin: Plugin<GetSdkType<RequestPluginProvides>, // requires request in SDK
+{}, // requires no context (uses SDK methods)
+FetchPluginProvides>;
+export type ZapierFetchInitOptions = RequestInit & {
+    authenticationId?: number;
+    callbackUrl?: string;
+    authenticationTemplate?: string;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,CACL,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,CAAC,EAAE,WAAW,GAAG;QACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,sBAAsB,CAAC,EAAE,MAAM,CAAC;KACjC,KACE,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxB;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAC9B,UAAU,CAAC,qBAAqB,CAAC,EAAE,0BAA0B;AAC7D,EAAE,EAAE,yCAAyC;AAC7C,mBAAmB,CA8BpB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG;IACjD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC"}

package/dist/plugins/fetch/index.js

@@ -0,0 +1,20 @@
+/**
+ * Direct plugin function - takes options + sdk + context in one object
+ */
+export const fetchPlugin = ({ sdk }) => {
+    // Return flat structure - fetch goes directly to SDK
+    return {
+        fetch: async function fetch(url, init) {
+            const { authenticationId, callbackUrl, authenticationTemplate, ...fetchInit } = init || {};
+            return sdk.request({
+                url: url.toString(),
+                method: fetchInit.method,
+                body: fetchInit.body,
+                headers: fetchInit.headers,
+                authenticationId,
+                callbackUrl,
+                authenticationTemplate,
+            });
+        },
+    };
+};

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

@@ -0,0 +1,20 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { AuthenticationItem } from "../../types/domain";
+import { FindFirstAuthenticationSchema, type FindFirstAuthenticationOptions } from "./schemas";
+import type { ListAuthenticationsPluginProvides } from "../listAuthentications";
+export interface FindFirstAuthenticationPluginProvides {
+    findFirstAuthentication: (options?: FindFirstAuthenticationOptions) => Promise<{
+        data: AuthenticationItem | null;
+    }>;
+    context: {
+        meta: {
+            findFirstAuthentication: {
+                inputSchema: typeof FindFirstAuthenticationSchema;
+            };
+        };
+    };
+}
+export declare const findFirstAuthenticationPlugin: Plugin<GetSdkType<ListAuthenticationsPluginProvides>, // requires listAuthentications in SDK
+{}, // no context requirements
+FindFirstAuthenticationPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/findFirstAuthentication/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EACL,6BAA6B,EAC7B,KAAK,8BAA8B,EACpC,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAEhF,MAAM,WAAW,qCAAqC;IACpD,uBAAuB,EAAE,CACvB,OAAO,CAAC,EAAE,8BAA8B,KACrC,OAAO,CAAC;QAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAClD,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,uBAAuB,EAAE;gBACvB,WAAW,EAAE,OAAO,6BAA6B,CAAC;aACnD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAChD,UAAU,CAAC,iCAAiC,CAAC,EAAE,sCAAsC;AACrF,EAAE,EAAE,0BAA0B;AAC9B,qCAAqC,CA6BtC,CAAC"}

package/dist/plugins/findFirstAuthentication/index.js

@@ -0,0 +1,24 @@
+import { FindFirstAuthenticationSchema, } from "./schemas";
+import { createFunction } from "../../utils/function-utils";
+export const findFirstAuthenticationPlugin = ({ sdk }) => {
+    const findFirstAuthentication = createFunction(async function findFirstAuthentication(options = {}) {
+        // Use listAuthentications with maxItems 1 to get the first result
+        const authsResponse = await sdk.listAuthentications({
+            ...options,
+            maxItems: 1,
+        });
+        return {
+            data: authsResponse.data.length > 0 ? authsResponse.data[0] : null,
+        };
+    }, FindFirstAuthenticationSchema);
+    return {
+        findFirstAuthentication,
+        context: {
+            meta: {
+                findFirstAuthentication: {
+                    inputSchema: FindFirstAuthenticationSchema,
+                },
+            },
+        },
+    };
+};

package/dist/plugins/findFirstAuthentication/index.test.d.ts

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

package/dist/plugins/findFirstAuthentication/index.test.d.ts.map

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

package/dist/plugins/findFirstAuthentication/index.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError } from "../../types/errors";
+import { findFirstAuthenticationPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { ListAuthenticationsSchema } from "../listAuthentications/schemas";
+const mockAuthentications = [
+    {
+        id: 123,
+        title: "My Slack",
+        date: "2021-01-01",
+        account_id: 123,
+        implementation_id: "api_123",
+        is_expired: "false",
+        expired_at: null,
+        is_invite_only: false,
+        is_private: false,
+        shared_with_all: false,
+    },
+    {
+        id: 456,
+        title: "Slack Workspace 2",
+        is_expired: "false",
+        expired_at: null,
+        date: "2021-01-01",
+        account_id: 123,
+        implementation_id: "api_123",
+        is_invite_only: false,
+        is_private: false,
+        shared_with_all: false,
+    },
+];
+describe("findFirstAuthentication plugin", () => {
+    let mockListAuthentications;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockListAuthentications = vi.fn().mockResolvedValue({
+            data: mockAuthentications,
+        });
+    });
+    function createTestSdk() {
+        // Create a proper plugin chain: first add a mock listAuthentications plugin, then add findFirstAuthentication
+        const mockListAuthenticationsPlugin = () => ({
+            listAuthentications: mockListAuthentications,
+            context: {
+                meta: {
+                    listAuthentications: {
+                        inputSchema: ListAuthenticationsSchema,
+                    },
+                },
+            },
+        });
+        // Build SDK with proper plugin composition
+        return createSdk()
+            .addPlugin(mockListAuthenticationsPlugin)
+            .addPlugin(findFirstAuthenticationPlugin);
+    }
+    describe("schema validation", () => {
+        it("should pass validation with empty options", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.findFirstAuthentication({});
+            expect(result.data).toBeDefined();
+        });
+        it("should pass validation with undefined options", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.findFirstAuthentication();
+            expect(result.data).toBeDefined();
+        });
+        it("should throw validation error for invalid appKey type", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.findFirstAuthentication({
+                appKey: 123, // intentionally wrong type for testing
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid search type", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.findFirstAuthentication({
+                search: 123,
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid parameter types", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.findFirstAuthentication({
+                title: 123,
+                account_id: 456,
+                owner: true,
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all valid fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.findFirstAuthentication({
+                appKey: "slack",
+                search: "workspace",
+                title: "My Slack Workspace",
+                account_id: "acc_123",
+                owner: "me",
+            });
+            expect(result.data).toBeDefined();
+        });
+    });
+    describe("business logic", () => {
+        it("should return first authentication when found", async () => {
+            const mockAuth = mockAuthentications[0];
+            mockListAuthentications.mockResolvedValue({
+                data: [mockAuth],
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.findFirstAuthentication({
+                appKey: "slack",
+            });
+            expect(result.data).toEqual(mockAuth);
+        });
+        it("should return null when no authentications found", async () => {
+            mockListAuthentications.mockResolvedValue({
+                data: [],
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.findFirstAuthentication({
+                appKey: "nonexistent",
+            });
+            expect(result.data).toBeNull();
+        });
+        it("should return first authentication when multiple found", async () => {
+            const mockAuth = mockAuthentications[0];
+            mockListAuthentications.mockResolvedValue({
+                data: [mockAuth, mockAuthentications[1]],
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.findFirstAuthentication({
+                search: "Slack",
+            });
+            expect(result.data).toEqual(mockAuth);
+        });
+    });
+    describe("options forwarding", () => {
+        it("should forward all options to listAuthentications", async () => {
+            const sdk = createTestSdk();
+            const options = {
+                appKey: "slack",
+                search: "workspace",
+                title: "My Slack Workspace",
+                account_id: "acc_123",
+                owner: "me",
+            };
+            await sdk.findFirstAuthentication(options);
+            expect(mockListAuthentications).toHaveBeenCalledWith({
+                ...options,
+                maxItems: 1,
+            });
+        });
+    });
+    describe("limit enforcement", () => {
+        it("should automatically set maxItems to 1", async () => {
+            const sdk = createTestSdk();
+            await sdk.findFirstAuthentication({
+                appKey: "slack",
+            });
+            expect(mockListAuthentications).toHaveBeenCalledWith({
+                appKey: "slack",
+                maxItems: 1,
+            });
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.findFirstAuthentication).toBeDefined();
+            expect(context.meta.findFirstAuthentication.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { AuthenticationItem } from "../../types/domain";
+export declare const FindFirstAuthenticationSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    title?: string | undefined;
+    search?: string | undefined;
+    account_id?: string | undefined;
+    appKey?: string | undefined;
+    owner?: string | undefined;
+}, {
+    title?: string | undefined;
+    search?: string | undefined;
+    account_id?: string | undefined;
+    appKey?: string | undefined;
+    owner?: string | undefined;
+}>;
+export type FindFirstAuthenticationOptions = z.infer<typeof FindFirstAuthenticationSchema>;
+export type FindFirstAuthenticationError = import("../../types/errors").ZapierAuthenticationError | import("../../types/errors").ZapierApiError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierUnknownError;
+export interface FindFirstAuthenticationSdkFunction {
+    findFirstAuthentication: (options?: FindFirstAuthenticationOptions) => Promise<{
+        data: AuthenticationItem | null;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/findFirstAuthentication/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;EAgBwB,CAAC;AAGnE,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAClD,OAAO,6BAA6B,CACrC,CAAC;AAGF,MAAM,MAAM,4BAA4B,GACpC,OAAO,oBAAoB,EAAE,yBAAyB,GACtD,OAAO,oBAAoB,EAAE,cAAc,GAC3C,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,kCAAkC;IACjD,uBAAuB,EAAE,CACvB,OAAO,CAAC,EAAE,8BAA8B,KACrC,OAAO,CAAC;QAAE,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;CACnD"}

package/dist/plugins/findFirstAuthentication/schemas.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { AppKeyPropertySchema } from "../../types/properties";
+// Pure Zod schema - no resolver metadata!
+export const FindFirstAuthenticationSchema = z
+    .object({
+    appKey: AppKeyPropertySchema.optional().describe("App key of authentication to find (e.g., 'SlackCLIAPI')"),
+    search: z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+    account_id: z.string().optional().describe("Filter by account ID"),
+    owner: z.string().optional().describe("Filter by owner"),
+})
+    .describe("Find the first authentication matching the criteria");

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

@@ -0,0 +1,20 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { AuthenticationItem } from "../../types/domain";
+import { FindUniqueAuthenticationSchema, type FindUniqueAuthenticationOptions } from "./schemas";
+import type { ListAuthenticationsPluginProvides } from "../listAuthentications";
+export interface FindUniqueAuthenticationPluginProvides {
+    findUniqueAuthentication: (options?: FindUniqueAuthenticationOptions) => Promise<{
+        data: AuthenticationItem;
+    }>;
+    context: {
+        meta: {
+            findUniqueAuthentication: {
+                inputSchema: typeof FindUniqueAuthenticationSchema;
+            };
+        };
+    };
+}
+export declare const findUniqueAuthenticationPlugin: Plugin<GetSdkType<ListAuthenticationsPluginProvides>, // requires listAuthentications in SDK
+{}, // no context requirements
+FindUniqueAuthenticationPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/findUniqueAuthentication/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,EACL,8BAA8B,EAC9B,KAAK,+BAA+B,EACrC,MAAM,WAAW,CAAC;AAMnB,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAEhF,MAAM,WAAW,sCAAsC;IACrD,wBAAwB,EAAE,CACxB,OAAO,CAAC,EAAE,+BAA+B,KACtC,OAAO,CAAC;QAAE,IAAI,EAAE,kBAAkB,CAAA;KAAE,CAAC,CAAC;IAC3C,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,wBAAwB,EAAE;gBACxB,WAAW,EAAE,OAAO,8BAA8B,CAAC;aACpD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,8BAA8B,EAAE,MAAM,CACjD,UAAU,CAAC,iCAAiC,CAAC,EAAE,sCAAsC;AACrF,EAAE,EAAE,0BAA0B;AAC9B,sCAAsC,CA0CvC,CAAC"}

package/dist/plugins/findUniqueAuthentication/index.js

@@ -0,0 +1,31 @@
+import { FindUniqueAuthenticationSchema, } from "./schemas";
+import { ZapierResourceNotFoundError, ZapierValidationError, } from "../../types/errors";
+import { createFunction } from "../../utils/function-utils";
+export const findUniqueAuthenticationPlugin = ({ sdk }) => {
+    const findUniqueAuthentication = createFunction(async function findUniqueAuthentication(options = {}) {
+        // Use listAuthentications with maxItems 2 to check for uniqueness
+        const authsResponse = await sdk.listAuthentications({
+            ...options,
+            maxItems: 2, // Get up to 2 to check for uniqueness
+        });
+        if (authsResponse.data.length === 0) {
+            throw new ZapierResourceNotFoundError("No authentication found matching the specified criteria", { resourceType: "Authentication" });
+        }
+        if (authsResponse.data.length > 1) {
+            throw new ZapierValidationError("Multiple authentications found matching the specified criteria. Expected exactly one.");
+        }
+        return {
+            data: authsResponse.data[0],
+        };
+    }, FindUniqueAuthenticationSchema);
+    return {
+        findUniqueAuthentication,
+        context: {
+            meta: {
+                findUniqueAuthentication: {
+                    inputSchema: FindUniqueAuthenticationSchema,
+                },
+            },
+        },
+    };
+};

package/dist/plugins/findUniqueAuthentication/index.test.d.ts

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

package/dist/plugins/findUniqueAuthentication/index.test.d.ts.map

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