@zapier/zapier-sdk 0.0.3 → 0.1.1

package/dist/resolvers/index.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputsResolver = exports.authenticationIdResolver = exports.actionKeyResolver = exports.actionTypeResolver = exports.appKeyResolver = exports.resolverRegistry = void 0;
+exports.getResolver = getResolver;
+exports.getResolversForMissingParams = getResolversForMissingParams;
+exports.hasResolver = hasResolver;
+exports.getResolvableParams = getResolvableParams;
+exports.getResolutionOrder = getResolutionOrder;
+exports.getResolutionOrderForParams = getResolutionOrderForParams;
+const appKey_1 = require("./appKey");
+const actionType_1 = require("./actionType");
+const actionKey_1 = require("./actionKey");
+const authenticationId_1 = require("./authenticationId");
+const inputs_1 = require("./inputs");
+// Centralized resolver registry
+exports.resolverRegistry = {
+    appKey: appKey_1.appKeyResolver,
+    actionType: actionType_1.actionTypeResolver,
+    actionKey: actionKey_1.actionKeyResolver,
+    authenticationId: authenticationId_1.authenticationIdResolver,
+    inputs: inputs_1.inputsResolver,
+};
+// Utility functions for working with resolvers
+/**
+ * Get a resolver by name
+ */
+function getResolver(name) {
+    return exports.resolverRegistry[name];
+}
+/**
+ * Get all resolvers for a list of missing parameters
+ */
+function getResolversForMissingParams(missingParams) {
+    const resolvers = {};
+    for (const param of missingParams) {
+        const resolver = exports.resolverRegistry[param];
+        if (resolver) {
+            resolvers[param] = resolver;
+        }
+    }
+    return resolvers;
+}
+/**
+ * Check if a parameter has a resolver
+ */
+function hasResolver(paramName) {
+    return paramName in exports.resolverRegistry;
+}
+/**
+ * Get all parameter names that have resolvers
+ */
+function getResolvableParams() {
+    return Object.keys(exports.resolverRegistry);
+}
+/**
+ * Resolve dependency chain for a parameter
+ * Returns parameters in the order they need to be resolved
+ */
+function getResolutionOrder(paramName, resolved = new Set()) {
+    const resolver = getResolver(paramName);
+    if (!resolver || resolver.type === "static") {
+        return [paramName];
+    }
+    const order = [];
+    if ("depends" in resolver && resolver.depends) {
+        for (const dependency of resolver.depends) {
+            if (!resolved.has(dependency)) {
+                order.push(...getResolutionOrder(dependency, resolved));
+                resolved.add(dependency);
+            }
+        }
+    }
+    if (!resolved.has(paramName)) {
+        order.push(paramName);
+        resolved.add(paramName);
+    }
+    return order;
+}
+/**
+ * Get resolution order for multiple parameters
+ */
+function getResolutionOrderForParams(paramNames) {
+    const resolved = new Set();
+    const order = [];
+    for (const paramName of paramNames) {
+        const paramOrder = getResolutionOrder(paramName, resolved);
+        for (const param of paramOrder) {
+            if (!order.includes(param)) {
+                order.push(param);
+            }
+        }
+    }
+    return order;
+}
+// Re-export individual resolvers for direct access if needed
+var appKey_2 = require("./appKey");
+Object.defineProperty(exports, "appKeyResolver", { enumerable: true, get: function () { return appKey_2.appKeyResolver; } });
+var actionType_2 = require("./actionType");
+Object.defineProperty(exports, "actionTypeResolver", { enumerable: true, get: function () { return actionType_2.actionTypeResolver; } });
+var actionKey_2 = require("./actionKey");
+Object.defineProperty(exports, "actionKeyResolver", { enumerable: true, get: function () { return actionKey_2.actionKeyResolver; } });
+var authenticationId_2 = require("./authenticationId");
+Object.defineProperty(exports, "authenticationIdResolver", { enumerable: true, get: function () { return authenticationId_2.authenticationIdResolver; } });
+var inputs_2 = require("./inputs");
+Object.defineProperty(exports, "inputsResolver", { enumerable: true, get: function () { return inputs_2.inputsResolver; } });

package/dist/resolvers/inputs.d.ts

