@zapier/zapier-sdk 0.1.0 → 0.2.0

package/dist/api/client.js

@@ -11,7 +11,7 @@ const auth_1 = require("./auth");
 const debug_1 = require("./debug");
 const polling_1 = require("./polling");
 function createZapierApi(options) {
-    const { baseUrl, token, debug = false, fetch: originalFetch = globalThis.fetch, } = options;
+    const { baseUrl, token, getToken, debug = false, fetch: originalFetch = globalThis.fetch, } = options;
     const debugLog = (0, debug_1.createDebugLogger)(debug);
     const fetch = (0, debug_1.createDebugFetch)({ originalFetch, debugLog });
     // Helper to build full URLs
@@ -25,13 +25,23 @@ function createZapierApi(options) {
         return url.toString();
     }
     // Helper to build headers
-    function buildHeaders(options = {}) {
+    async function buildHeaders(options = {}) {
         const headers = {
             ...options.headers,
         };
         // Add auth header if token provided and not explicitly disabled
-        if (token && options.authRequired !== false) {
-            headers.Authorization = (0, auth_1.getAuthorizationHeader)(token);
+        if (options.authRequired !== false) {
+            let resolvedToken = token;
+            // Token resolution precedence: explicit token > getToken() > env var
+            if (!resolvedToken && getToken) {
+                resolvedToken = await getToken();
+            }
+            if (!resolvedToken) {
+                resolvedToken = process.env.ZAPIER_TOKEN;
+            }
+            if (resolvedToken) {
+                headers.Authorization = (0, auth_1.getAuthorizationHeader)(resolvedToken);
+            }
         }
         return headers;
     }
@@ -58,7 +68,7 @@ function createZapierApi(options) {
     // Helper to perform HTTP requests with JSON handling
     async function fetchJson(method, path, data, options = {}) {
         const url = buildUrl(path, options.searchParams);
-        const headers = buildHeaders(options);
+        const headers = await buildHeaders(options);
         // Add Content-Type for JSON requests with body data
         if (data && typeof data === "object") {
             headers["Content-Type"] = "application/json";
@@ -85,7 +95,7 @@ function createZapierApi(options) {
         },
         async poll(path, options = {}) {
             const url = buildUrl(path, options.searchParams);
-            const headers = buildHeaders(options);
+            const headers = await buildHeaders(options);
             return (0, polling_1.pollUntilComplete)({
                 fetch,
                 url,
@@ -98,5 +108,11 @@ function createZapierApi(options) {
                 resultExtractor: options.resultExtractor,
             });
         },
+        requireAuthTo(operation) {
+            // Check if any authentication method is available
+            if (!token && !getToken && !process.env.ZAPIER_TOKEN) {
+                throw new Error(`Authentication token is required to ${operation}. Please provide token in options or set ZAPIER_TOKEN environment variable.`);
+            }
+        },
     };
 }

package/dist/api/index.d.ts

@@ -6,6 +6,7 @@
  * polling, and provides consistent patterns across all services.
  */
 export type { ApiClient, ApiClientOptions, RequestOptions, PollOptions, DebugLogger, Integration, Action, Trigger, Field, Choice, ActionExecutionResult, ActionField, ActionFieldChoice, NeedsRequest, NeedsResponse, Authentication, AuthenticationsResponse, } from "./types";
+import type { ApiClient } from "./types";
 export { isJwt, getAuthorizationHeader } from "./auth";
 export { createDebugLogger, createDebugFetch } from "./debug";
 export { pollUntilComplete } from "./polling";
@@ -20,7 +21,8 @@ export declare function generateRequestId(): string;
 export declare function getOrCreateApiClient(config: {
     baseUrl?: string;
     token?: string;
-    api?: import("./types").ApiClient;
+    getToken?: () => Promise<string | undefined>;
+    api?: ApiClient;
     debug?: boolean;
     fetch?: typeof globalThis.fetch;
-}): import("./types").ApiClient;
+}): ApiClient;

package/dist/api/index.js

@@ -24,6 +24,8 @@ Object.defineProperty(exports, "pollUntilComplete", { enumerable: true, get: fun
 // Re-export the main client factory
 var client_1 = require("./client");
 Object.defineProperty(exports, "createZapierApi", { enumerable: true, get: function () { return client_1.createZapierApi; } });
+// Import for local use
+const client_2 = require("./client");
 // Utility Functions
 function generateRequestId() {
     return Math.random().toString(36).substring(2) + Date.now().toString(36);
@@ -35,16 +37,15 @@ function generateRequestId() {
  * @returns ApiClient instance
  */
 function getOrCreateApiClient(config) {
-    const { baseUrl = "https://zapier.com", token = process.env.ZAPIER_TOKEN, api: providedApi, debug = false, fetch: customFetch, } = config;
+    const { baseUrl = "https://zapier.com", token, getToken, api: providedApi, debug = false, fetch: customFetch, } = config;
     // Use provided API client or create a new one
     if (providedApi) {
         return providedApi;
     }
-    // Import createZapierApi locally to avoid circular imports
-    const { createZapierApi } = require("./client");
-    return createZapierApi({
+    return (0, client_2.createZapierApi)({
         baseUrl,
         token,
+        getToken,
         debug,
         fetch: customFetch,
     });

package/dist/api/types.d.ts

@@ -8,6 +8,7 @@
 export interface ApiClientOptions {
     baseUrl: string;
     token?: string;
+    getToken?: () => Promise<string | undefined>;
     debug?: boolean;
     fetch?: typeof globalThis.fetch;
 }
@@ -17,6 +18,7 @@ export interface ApiClient {
     put: (path: string, data?: any, options?: RequestOptions) => Promise<any>;
     delete: (path: string, options?: RequestOptions) => Promise<any>;
     poll: (path: string, options?: PollOptions) => Promise<any>;
+    requireAuthTo: (operation: string) => void;
 }
 export interface RequestOptions {
     headers?: Record<string, string>;

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

@@ -0,0 +1,12 @@
+import type { Authentication } from "../../types/domain";
+import type { FindFirstAuthenticationOptions } from "./schemas";
+/**
+ * Find the first authentication matching the given criteria
+ *
+ * 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 - Filtering and API configuration options
+ * @returns Promise<Authentication | null> - First matching authentication or null if not found
+ */
+export declare function findFirstAuthentication(options?: Partial<FindFirstAuthenticationOptions>): Promise<Authentication | null>;

package/dist/functions/findFirstAuthentication/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFirstAuthentication = findFirstAuthentication;
+const listAuthentications_1 = require("../listAuthentications");
+/**
+ * Find the first authentication matching the given criteria
+ *
+ * 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 - Filtering and API configuration options
+ * @returns Promise<Authentication | null> - First matching authentication or null if not found
+ */
+async function findFirstAuthentication(options = {}) {
+    // Use listAuthentications with limit 1 to get the first result
+    const auths = await (0, listAuthentications_1.listAuthentications)({
+        ...options,
+        limit: 1,
+    });
+    return auths.length > 0 ? auths[0] : null;
+}

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

@@ -0,0 +1,30 @@
+import { findFirstAuthentication } from "./index";
+export declare const findFirstAuthenticationInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        search: import("zod").ZodOptional<import("zod").ZodString>;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
+        account_id: import("zod").ZodOptional<import("zod").ZodString>;
+        owner: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+        offset: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    implementation: typeof findFirstAuthentication;
+};

package/dist/functions/findFirstAuthentication/info.js

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

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

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { Authentication } 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>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type FindFirstAuthenticationOptions = z.infer<typeof FindFirstAuthenticationSchema> & {
+    /** 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 FindFirstAuthenticationSdkFunction {
+    findFirstAuthentication: (options?: Partial<FindFirstAuthenticationOptions>) => Promise<Authentication | null>;
+}

package/dist/functions/findFirstAuthentication/schemas.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindFirstAuthenticationSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Auth_1 = require("../../schemas/Auth");
+// Pure Zod schema - no resolver metadata!
+exports.FindFirstAuthenticationSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.optional().describe("App slug to get authentications for (e.g., 'slack', 'github')"),
+    search: zod_1.z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+    account_id: zod_1.z.string().optional().describe("Filter by account ID"),
+    owner: zod_1.z.string().optional().describe("Filter by owner"),
+    limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),
+    offset: properties_1.OffsetPropertySchema.optional().describe("Number of items to skip for pagination"),
+})
+    .describe("Find the first authentication matching the criteria"), Auth_1.AuthItemSchema);

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

@@ -0,0 +1,13 @@
+import type { Authentication } from "../../types/domain";
+import type { FindUniqueAuthenticationOptions } from "./schemas";
+/**
+ * Find a unique authentication matching the given criteria
+ *
+ * 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 - Filtering and API configuration options
+ * @returns Promise<Authentication> - The unique matching authentication
+ * @throws Error if no authentication found or multiple authentications found
+ */
+export declare function findUniqueAuthentication(options?: Partial<FindUniqueAuthenticationOptions>): Promise<Authentication>;

package/dist/functions/findUniqueAuthentication/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUniqueAuthentication = findUniqueAuthentication;
+const listAuthentications_1 = require("../listAuthentications");
+/**
+ * Find a unique authentication matching the given criteria
+ *
+ * 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 - Filtering and API configuration options
+ * @returns Promise<Authentication> - The unique matching authentication
+ * @throws Error if no authentication found or multiple authentications found
+ */
+async function findUniqueAuthentication(options = {}) {
+    // Use listAuthentications with a reasonable limit to check for uniqueness
+    const auths = await (0, listAuthentications_1.listAuthentications)({
+        ...options,
+        limit: 2, // Get up to 2 to check for uniqueness
+    });
+    if (auths.length === 0) {
+        throw new Error("No authentication found matching the specified criteria");
+    }
+    if (auths.length > 1) {
+        throw new Error("Multiple authentications found matching the specified criteria. Expected exactly one.");
+    }
+    return auths[0];
+}

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

@@ -0,0 +1,30 @@
+import { findUniqueAuthentication } from "./index";
+export declare const findUniqueAuthenticationInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        search: import("zod").ZodOptional<import("zod").ZodString>;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
+        account_id: import("zod").ZodOptional<import("zod").ZodString>;
+        owner: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+        offset: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }, {
+        search?: string | undefined;
+        appKey?: string | undefined;
+        title?: string | undefined;
+        account_id?: string | undefined;
+        owner?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    implementation: typeof findUniqueAuthentication;
+};

package/dist/functions/findUniqueAuthentication/info.js

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

package/dist/functions/{listAuths → findUniqueAuthentication}/schemas.d.ts

@@ -1,25 +1,31 @@
 import { z } from "zod";
 import type { Authentication } from "../../types/domain";
-export declare const ListAuthsSchema: z.ZodObject<{
+export declare const FindUniqueAuthenticationSchema: 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>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
     appKey?: string | undefined;
+    title?: string | undefined;
     account_id?: string | undefined;
     owner?: string | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
 }, {
+    search?: string | undefined;
     appKey?: string | undefined;
+    title?: string | undefined;
     account_id?: string | undefined;
     owner?: string | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
 }>;
-export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
+export type FindUniqueAuthenticationOptions = z.infer<typeof FindUniqueAuthenticationSchema> & {
     /** Base URL for Zapier API */
     baseUrl?: string;
     /** Authentication token */
@@ -31,6 +37,6 @@ export type ListAuthsOptions = z.infer<typeof ListAuthsSchema> & {
     /** Custom fetch implementation */
     fetch?: typeof globalThis.fetch;
 };
-export interface ListAuthsSdkFunction {
-    listAuths: (options?: Partial<ListAuthsOptions>) => Promise<Authentication[]>;
+export interface FindUniqueAuthenticationSdkFunction {
+    findUniqueAuthentication: (options?: Partial<FindUniqueAuthenticationOptions>) => Promise<Authentication>;
 }

package/dist/functions/findUniqueAuthentication/schemas.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindUniqueAuthenticationSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Auth_1 = require("../../schemas/Auth");
+// Pure Zod schema - no resolver metadata!
+exports.FindUniqueAuthenticationSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.optional().describe("App slug to get authentications for (e.g., 'slack', 'github')"),
+    search: zod_1.z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
+    account_id: zod_1.z.string().optional().describe("Filter by account ID"),
+    owner: zod_1.z.string().optional().describe("Filter by owner"),
+    limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),
+    offset: properties_1.OffsetPropertySchema.optional().describe("Number of items to skip for pagination"),
+})
+    .describe("Find a unique authentication matching the criteria"), Auth_1.AuthItemSchema);

package/dist/functions/{listAuths → listAuthentications}/index.d.ts

@@ -1,5 +1,5 @@
 import type { Authentication } from "../../types/domain";
-import type { ListAuthsOptions } from "./schemas";
+import type { ListAuthenticationsOptions } from "./schemas";
 /**
  * List available authentications with optional filtering
  *
@@ -9,4 +9,4 @@ import type { ListAuthsOptions } from "./schemas";
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-export declare function listAuths(options?: Partial<ListAuthsOptions>): Promise<Authentication[]>;
+export declare function listAuthentications(options?: Partial<ListAuthenticationsOptions>): Promise<Authentication[]>;

package/dist/functions/{listAuths → listAuthentications}/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listAuths = listAuths;
+exports.listAuthentications = listAuthentications;
 const api_1 = require("../../api");
 const getApp_1 = require("../getApp");
 /**
@@ -12,14 +12,11 @@ const getApp_1 = require("../getApp");
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-async function listAuths(options = {}) {
-    const { token } = options;
-    if (!token && !process.env.ZAPIER_TOKEN) {
-        throw new Error("Authentication token is required to list authentications. Please provide token in options or set ZAPIER_TOKEN environment variable.");
-    }
+async function listAuthentications(options = {}) {
     const api = (0, api_1.getOrCreateApiClient)(options);
+    api.requireAuthTo("list authentications");
     // Local function to handle the actual API fetching
-    const listAuthsInternal = async (options = {}) => {
+    const listAuthenticationsInternal = async (options = {}) => {
         // Build search parameters
         const searchParams = {};
         // Handle appKey filtering by getting the selected_api first
@@ -52,6 +49,13 @@ async function listAuths(options = {}) {
             }
         }
         // Add other query parameters if provided
+        // Use title as search if no explicit search provided
+        if (options.search) {
+            searchParams.search = options.search;
+        }
+        else if (options.title) {
+            searchParams.search = options.title;
+        }
         if (options.account_id) {
             searchParams.account_id = options.account_id;
         }
@@ -77,7 +81,16 @@ async function listAuths(options = {}) {
             },
         });
         // Transform API response
-        const auths = data.results || [];
+        let auths = data.results || [];
+        // Coerce title from label if title is missing (API cleanup)
+        auths = auths.map((auth) => ({
+            ...auth,
+            title: auth.title || auth.label || undefined,
+        }));
+        // Filter by exact title match if specified
+        if (options.title) {
+            auths = auths.filter((auth) => auth.title === options.title);
+        }
         // Add pagination metadata to the response
         if (auths.length > 0) {
             auths.__pagination = {
@@ -93,7 +106,7 @@ async function listAuths(options = {}) {
     // If a limit is provided and no specific owner filter, prioritize owned auths
     if (options.limit && options.owner === undefined) {
         // First get owned auths
-        const ownedAuths = await listAuthsInternal({
+        const ownedAuths = await listAuthenticationsInternal({
             ...options,
             owner: "me",
         });
@@ -102,7 +115,7 @@ async function listAuths(options = {}) {
             return ownedAuths.slice(0, options.limit);
         }
         // Get all auths up to the original limit to fill remaining slots
-        const allAuths = await listAuthsInternal({
+        const allAuths = await listAuthenticationsInternal({
             ...options,
             owner: undefined,
         });
@@ -114,5 +127,5 @@ async function listAuths(options = {}) {
         return combined.slice(0, options.limit);
     }
     // Standard implementation for non-prioritized requests
-    return listAuthsInternal(options);
+    return listAuthenticationsInternal(options);
 }

package/dist/functions/{listAuths → listAuthentications}/info.d.ts

@@ -1,24 +1,30 @@
-import { listAuths } from "./index";
-export declare const listAuthsInfo: {
+import { listAuthentications } from "./index";
+export declare const listAuthenticationsInfo: {
     name: string;
     inputSchema: import("zod").ZodObject<{
         appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        search: import("zod").ZodOptional<import("zod").ZodString>;
+        title: import("zod").ZodOptional<import("zod").ZodString>;
         account_id: import("zod").ZodOptional<import("zod").ZodString>;
         owner: import("zod").ZodOptional<import("zod").ZodString>;
         limit: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
         offset: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
     }, "strip", import("zod").ZodTypeAny, {
+        search?: string | undefined;
         appKey?: string | undefined;
+        title?: string | undefined;
         account_id?: string | undefined;
         owner?: string | undefined;
         limit?: number | undefined;
         offset?: number | undefined;
     }, {
+        search?: string | undefined;
         appKey?: string | undefined;
+        title?: string | undefined;
         account_id?: string | undefined;
         owner?: string | undefined;
         limit?: number | undefined;
         offset?: number | undefined;
     }>;
-    implementation: typeof listAuths;
+    implementation: typeof listAuthentications;
 };

package/dist/functions/listAuthentications/info.js

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

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import type { Authentication } from "../../types/domain";
+export declare const ListAuthenticationsSchema: 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>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    search?: string | undefined;
+    appKey?: string | undefined;
+    title?: string | undefined;
+    account_id?: string | undefined;
+    owner?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListAuthenticationsOptions = z.infer<typeof ListAuthenticationsSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Function to dynamically resolve authentication token */
+    getToken?: () => Promise<string | undefined>;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface ListAuthenticationsSdkFunction {
+    listAuthentications: (options?: Partial<ListAuthenticationsOptions>) => Promise<Authentication[]>;
+}

package/dist/functions/{listAuths → listAuthentications}/schemas.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListAuthsSchema = void 0;
+exports.ListAuthenticationsSchema = void 0;
 const zod_1 = require("zod");
 const properties_1 = require("../../types/properties");
 const schema_utils_1 = require("../../schema-utils");
 const Auth_1 = require("../../schemas/Auth");
 // Pure Zod schema - no resolver metadata!
-exports.ListAuthsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+exports.ListAuthenticationsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
     .object({
     appKey: properties_1.AppKeyPropertySchema.optional().describe("App slug to get authentications for (e.g., 'slack', 'github')"),
+    search: zod_1.z
+        .string()
+        .optional()
+        .describe("Search term to filter authentications by title"),
+    title: zod_1.z
+        .string()
+        .optional()
+        .describe("Filter authentications by exact title match"),
     account_id: zod_1.z.string().optional().describe("Filter by account ID"),
     owner: zod_1.z.string().optional().describe("Filter by owner"),
     limit: properties_1.LimitPropertySchema.optional().describe("Maximum number of items to return (1-200)"),