@zapier/zapier-sdk 0.0.3 → 0.1.1

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/findUniqueAuthentication/schemas.d.ts

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import type { Authentication } from "../../types/domain";
+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 FindUniqueAuthenticationOptions = z.infer<typeof FindUniqueAuthenticationSchema> & {
+    /** 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 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/{generateTypes.d.ts → generateTypes/index.d.ts}

@@ -1,16 +1,11 @@
-import type { FunctionConfig } from "../types";
-export interface GenerateTypesOptions extends FunctionConfig {
-    appKey: string;
-    authId?: number;
-    output?: string;
-}
+import type { GenerateTypesOptions } from "./schemas";
 /**
  * Generate TypeScript types for a specific app
  *
  * 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 - App key, auth ID, output path, and API configuration options
+ * @param options - App key, authentication ID, output path, and API configuration options
  * @returns Promise<string> - Generated TypeScript code
  */
 export declare function generateTypes(options: GenerateTypesOptions): Promise<string>;

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

@@ -34,19 +34,19 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTypes = generateTypes;
-const listActions_1 = require("./listActions");
-const listFields_1 = require("./listFields");
+const listActions_1 = require("../listActions");
+const listFields_1 = require("../listFields");
 /**
  * Generate TypeScript types for a specific app
  *
  * 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 - App key, auth ID, output path, and API configuration options
+ * @param options - App key, authentication ID, output path, and API configuration options
  * @returns Promise<string> - Generated TypeScript code
  */
 async function generateTypes(options) {
-    const { appKey, authId, output = `./types/${appKey}.d.ts` } = options;
+    const { appKey, authenticationId, output = `./types/${appKey}.d.ts`, } = options;
     // Parse app identifier (support app@version format)
     const { app, version } = parseAppIdentifier(appKey);
     // Fetch all actions for the app
@@ -66,15 +66,15 @@ async function generateTypes(options) {
     }
     // Fetch input fields for each action
     const actionsWithFields = [];
-    if (authId) {
+    if (authenticationId) {
         for (const action of actions) {
             try {
                 const fields = await (0, listFields_1.listFields)({
                     ...options,
-                    app: action.appKey,
-                    action: action.key,
-                    type: action.type,
-                    authId: authId,
+                    appKey: action.appKey,
+                    actionKey: action.key,
+                    actionType: action.type,
+                    authenticationId: authenticationId,
                 });
                 actionsWithFields.push({ ...action, inputFields: fields });
             }
@@ -132,8 +132,15 @@ ${versionComment}
  * Generated on: ${new Date().toISOString()}
  * 
  * Usage:
- *   import type { ${appName}Actions } from './path/to/this/file'
- *   const sdk: ActionsSdk & { actions: ${appName}Actions } = createActionsSdk(...)
+ *   import type { ${appName}Sdk } from './path/to/this/file'
+ *   const sdk = createZapierSdk() as unknown as ${appName}Sdk
+ *   
+ *   // Direct usage (per-call auth):
+ *   await sdk.apps.${appKey}.search.user_by_email({ authenticationId: 123, inputs: { email } })
+ *   
+ *   // Factory usage (pinned auth):
+ *   const my${appName} = sdk.apps.${appKey}({ authenticationId: 123 })
+ *   await my${appName}.search.user_by_email({ inputs: { email } })
  */
 
 import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
@@ -176,15 +183,24 @@ import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapi
         });
         output += `}\n\n`;
     });
-    // Generate the main app actions interface
-    output += `export interface ${appName}Actions {\n`;
-    output += `  run: {\n`;
-    output += `    ${appKey}: {\n`;
+    // Generate the main app SDK interface with factory pattern support
+    // Generate the app proxy interface (actions grouped by type)
+    output += `interface ${appName}AppProxy {\n`;
     Object.keys(actionsByType).forEach((actionType) => {
         const typeName = `${appName}${capitalize(actionType)}Actions`;
-        output += `      ${actionType}: ${typeName}\n`;
+        output += `  ${actionType}: ${typeName}\n`;
     });
-    output += `    }\n`;
+    output += `}\n\n`;
+    // Generate the factory function interface
+    output += `interface ${appName}AppFactory {\n`;
+    output += `  (options: { authenticationId: number }): ${appName}AppProxy\n`;
+    output += `}\n\n`;
+    // Combine factory and direct access
+    output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy\n\n`;
+    // Generate the main SDK interface
+    output += `export interface ${appName}Sdk {\n`;
+    output += `  apps: {\n`;
+    output += `    ${appKey}: ${appName}AppWithFactory\n`;
     output += `  }\n`;
     output += `}\n`;
     return output;
@@ -205,11 +221,19 @@ ${versionComment}
 
 import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
 
-export interface ${appName}Actions {
-  run: {
-    ${appKey}: {
-      // No actions available
-    }
+interface ${appName}AppProxy {
+  // No actions available
+}
+
+interface ${appName}AppFactory {
+  (options: { authenticationId: number }): ${appName}AppProxy
+}
+
+type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
+
+export interface ${appName}Sdk {
+  apps: {
+    ${appKey}: ${appName}AppWithFactory
   }
 }
 `;
@@ -219,11 +243,21 @@ function capitalize(str) {
 }
 function sanitizeActionName(actionKey) {
     // Ensure the action name is a valid TypeScript identifier
-    return actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    // If it starts with a number, prepend an underscore
+    if (/^[0-9]/.test(sanitized)) {
+        sanitized = "_" + sanitized;
+    }
+    return sanitized;
 }
 function sanitizeFieldName(fieldKey) {
     // Ensure the field name is a valid TypeScript identifier
-    return fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+    // If it starts with a number, prepend an underscore
+    if (/^[0-9]/.test(sanitized)) {
+        sanitized = "_" + sanitized;
+    }
+    return sanitized;
 }
 function escapeComment(comment) {
     // Escape comment text to prevent breaking the JSDoc comment

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

@@ -0,0 +1,21 @@
+import { generateTypes } from "./index";
+export declare const generateTypesInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodString;
+        authenticationId: import("zod").ZodOptional<import("zod").ZodNumber>;
+        output: import("zod").ZodOptional<import("zod").ZodString>;
+        debug: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        debug: boolean;
+        appKey: string;
+        authenticationId?: number | undefined;
+        output?: string | undefined;
+    }, {
+        appKey: string;
+        debug?: boolean | undefined;
+        authenticationId?: number | undefined;
+        output?: string | undefined;
+    }>;
+    implementation: typeof generateTypes;
+};