@@ -0,0 +1,7 @@
+import type { ZapierSdk } from "../types/sdk";
+export interface InputsResolver {
+    type: "fields";
+    depends: readonly string[];
+    fetch: (sdk: ZapierSdk, resolvedParams: Record<string, any>) => Promise<any[]>;
+}
+export declare const inputsResolver: InputsResolver;

package/dist/resolvers/inputs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputsResolver = void 0;
+exports.inputsResolver = {
+    type: "fields",
+    depends: ["appKey", "actionKey", "actionType", "authenticationId"],
+    fetch: async (sdk, resolvedParams) => {
+        return await sdk.listFields({
+            appKey: resolvedParams.appKey,
+            actionKey: resolvedParams.actionKey,
+            actionType: resolvedParams.actionType,
+            authenticationId: resolvedParams.authenticationId,
+        });
+    },
+};

package/dist/schema-utils.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export interface FormattedItem {
+    title: string;
+    subtitle?: string;
+    details: Array<{
+        text: string;
+        style: "normal" | "dim" | "accent" | "warning" | "success";
+    }>;
+}
+export interface FormatMetadata {
+    format: (item: any) => FormattedItem;
+}
+export declare function withFormatter<T extends z.ZodType>(schema: T, formatMeta: FormatMetadata): T;
+export declare function getFormatMetadata(schema: z.ZodType): FormatMetadata | undefined;
+export declare function withOutputSchema<T extends z.ZodType>(inputSchema: T, outputSchema: z.ZodType): T;
+export declare function getOutputSchema(inputSchema: z.ZodType): z.ZodType | undefined;
+export interface StaticResolver {
+    type: "static";
+    inputType?: "text" | "password" | "email";
+    placeholder?: string;
+}
+export interface DynamicResolver {
+    type: "dynamic";
+    fetch: (sdk: any, resolvedParams: any) => Promise<any[]>;
+    prompt: (items: any[], params: any) => any;
+    depends?: string[];
+}
+export interface FieldsResolver {
+    type: "fields";
+    fetch: (sdk: any, resolvedParams: any) => Promise<any[]>;
+    depends?: string[];
+}
+export type ResolverMetadata = StaticResolver | DynamicResolver | FieldsResolver;
+export interface ResolverConfig {
+    resolver: ResolverMetadata;
+}
+export declare function withResolver<T extends z.ZodType>(schema: T, config: ResolverConfig): T;
+export declare function getSchemaDescription(schema: z.ZodSchema): string | undefined;
+export declare function getFieldDescriptions(schema: z.ZodObject<any>): Record<string, string>;
+export interface PositionalMetadata {
+    positional: true;
+}
+export declare function withPositional<T extends z.ZodType>(schema: T): T;
+export declare function isPositional(schema: z.ZodType): boolean;

package/dist/schema-utils.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFormatter = withFormatter;
+exports.getFormatMetadata = getFormatMetadata;
+exports.withOutputSchema = withOutputSchema;
+exports.getOutputSchema = getOutputSchema;
+exports.withResolver = withResolver;
+exports.getSchemaDescription = getSchemaDescription;
+exports.getFieldDescriptions = getFieldDescriptions;
+exports.withPositional = withPositional;
+exports.isPositional = isPositional;
+const zod_1 = require("zod");
+// Helper function to add format metadata to schemas
+function withFormatter(schema, formatMeta) {
+    // Store format metadata on the schema definition
+    schema._def.formatMeta = formatMeta;
+    return schema;
+}
+// Helper function to get format metadata from a schema
+function getFormatMetadata(schema) {
+    return schema._def.formatMeta;
+}
+// Helper function to link input schemas to output schemas
+function withOutputSchema(inputSchema, outputSchema) {
+    // Store output schema reference on the input schema
+    inputSchema._def.outputSchema = outputSchema;
+    return inputSchema;
+}
+// Helper function to get output schema from an input schema
+function getOutputSchema(inputSchema) {
+    return inputSchema._def.outputSchema;
+}
+// Helper function to add resolver metadata to schemas
+function withResolver(schema, config) {
+    // Store resolver metadata on the schema definition
+    schema._def.resolverMeta = config;
+    return schema;
+}
+// ============================================================================
+// Schema Description Utilities
+// ============================================================================
+function getSchemaDescription(schema) {
+    return schema.description;
+}
+function getFieldDescriptions(schema) {
+    const descriptions = {};
+    const shape = schema.shape;
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+        if (fieldSchema instanceof zod_1.z.ZodType && fieldSchema.description) {
+            descriptions[key] = fieldSchema.description;
+        }
+    }
+    return descriptions;
+}
+// Helper function to mark a parameter as positional for CLI
+function withPositional(schema) {
+    // Store positional metadata on the schema definition
+    schema._def.positionalMeta = { positional: true };
+    return schema;
+}
+// Helper function to check if a parameter should be positional
+function isPositional(schema) {
+    // Check the current schema first
+    if (schema._def.positionalMeta?.positional) {
+        return true;
+    }
+    // If this is a ZodOptional, check the inner type
+    if (schema instanceof zod_1.z.ZodOptional) {
+        return isPositional(schema._def.innerType);
+    }
+    // If this is a ZodDefault, check the inner type
+    if (schema instanceof zod_1.z.ZodDefault) {
+        return isPositional(schema._def.innerType);
+    }
+    return false;
+}

