@zapier/zapier-sdk 0.0.2 → 0.1.0

package/dist/functions/bundleCode/schemas.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundleCodeSchema = void 0;
+const zod_1 = require("zod");
+const properties_1 = require("../../types/properties");
+// Pure Zod schema - no resolver metadata!
+exports.BundleCodeSchema = zod_1.z
+    .object({
+    input: zod_1.z.string().min(1).describe("Input TypeScript file path to bundle"),
+    output: properties_1.OutputPropertySchema.optional().describe("Output file path (defaults to input with .js extension)"),
+    string: zod_1.z
+        .boolean()
+        .default(false)
+        .describe("Return bundled code as string instead of writing to file"),
+    minify: zod_1.z.boolean().default(false).describe("Minify the bundled output"),
+    target: zod_1.z.string().default("es2017").describe("ECMAScript target version"),
+    cjs: zod_1.z
+        .boolean()
+        .default(false)
+        .describe("Output CommonJS format instead of ESM"),
+})
+    .describe("Bundle TypeScript code into executable JavaScript");

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

@@ -0,0 +1,11 @@
+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, 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/index.js

@@ -0,0 +1,305 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypes = generateTypes;
+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, authentication ID, output path, and API configuration options
+ * @returns Promise<string> - Generated TypeScript code
+ */
+async function generateTypes(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
+    const actions = await (0, listActions_1.listActions)({
+        ...options,
+        appKey: app,
+    });
+    if (actions.length === 0) {
+        const typeDefinitions = generateEmptyTypesFile(app, version);
+        if (output) {
+            const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+            const path = await Promise.resolve().then(() => __importStar(require("path")));
+            fs.mkdirSync(path.dirname(output), { recursive: true });
+            fs.writeFileSync(output, typeDefinitions, "utf8");
+        }
+        return typeDefinitions;
+    }
+    // Fetch input fields for each action
+    const actionsWithFields = [];
+    if (authenticationId) {
+        for (const action of actions) {
+            try {
+                const fields = await (0, listFields_1.listFields)({
+                    ...options,
+                    appKey: action.appKey,
+                    actionKey: action.key,
+                    actionType: action.type,
+                    authenticationId: authenticationId,
+                });
+                actionsWithFields.push({ ...action, inputFields: fields });
+            }
+            catch {
+                // If we can't get fields for an action, include it without fields
+                actionsWithFields.push({ ...action, inputFields: [] });
+            }
+        }
+    }
+    else {
+        // Convert actions to have empty input fields (will generate generic types)
+        actions.forEach((action) => {
+            actionsWithFields.push({ ...action, inputFields: [] });
+        });
+    }
+    // Generate TypeScript types
+    const typeDefinitions = generateTypeDefinitions(app, actionsWithFields, version);
+    // Write to file if output path specified
+    if (output) {
+        const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+        const path = await Promise.resolve().then(() => __importStar(require("path")));
+        fs.mkdirSync(path.dirname(output), { recursive: true });
+        fs.writeFileSync(output, typeDefinitions, "utf8");
+    }
+    return typeDefinitions;
+}
+function parseAppIdentifier(identifier) {
+    const parts = identifier.split("@");
+    return {
+        app: parts[0],
+        version: parts[1],
+    };
+}
+function generateTypeDefinitions(appKey, actions, version) {
+    // Handle empty actions
+    if (actions.length === 0) {
+        return generateEmptyTypesFile(appKey, version);
+    }
+    // Group actions by type
+    const actionsByType = actions.reduce((acc, action) => {
+        if (!acc[action.type]) {
+            acc[action.type] = [];
+        }
+        acc[action.type].push(action);
+        return acc;
+    }, {});
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    let output = `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * Usage:
+ *   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'
+
+`;
+    // Generate input types for each action
+    actions.forEach((action) => {
+        if (action.inputFields.length > 0) {
+            const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+            output += `interface ${inputTypeName} {\n`;
+            action.inputFields.forEach((field) => {
+                const isOptional = !field.required;
+                const fieldType = mapFieldTypeToTypeScript(field);
+                const description = field.helpText
+                    ? `  /** ${escapeComment(field.helpText)} */\n`
+                    : "";
+                output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}\n`;
+            });
+            output += `}\n\n`;
+        }
+    });
+    // Generate action type interfaces for each action type
+    Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+        const typeName = `${appName}${capitalize(actionType)}Actions`;
+        output += `interface ${typeName} {\n`;
+        typeActions.forEach((action) => {
+            const actionName = sanitizeActionName(action.key);
+            const description = action.description
+                ? `  /** ${escapeComment(action.description)} */\n`
+                : "";
+            // Generate type-safe action method signature
+            if (action.inputFields.length > 0) {
+                const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(sanitizeActionName(action.key))}Inputs`;
+                output += `${description}  ${actionName}: (options: { inputs: ${inputTypeName} } & Omit<ActionExecutionOptions, 'inputs'>) => Promise<ActionExecutionResult>\n`;
+            }
+            else {
+                // No specific input fields available - use generic Record<string, any> for inputs
+                output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>\n`;
+            }
+        });
+        output += `}\n\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 += `}\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;
+}
+function generateEmptyTypesFile(appKey, version) {
+    const appName = capitalize(appKey);
+    const versionComment = version
+        ? ` * Generated for ${appKey}@${version}`
+        : ` * Generated for ${appKey}`;
+    return `/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Auto-generated TypeScript types for Zapier ${appKey} actions
+${versionComment}
+ * Generated on: ${new Date().toISOString()}
+ * 
+ * No actions found for this app.
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+
+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
+  }
+}
+`;
+}
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1).replace(/[-_]/g, "");
+}
+function sanitizeActionName(actionKey) {
+    // Ensure the action name is a valid TypeScript identifier
+    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
+    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
+    return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+}
+function mapFieldTypeToTypeScript(field) {
+    // Handle choices (enum-like fields)
+    if (field.choices && field.choices.length > 0) {
+        const choiceValues = field.choices
+            .filter((choice) => choice.value !== undefined &&
+            choice.value !== null &&
+            choice.value !== "")
+            .map((choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value);
+        if (choiceValues.length > 0) {
+            return choiceValues.join(" | ");
+        }
+        // If all choices were filtered out, fall through to default type handling
+    }
+    // Map Zapier field types to TypeScript types
+    switch (field.type?.toLowerCase()) {
+        case "string":
+        case "text":
+        case "email":
+        case "url":
+        case "password":
+            return "string";
+        case "integer":
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "datetime":
+        case "date":
+            return "string"; // ISO date strings
+        case "file":
+            return "string"; // File URL or content
+        case "array":
+            return "any[]";
+        case "object":
+            return "Record<string, any>";
+        default:
+            // Default to string for unknown types, with union for common cases
+            return "string | number | boolean";
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { Action } from "../../types/domain";
+import type { GetActionOptions } from "./schemas";
+/**
+ * Get a specific action by app, action key, and type
+ *
+ * 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, action key, type, and API configuration options
+ * @returns Promise<Action>
+ */
+export declare function getAction(options: GetActionOptions): Promise<Action>;

package/dist/functions/getAction/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAction = getAction;
+const listActions_1 = require("../listActions");
+/**
+ * Get a specific action by app, action key, and type
+ *
+ * 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, action key, type, and API configuration options
+ * @returns Promise<Action>
+ */
+async function getAction(options) {
+    const { appKey, actionKey, actionType } = options;
+    const actions = await (0, listActions_1.listActions)({
+        ...options,
+        appKey: appKey,
+    });
+    const action = actions.find((a) => a.key === actionKey && a.type === actionType);
+    if (!action) {
+        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/index.d.ts

@@ -0,0 +1,12 @@
+import type { Integration } from "../../types/domain";
+import type { GetAppOptions } from "./schemas";
+/**
+ * Get a specific app by key
+ *
+ * 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 and API configuration options
+ * @returns Promise<Integration>
+ */
+export declare function getApp(options: GetAppOptions): Promise<Integration>;

package/dist/functions/getApp/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApp = getApp;
+const api_1 = require("../../api");
+const domain_1 = require("../../types/domain");
+/**
+ * Get a specific app by key
+ *
+ * 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 and API configuration options
+ * @returns Promise<Integration>
+ */
+async function getApp(options) {
+    const api = (0, api_1.getOrCreateApiClient)(options);
+    const { appKey } = options;
+    const app = await api.get(`/api/v4/apps/${appKey}/`, {
+        customErrorHandler: (response) => {
+            if (response.status === 404) {
+                return new domain_1.AppNotFoundError(appKey);
+            }
+            return undefined;
+        },
+    });
+    return {
+        key: app.slug,
+        name: app.name,
+        description: app.description,
+        version: "1.0.0",
+        category: app.category?.name,
+        actions: [],
+        triggers: [],
+        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/index.d.ts

@@ -0,0 +1,12 @@
+import type { Action } from "../../types/domain";
+import type { ListActionsOptions } from "./schemas";
+/**
+ * List available actions with optional filtering
+ *
+ * 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<Action[]> with pagination metadata
+ */
+export declare function listActions(options?: Partial<ListActionsOptions>): Promise<Action[]>;