package/dist/functions/generateTypes/info.js

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

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const GenerateTypesSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodString>;
+    debug: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    debug: boolean;
+    appKey: string;
+    authenticationId?: number | undefined;
+    output?: string | undefined;
+}, {
+    appKey: string;
+    debug?: boolean | undefined;
+    authenticationId?: number | undefined;
+    output?: string | undefined;
+}>;
+export type GenerateTypesOptions = z.infer<typeof GenerateTypesSchema> & {
+    /** Base URL for Zapier API */
+    baseUrl?: string;
+    /** Authentication token */
+    token?: string;
+    /** Optional pre-instantiated API client */
+    api?: any;
+    /** Custom fetch implementation */
+    fetch?: typeof globalThis.fetch;
+};
+export interface GenerateTypesSdkFunction {
+    generateTypes: (options: GenerateTypesOptions) => Promise<string>;
+}

package/dist/functions/generateTypes/schemas.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateTypesSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+// Pure Zod schema - no resolver metadata!
+exports.GenerateTypesSchema = zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema.describe("App key to generate SDK code for"),
+    authenticationId: properties_1.AuthenticationIdPropertySchema.optional(),
+    output: properties_1.OutputPropertySchema.optional().describe("Output file path (defaults to generated/<appKey>.ts)"),
+    debug: properties_1.DebugPropertySchema.describe("Enable debug logging during generation"),
+})
+    .describe("Generate TypeScript SDK code for a specific app");

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

@@ -1,9 +1,5 @@
-import type { Action, FunctionConfig } from "../types";
-export interface GetActionOptions extends FunctionConfig {
-    app: string;
-    action: string;
-    type: string;
-}
+import type { Action } from "../../types/domain";
+import type { GetActionOptions } from "./schemas";
 /**
  * Get a specific action by app, action key, and type
  *

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAction = getAction;
-const listActions_1 = require("./listActions");
+const listActions_1 = require("../listActions");
 /**
  * Get a specific action by app, action key, and type
  *
@@ -12,14 +12,15 @@ const listActions_1 = require("./listActions");
  * @returns Promise<Action>
  */
 async function getAction(options) {
-    const { app, action: actionKey, type } = options;
+    const { appKey, actionKey, actionType } = options;
     const actions = await (0, listActions_1.listActions)({
         ...options,
-        appKey: app,
+        appKey: appKey,
     });
-    const action = actions.find((a) => a.key === actionKey && a.type === type);
+    const action = actions.find((a) => a.key === actionKey && a.type === actionType);
     if (!action) {
-        throw new Error(`Action not found: ${actionKey} with type ${type}`);
+        throw new Error(`Action not found: ${actionKey} with type ${actionType}`);
     }
     return action;
 }
+// No registry info here - moved to info.ts for proper tree-shaking

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

@@ -0,0 +1,18 @@
+import { getAction } from "./index";
+export declare const getActionInfo: {
+    name: string;
+    inputSchema: import("zod").ZodObject<{
+        appKey: import("zod").ZodString;
+        actionType: import("zod").ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+        actionKey: import("zod").ZodString;
+    }, "strip", import("zod").ZodTypeAny, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+    }, {
+        appKey: string;
+        actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+        actionKey: string;
+    }>;
+    implementation: typeof getAction;
+};

package/dist/functions/getAction/info.js

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

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import type { Action } from "../../types/domain";
+export declare const GetActionSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "write", "search", "create", "update", "delete"]>;
+    actionKey: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+}, {
+    appKey: string;
+    actionType: "create" | "update" | "search" | "delete" | "read" | "write";
+    actionKey: string;
+}>;
+export type GetActionOptions = z.infer<typeof GetActionSchema> & {
+    /** 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 GetActionSdkFunction {
+    getAction: (options: GetActionOptions) => Promise<Action>;
+}

package/dist/functions/getAction/schemas.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetActionSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+// Pure Zod schema - no resolver metadata!
+exports.GetActionSchema = zod_1.z
+    .object({
+    appKey: properties_1.AppKeyPropertySchema,
+    actionType: properties_1.ActionTypePropertySchema,
+    actionKey: properties_1.ActionKeyPropertySchema,
+})
+    .describe("Get detailed information about a specific action");

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

@@ -1,7 +1,5 @@
-import type { Integration, FunctionConfig } from "../types";
-export interface GetAppOptions extends FunctionConfig {
-    key: string;
-}
+import type { Integration } from "../../types/domain";
+import type { GetAppOptions } from "./schemas";
 /**
  * Get a specific app by key
  *