package/dist/schemas/Action.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const ActionItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    appKey: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    key: string;
+    appKey?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    type: string;
+    key: string;
+    appKey?: string | undefined;
+    name?: string | undefined;
+    description?: string | undefined;
+}>;
+export type ActionItem = z.infer<typeof ActionItemSchema>;

package/dist/schemas/Action.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// Action Schemas
+// ============================================================================
+exports.ActionItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    type: zod_1.z.string(),
+    appKey: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        details.push({ text: `Type: ${item.type}`, style: "accent" });
+        if (item.appKey) {
+            details.push({ text: `App: ${item.appKey}`, style: "normal" });
+        }
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});

package/dist/schemas/App.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export { FormattedItem, FormatMetadata } from "../schema-utils";
+export declare const AppItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+}, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+}>;
+export type AppItem = z.infer<typeof AppItemSchema>;

package/dist/schemas/App.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// App Schemas
+// ============================================================================
+exports.AppItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    category: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        if (item.category) {
+            details.push({
+                text: `Category: ${item.category}`,
+                style: "accent",
+            });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});

package/dist/schemas/Auth.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+export declare const AuthItemSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    identifier: z.ZodOptional<z.ZodString>;
+    account_id: z.ZodOptional<z.ZodString>;
+    is_private: z.ZodOptional<z.ZodBoolean>;
+    shared_with_all: z.ZodOptional<z.ZodBoolean>;
+    marked_stale_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    title?: string | undefined;
+    identifier?: string | undefined;
+    account_id?: string | undefined;
+    is_private?: boolean | undefined;
+    shared_with_all?: boolean | undefined;
+    marked_stale_at?: string | undefined;
+}, {
+    id: number;
+    title?: string | undefined;
+    identifier?: string | undefined;
+    account_id?: string | undefined;
+    is_private?: boolean | undefined;
+    shared_with_all?: boolean | undefined;
+    marked_stale_at?: string | undefined;
+}>;
+export type AuthItem = z.infer<typeof AuthItemSchema>;

package/dist/schemas/Auth.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// Auth Schemas
+// ============================================================================
+exports.AuthItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    id: zod_1.z.number(),
+    title: zod_1.z.string().optional(),
+    identifier: zod_1.z.string().optional(),
+    account_id: zod_1.z.string().optional(),
+    is_private: zod_1.z.boolean().optional(),
+    shared_with_all: zod_1.z.boolean().optional(),
+    marked_stale_at: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.identifier) {
+            details.push({
+                text: `Identifier: ${item.identifier}`,
+                style: "accent",
+            });
+        }
+        details.push({
+            text: `Account: ${item.account_id || "unknown"} | Private: ${item.is_private || false} | Shared: ${item.shared_with_all || false}`,
+            style: "dim",
+        });
+        if (item.marked_stale_at) {
+            details.push({
+                text: `⚠️  Marked stale: ${new Date(item.marked_stale_at).toLocaleDateString()}`,
+                style: "warning",
+            });
+        }
+        return {
+            title: item.title || `Authentication ${item.id}`,
+            subtitle: `(ID: ${item.id})`,
+            details,
+        };
+    },
+});

