@zapier/zapier-sdk 0.0.3 → 0.1.1

package/dist/functions/{getApp.js → getApp/index.js}

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getApp = getApp;
-const api_1 = require("../api");
+const api_1 = require("../../api");
+const domain_1 = require("../../types/domain");
 /**
  * Get a specific app by key
  *
@@ -13,17 +14,11 @@ const api_1 = require("../api");
  */
 async function getApp(options) {
     const api = (0, api_1.getOrCreateApiClient)(options);
-    const { key } = options;
-    const app = await api.get(`/api/v4/apps/${key}/`, {
+    const { appKey } = options;
+    const app = await api.get(`/api/v4/apps/${appKey}/`, {
         customErrorHandler: (response) => {
             if (response.status === 404) {
-                const AppNotFoundError = class extends Error {
-                    constructor(appKey) {
-                        super(`App not found: ${appKey}`);
-                        this.name = "AppNotFoundError";
-                    }
-                };
-                return new AppNotFoundError(key);
+                return new domain_1.AppNotFoundError(appKey);
             }
             return undefined;
         },
@@ -39,3 +34,4 @@ async function getApp(options) {
         current_implementation_id: app.current_implementation_id,
     };
 }
+// No registry info here - moved to info.ts for proper tree-shaking

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

@@ -0,0 +1,12 @@
+import { getApp } from "./index";
+export declare const getAppInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        appKey: string;
+    }, {
+        appKey: string;
+    }>;
+    implementation: typeof getApp;
+};

package/dist/functions/getApp/info.js

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

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

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import type { Integration } from "../../types/domain";
+export declare const GetAppSchema: z.ZodObject<{
+    appKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+}, {
+    appKey: string;
+}>;
+export type GetAppOptions = z.infer<typeof GetAppSchema> & {
+    /** 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 GetAppSdkFunction {
+    getApp: (options: GetAppOptions) => Promise<Integration>;
+}

package/dist/functions/getApp/schemas.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetAppSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+// Pure Zod schema - no resolver metadata!
+exports.GetAppSchema = zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.describe("App key or slug to fetch (e.g., google-sheets, slack, github)"),
+})
+    .describe("Get detailed information about a specific app");

package/dist/functions/{listActions.d.ts → listActions/index.d.ts}

@@ -1,8 +1,5 @@
-import type { Action, FunctionConfig } from "../types";
-export interface ListActionsOptions extends FunctionConfig {
-    appKey?: string;
-    type?: string;
-}
+import type { Action } from "../../types/domain";
+import type { ListActionsOptions } from "./schemas";
 /**
  * List available actions with optional filtering
  *
@@ -12,4 +9,4 @@ export interface ListActionsOptions extends FunctionConfig {
  * @param options - Filtering and API configuration options
  * @returns Promise<Action[]> with pagination metadata
  */
-export declare function listActions(options?: ListActionsOptions): Promise<Action[]>;
+export declare function listActions(options?: Partial<ListActionsOptions>): Promise<Action[]>;

package/dist/functions/{listActions.js → listActions/index.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listActions = listActions;
-const api_1 = require("../api");
-const getApp_1 = require("./getApp");
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
 /**
  * List available actions with optional filtering
  *
@@ -19,7 +19,7 @@ async function listActions(options = {}) {
         try {
             // Use the standalone getApp function
             const appData = await (0, getApp_1.getApp)({
-                key: options.appKey,
+                appKey: options.appKey,
                 api,
                 token: options.token,
                 baseUrl: options.baseUrl,
@@ -125,3 +125,4 @@ async function listActions(options = {}) {
     }
     return actions;
 }
+// No registry info here - moved to info.ts for proper tree-shaking

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

@@ -0,0 +1,15 @@
+import { listActions } from "./index";
+export declare const listActionsInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodOptional<import("zod").ZodString>;
+        type: import("zod").ZodOptional<import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        appKey?: string | undefined;
+    }, {
+        type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+        appKey?: string | undefined;
+    }>;
+    implementation: typeof listActions;
+};

package/dist/functions/listActions/info.js

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

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import type { Action } from "../../types/domain";
+export declare const ListActionsSchema: z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>>;
+}, "strip", z.ZodTypeAny, {
+    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+    appKey?: string | undefined;
+}, {
+    type?: "create" | "update" | "search" | "delete" | "read" | "write" | undefined;
+    appKey?: string | undefined;
+}>;
+export type ListActionsOptions = z.infer<typeof ListActionsSchema> & {
+    /** 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 ListActionsSdkFunction {
+    listActions: (options?: Partial<ListActionsOptions>) => Promise<Action[]>;
+}

package/dist/functions/listActions/schemas.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListActionsSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const Action_1 = require("../../schemas/Action");
+// Pure Zod schema - no resolver metadata!
+exports.ListActionsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.optional(),
+    type: properties_1.ActionTypePropertySchema.optional().describe("Filter actions by type"),
+})
+    .describe("List all actions for a specific app"), Action_1.ActionItemSchema);

package/dist/functions/{listApps.d.ts → listApps/index.d.ts}

@@ -1,9 +1,5 @@
-import type { Integration, FunctionConfig } from "../types";
-export interface ListAppsOptions extends FunctionConfig {
-    category?: string;
-    limit?: number;
-    offset?: number;
-}
+import type { Integration } from "../../types/domain";
+import type { ListAppsOptions } from "./schemas";
 /**
  * List available apps with optional filtering
  *

package/dist/functions/{listApps.js → listApps/index.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listApps = listApps;
-const api_1 = require("../api");
+const api_1 = require("../../api");
 /**
  * List available apps with optional filtering
  *

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

@@ -0,0 +1,18 @@
+import { listApps } from "./index";
+export declare const listAppsInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        category: 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, {
+        category?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }, {
+        category?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+    }>;
+    implementation: typeof listApps;
+};

package/dist/functions/listApps/info.js

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

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import type { Integration } from "../../types/domain";
+export declare const ListAppsSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}, {
+    category?: string | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+}>;
+export type ListAppsOptions = z.infer<typeof ListAppsSchema> & {
+    /** 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 ListAppsSdkFunction {
+    listApps: (options?: Partial<ListAppsOptions>) => Promise<Integration[]>;
+}

package/dist/functions/listApps/schemas.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAppsSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+const schema_utils_1 = require("../../schema-utils");
+const App_1 = require("../../schemas/App");
+// Pure Zod schema - no resolver metadata!
+exports.ListAppsSchema = (0, schema_utils_1.withOutputSchema)(zod_1.z
+    .object({
+    category: zod_1.z.string().optional().describe("Filter apps by category"),
+    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("List all available apps with optional filtering"), App_1.AppItemSchema);

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

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

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.listAuths = listAuths;
-const api_1 = require("../api");
-const getApp_1 = require("./getApp");
+exports.listAuthentications = listAuthentications;
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
 /**
  * List available authentications with optional filtering
  *
@@ -12,14 +12,14 @@ const getApp_1 = require("./getApp");
  * @param options - Filtering, pagination, and API configuration options
  * @returns Promise<Authentication[]> with pagination metadata
  */
-async function listAuths(options = {}) {
+async function listAuthentications(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.");
     }
     const api = (0, api_1.getOrCreateApiClient)(options);
     // 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
@@ -27,7 +27,7 @@ async function listAuths(options = {}) {
             try {
                 // Use the standalone getApp function
                 const app = await (0, getApp_1.getApp)({
-                    key: options.appKey,
+                    appKey: options.appKey,
                     api,
                     token: options.token,
                     baseUrl: options.baseUrl,
@@ -52,6 +52,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 +84,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 +109,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,17 +118,17 @@ 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,
         });
         // Filter out auths the user already owns to avoid duplicates
-        const ownedAuthIds = new Set(ownedAuths.map((auth) => auth.id));
-        const additionalAuths = allAuths.filter((auth) => !ownedAuthIds.has(auth.id));
+        const ownedAuthenticationIds = new Set(ownedAuths.map((auth) => auth.id));
+        const additionalAuths = allAuths.filter((auth) => !ownedAuthenticationIds.has(auth.id));
         // Combine and slice to the requested limit
         const combined = [...ownedAuths, ...additionalAuths];
         return combined.slice(0, options.limit);
     }
     // Standard implementation for non-prioritized requests
-    return listAuthsInternal(options);
+    return listAuthenticationsInternal(options);
 }

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

@@ -0,0 +1,30 @@
+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 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,42 @@
+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;
+    /** 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/listAuthentications/schemas.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.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)"),
+    offset: properties_1.OffsetPropertySchema.optional().describe("Number of items to skip for pagination"),
+})
+    .describe("List available authentications with optional filtering"), Auth_1.AuthItemSchema);

package/dist/functions/{listFields.d.ts → listFields/index.d.ts}

@@ -1,18 +1,12 @@
-import type { ActionField, FunctionConfig } from "../types";
-export interface ListFieldsOptions extends FunctionConfig {
-    app: string;
-    action: string;
-    type: string;
-    authId?: number;
-    params?: Record<string, any>;
-}
+import type { ActionField } from "../../types/domain";
+import type { ListFieldsOptions } from "./schemas";
 /**
  * List available fields for 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 details, auth ID, params, and API configuration options
+ * @param options - Action details, authentication ID, params, and API configuration options
  * @returns Promise<ActionField[]>
  */
 export declare function listFields(options: ListFieldsOptions): Promise<ActionField[]>;

package/dist/functions/{listFields.js → listFields/index.js}

@@ -1,27 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listFields = listFields;
-const api_1 = require("../api");
-const getApp_1 = require("./getApp");
+const api_1 = require("../../api");
+const getApp_1 = require("../getApp");
 /**
  * List available fields for 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 details, auth ID, params, and API configuration options
+ * @param options - Action details, authentication ID, params, and API configuration options
  * @returns Promise<ActionField[]>
  */
 async function listFields(options) {
     const api = (0, api_1.getOrCreateApiClient)(options);
-    // Map consistent parameter names to internal API names
-    const { app, action, type, authId, params } = options;
-    const appKey = app;
-    const actionKey = action;
-    const actionType = type;
+    // Extract parameters
+    const { appKey, actionKey, actionType, authenticationId, params } = options;
     // Use the standalone getApp function
     const appData = await (0, getApp_1.getApp)({
-        key: appKey,
+        appKey,
         api,
         token: options.token,
         baseUrl: options.baseUrl,
@@ -37,7 +34,7 @@ async function listFields(options) {
         selected_api: selectedApi,
         action: actionKey,
         type_of: actionType,
-        authentication_id: authId,
+        authentication_id: authenticationId,
         params: params || {},
     };
     const needsData = await api.post("/api/v4/implementations/needs/", needsRequest);
@@ -65,3 +62,4 @@ async function listFields(options) {
         inputFormat: need.input_format,
     }));
 }
+// No registry info here - moved to info.ts for proper tree-shaking

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;
+};