package/dist/schemas/Field.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const FieldItemSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+}, {
+    key: string;
+    name?: string | undefined;
+    description?: string | undefined;
+}>;
+export type FieldItem = z.infer<typeof FieldItemSchema>;

package/dist/schemas/Field.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldItemSchema = void 0;
+const zod_1 = require("zod");
+const schema_utils_1 = require("../schema-utils");
+// ============================================================================
+// Field Schemas
+// ============================================================================
+exports.FieldItemSchema = (0, schema_utils_1.withFormatter)(zod_1.z.object({
+    key: zod_1.z.string(),
+    name: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+}), {
+    format: (item) => {
+        const details = [];
+        if (item.description) {
+            details.push({ text: item.description, style: "dim" });
+        }
+        return {
+            title: item.name || item.key,
+            subtitle: `(${item.key})`,
+            details,
+        };
+    },
+});

package/dist/sdk.d.ts

@@ -1,7 +1,6 @@
-import { ActionsSdk } from "./actions-sdk";
-import { BaseSdkOptions } from "./types";
-export interface ZapierSdk extends ActionsSdk {
-}
+import { BaseSdkOptions } from "./types/domain";
+import type { ZapierSdk } from "./types/sdk";
+export type { ZapierSdk } from "./types/sdk";
 export interface ZapierSdkOptions extends BaseSdkOptions {
 }
 export declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;

package/dist/sdk.js

@@ -1,17 +1,110 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createZapierSdk = createZapierSdk;
-const actions_sdk_1 = require("./actions-sdk");
+const api_1 = require("./api");
+// Import function implementations
+const listApps_1 = require("./functions/listApps");
+const getApp_1 = require("./functions/getApp");
+const listActions_1 = require("./functions/listActions");
+const getAction_1 = require("./functions/getAction");
+const runAction_1 = require("./functions/runAction");
+const listAuthentications_1 = require("./functions/listAuthentications");
+const findFirstAuthentication_1 = require("./functions/findFirstAuthentication");
+const findUniqueAuthentication_1 = require("./functions/findUniqueAuthentication");
+const listFields_1 = require("./functions/listFields");
+const generateTypes_1 = require("./functions/generateTypes");
+const bundleCode_1 = require("./functions/bundleCode");
+// Import function registry info objects (only for CLI registry)
+const info_1 = require("./functions/listApps/info");
+const info_2 = require("./functions/getApp/info");
+const info_3 = require("./functions/listActions/info");
+const info_4 = require("./functions/getAction/info");
+const info_5 = require("./functions/runAction/info");
+const info_6 = require("./functions/listAuthentications/info");
+const info_7 = require("./functions/findFirstAuthentication/info");
+const info_8 = require("./functions/findUniqueAuthentication/info");
+const info_9 = require("./functions/listFields/info");
+const info_10 = require("./functions/generateTypes/info");
+const info_11 = require("./functions/bundleCode/info");
+// Function registry as array - uses names from function info objects
+const functionRegistry = [
+    info_1.listAppsInfo,
+    info_2.getAppInfo,
+    info_3.listActionsInfo,
+    info_4.getActionInfo,
+    info_5.runActionInfo,
+    info_6.listAuthenticationsInfo,
+    info_7.findFirstAuthenticationInfo,
+    info_8.findUniqueAuthenticationInfo,
+    info_9.listFieldsInfo,
+    info_10.generateTypesInfo,
+    info_11.bundleCodeInfo,
+];
+// Import plugin functions
+const index_1 = require("./plugins/apps/index");
+function createBaseZapierSdk(options = {}) {
+    // Auto-load .env files (searches up directory tree)
+    try {
+        const { findUpSync } = require("find-up");
+        const envPath = findUpSync(".env");
+        if (envPath) {
+            require("dotenv").config({ path: envPath, quiet: true });
+        }
+    }
+    catch {
+        // Silently fail if dotenv/find-up not available or .env not found
+    }
+    const { fetch: customFetch = globalThis.fetch, baseUrl = "https://zapier.com", token, debug = false, } = options;
+    // If no token provided, try to get it from environment variable
+    const finalToken = token || process.env.ZAPIER_TOKEN;
+    // Create the API client
+    const api = (0, api_1.createZapierApi)({
+        baseUrl,
+        token: finalToken,
+        debug,
+        fetch: customFetch,
+    });
+    // Build SDK directly - TypeScript will enforce correct implementation
+    const sdk = {
+        // Registry for CLI
+        __registry: functionRegistry,
+        // Function implementations with API config injection
+        listApps: (options = {}) => (0, listApps_1.listApps)({ ...options, api, token: finalToken }),
+        getApp: (options) => (0, getApp_1.getApp)({ ...options, api, token: finalToken }),
+        listActions: (options = {}) => (0, listActions_1.listActions)({ ...options, api, token: finalToken }),
+        getAction: (options) => (0, getAction_1.getAction)({ ...options, api, token: finalToken }),
+        runAction: (options) => (0, runAction_1.runAction)({ ...options, api, token: finalToken }),
+        listAuthentications: (options = {}) => (0, listAuthentications_1.listAuthentications)({ ...options, api, token: finalToken }),
+        findFirstAuthentication: (options = {}) => (0, findFirstAuthentication_1.findFirstAuthentication)({ ...options, api, token: finalToken }),
+        findUniqueAuthentication: (options = {}) => (0, findUniqueAuthentication_1.findUniqueAuthentication)({ ...options, api, token: finalToken }),
+        listFields: (options) => (0, listFields_1.listFields)({ ...options, api, token: finalToken }),
+        generateTypes: (options) => (0, generateTypes_1.generateTypes)({ ...options, api, token: finalToken }),
+        bundleCode: (options) => (0, bundleCode_1.bundleCode)(options), // No API config needed
+    };
+    return sdk;
+}
 function createZapierSdk(options = {}) {
-    // Create individual SDKs
-    const actionsSdk = (0, actions_sdk_1.createActionsSdk)(options);
-    // For now, we just return the actions SDK
-    // Later we'll combine multiple SDKs here
-    return {
-        ...actionsSdk,
-        // Future SDKs will be spread here:
-        // ...workflowsSdk,
-        // ...interfacesSdk,
-        // ...tablesSdk,
+    // Create base SDK
+    const baseSdk = createBaseZapierSdk(options);
+    // Extract options needed for plugins
+    const { fetch: customFetch = globalThis.fetch, baseUrl = "https://zapier.com", token, debug = false, } = options;
+    const finalToken = token || process.env.ZAPIER_TOKEN;
+    // Create the API client for plugins
+    const api = (0, api_1.createZapierApi)({
+        baseUrl,
+        token: finalToken,
+        debug,
+        fetch: customFetch,
+    });
+    // Create plugins directly - TypeScript will enforce correct implementation
+    const appsPlugin = (0, index_1.createAppsPlugin)({
+        api,
+        token: finalToken,
+    });
+    // Compose final SDK - TypeScript will enforce we have all required properties
+    const fullSdk = {
+        ...baseSdk,
+        apps: appsPlugin,
     };
+    return fullSdk;
 }

package/dist/types/domain.d.ts

@@ -0,0 +1,22 @@
+export type { Integration, Action, Trigger, Field, Choice, ActionExecutionResult, ActionField, ActionFieldChoice, NeedsRequest, NeedsResponse, Authentication, AuthenticationsResponse, } from "../api/types";
+export interface ActionExecutionOptions {
+    inputs?: Record<string, any>;
+    authenticationId?: number;
+}
+export interface AuthObject {
+    id: number;
+}
+export interface BaseSdkOptions {
+    token?: string;
+    fetch?: typeof fetch;
+    baseUrl?: string;
+    debug?: boolean;
+}
+export declare class ZapierSdkError extends Error {
+    code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+export declare class AppNotFoundError extends ZapierSdkError {
+    appKey: string;
+    constructor(appKey: string);
+}

package/dist/types/domain.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppNotFoundError = exports.ZapierSdkError = void 0;
+// Error Classes
+class ZapierSdkError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = "ZapierSdkError";
+    }
+}
+exports.ZapierSdkError = ZapierSdkError;
+class AppNotFoundError extends ZapierSdkError {
+    constructor(appKey) {
+        super(`App "${appKey}" not found`);
+        this.name = "AppNotFoundError";
+        this.code = "APP_NOT_FOUND";
+        this.appKey = appKey;
+    }
+}
+exports.AppNotFoundError = AppNotFoundError;