@zapier/zapier-sdk 0.3.1 → 0.4.0

package/dist/index.cjs

@@ -0,0 +1,2001 @@
+'use strict';
+
+var zod = require('zod');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  getTokenFromCliLogin: () => getTokenFromCliLogin,
+  getTokenFromEnv: () => getTokenFromEnv,
+  getTokenFromEnvOrConfig: () => getTokenFromEnvOrConfig
+});
+function getTokenFromEnv() {
+  return process.env.ZAPIER_TOKEN;
+}
+async function getTokenFromCliLogin(options = {}) {
+  try {
+    const { getToken } = await import('@zapier/zapier-sdk-cli-login');
+    return await getToken(options);
+  } catch {
+    return void 0;
+  }
+}
+async function getTokenFromEnvOrConfig(options = {}) {
+  const envToken = getTokenFromEnv();
+  if (envToken) {
+    return envToken;
+  }
+  return getTokenFromCliLogin(options);
+}
+var init_auth = __esm({
+  "src/auth.ts"() {
+  }
+});
+
+// src/api/auth.ts
+var auth_exports2 = {};
+__export(auth_exports2, {
+  getAuthorizationHeader: () => getAuthorizationHeader,
+  isJwt: () => isJwt
+});
+function isJwt(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    return false;
+  }
+  const base64UrlPattern = /^[A-Za-z0-9_-]+$/;
+  return parts.every((part) => part.length > 0 && base64UrlPattern.test(part));
+}
+function getAuthorizationHeader(token) {
+  if (isJwt(token)) {
+    return `JWT ${token}`;
+  }
+  return `Bearer ${token}`;
+}
+var init_auth2 = __esm({
+  "src/api/auth.ts"() {
+  }
+});
+
+// src/types/domain.ts
+var ZapierSdkError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "ZapierSdkError";
+  }
+};
+var AppNotFoundError = class extends ZapierSdkError {
+  constructor(appKey) {
+    super(`App "${appKey}" not found`);
+    this.name = "AppNotFoundError";
+    this.code = "APP_NOT_FOUND";
+    this.appKey = appKey;
+  }
+};
+function withFormatter(schema, formatMeta) {
+  schema._def.formatMeta = formatMeta;
+  return schema;
+}
+function withOutputSchema(inputSchema, outputSchema) {
+  inputSchema._def.outputSchema = outputSchema;
+  return inputSchema;
+}
+function withPositional(schema) {
+  schema._def.positionalMeta = { positional: true };
+  return schema;
+}
+function isPositional(schema) {
+  if (schema._def.positionalMeta?.positional) {
+    return true;
+  }
+  if (schema instanceof zod.z.ZodOptional) {
+    return isPositional(schema._def.innerType);
+  }
+  if (schema instanceof zod.z.ZodDefault) {
+    return isPositional(schema._def.innerType);
+  }
+  return false;
+}
+
+// src/types/properties.ts
+var AppKeyPropertySchema = withPositional(
+  zod.z.string().min(1).describe("App slug (e.g., 'slack', 'github')")
+);
+var ActionTypePropertySchema = zod.z.enum([
+  "read",
+  "read_bulk",
+  "write",
+  "run",
+  "search",
+  "search_or_write",
+  "search_and_write",
+  "filter"
+]).describe("Action type that matches the action's defined type");
+var ActionKeyPropertySchema = zod.z.string().min(1).describe("Action key to execute");
+var AuthenticationIdPropertySchema = zod.z.number().int().describe("Authentication ID to use for this action");
+var InputsPropertySchema = zod.z.record(zod.z.any()).describe("Input parameters for the action");
+var LimitPropertySchema = zod.z.number().int().min(1).max(1e3).default(50).describe("Maximum number of items to return");
+var OffsetPropertySchema = zod.z.number().int().min(0).default(0).describe("Number of items to skip for pagination");
+var OutputPropertySchema = zod.z.string().describe("Output file path");
+var DebugPropertySchema = zod.z.boolean().default(false).describe("Enable debug logging");
+var ParamsPropertySchema = zod.z.record(zod.z.any()).describe("Additional parameters");
+
+// src/plugins/apps/index.ts
+function createActionFunction(appKey, actionType, actionKey, options, pinnedAuthId) {
+  return async (actionOptions = {}) => {
+    const { sdk } = options;
+    const { inputs, authenticationId: providedAuthenticationId } = actionOptions;
+    const authenticationId = pinnedAuthId || providedAuthenticationId;
+    if (!authenticationId) {
+      throw new Error(
+        `Authentication ID is required. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }) or provide authenticationId in the action call.`
+      );
+    }
+    return sdk.runAction({
+      appKey,
+      actionType,
+      actionKey,
+      inputs,
+      authenticationId
+    });
+  };
+}
+function createActionTypeProxy(appKey, actionType, options, pinnedAuthId) {
+  if (actionType === "fetch") {
+    return async (fetchOptions) => {
+      const { sdk } = options;
+      const authenticationId = pinnedAuthId || fetchOptions.authenticationId;
+      if (!authenticationId) {
+        throw new Error(
+          `Authentication ID is required for fetch. Either use the factory pattern: sdk.apps.${appKey}({ authenticationId }).fetch(...) or provide authenticationId in the fetch call.`
+        );
+      }
+      return sdk.fetch({
+        ...fetchOptions,
+        authenticationId
+      });
+    };
+  }
+  return new Proxy(
+    {},
+    {
+      get(_, actionKey) {
+        if (typeof actionKey === "string") {
+          return createActionFunction(
+            appKey,
+            actionType,
+            actionKey,
+            options,
+            pinnedAuthId
+          );
+        }
+        return void 0;
+      }
+    }
+  );
+}
+function createPinnedAppProxy(appKey, options, pinnedAuthId) {
+  return new Proxy(
+    {},
+    {
+      get(_, actionType) {
+        if (typeof actionType === "string") {
+          return createActionTypeProxy(
+            appKey,
+            actionType,
+            options,
+            pinnedAuthId
+          );
+        }
+        return void 0;
+      }
+    }
+  );
+}
+function createAppProxy(appKey, options) {
+  const appFactory = (factoryOptions) => {
+    return createPinnedAppProxy(
+      appKey,
+      options,
+      factoryOptions.authenticationId
+    );
+  };
+  return new Proxy(appFactory, {
+    get(_, actionType) {
+      if (typeof actionType === "string") {
+        return createActionTypeProxy(appKey, actionType, options);
+      }
+      return void 0;
+    }
+  });
+}
+function createAppsProxy(options) {
+  const appsProxy = new Proxy({}, {
+    get(_, prop) {
+      if (typeof prop === "string") {
+        return createAppProxy(prop, options);
+      }
+      return void 0;
+    }
+  });
+  return appsProxy;
+}
+function createAppsPlugin(options) {
+  return createAppsProxy(options);
+}
+
+// src/index.ts
+init_auth();
+
+// src/resolvers/appKey.ts
+var appKeyResolver = {
+  type: "static",
+  inputType: "text",
+  placeholder: "Enter app slug (e.g., 'slack', 'github')"
+};
+
+// src/resolvers/actionType.ts
+var actionTypeResolver = {
+  type: "dynamic",
+  depends: ["appKey"],
+  fetch: async (sdk, resolvedParams) => {
+    const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+    const types = [...new Set(actions.map((action) => action.type))];
+    return types.map((type) => ({ key: type, name: type }));
+  },
+  prompt: (types) => ({
+    type: "list",
+    name: "actionType",
+    message: "Select action type:",
+    choices: types.map((type) => ({
+      name: type.name,
+      value: type.key
+    }))
+  })
+};
+
+// src/resolvers/actionKey.ts
+var actionKeyResolver = {
+  type: "dynamic",
+  depends: ["appKey", "actionType"],
+  fetch: async (sdk, resolvedParams) => {
+    const actions = await sdk.listActions({ appKey: resolvedParams.appKey });
+    return actions.filter(
+      (action) => action.type === resolvedParams.actionType
+    );
+  },
+  prompt: (actions) => ({
+    type: "list",
+    name: "actionKey",
+    message: "Select action:",
+    choices: actions.map((action) => ({
+      name: `${action.name || action.key} - ${action.description || "No description"}`,
+      value: action.key
+    }))
+  })
+};
+
+// src/resolvers/authenticationId.ts
+var authenticationIdResolver = {
+  type: "dynamic",
+  depends: ["appKey"],
+  fetch: async (sdk, resolvedParams) => {
+    return await sdk.listAuthentications({
+      appKey: resolvedParams.appKey,
+      limit: 1e3
+    });
+  },
+  prompt: (auths, params) => ({
+    type: "list",
+    name: "authenticationId",
+    message: `Select authentication for ${params.appKey}:`,
+    choices: [
+      ...auths.map((auth) => ({
+        name: `${auth.title || auth.label || "Authentication"} (ID: ${auth.id})`,
+        value: auth.id
+      })),
+      {
+        name: "\u2197 Skip authentication (may fail)",
+        value: null
+      }
+    ]
+  })
+};
+
+// src/resolvers/inputs.ts
+var 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
+    });
+  }
+};
+
+// src/resolvers/index.ts
+var resolverRegistry = {
+  appKey: appKeyResolver,
+  actionType: actionTypeResolver,
+  actionKey: actionKeyResolver,
+  authenticationId: authenticationIdResolver,
+  inputs: inputsResolver
+};
+function getResolver(name) {
+  return resolverRegistry[name];
+}
+function getResolversForMissingParams(missingParams) {
+  const resolvers = {};
+  for (const param of missingParams) {
+    const resolver = resolverRegistry[param];
+    if (resolver) {
+      resolvers[param] = resolver;
+    }
+  }
+  return resolvers;
+}
+function hasResolver(paramName) {
+  return paramName in resolverRegistry;
+}
+function getResolvableParams() {
+  return Object.keys(resolverRegistry);
+}
+function getResolutionOrder(paramName, resolved = /* @__PURE__ */ 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;
+}
+function getResolutionOrderForParams(paramNames) {
+  const resolved = /* @__PURE__ */ 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;
+}
+
+// src/api/index.ts
+init_auth2();
+
+// src/api/debug.ts
+function createDebugLogger(enabled) {
+  if (!enabled) {
+    return () => {
+    };
+  }
+  return (message, data) => {
+    console.log(`[Zapier SDK] ${message}`, data || "");
+  };
+}
+function createDebugFetch(options) {
+  const { originalFetch, debugLog } = options;
+  return async (input, options2) => {
+    const startTime = Date.now();
+    const url = typeof input === "string" ? input : input.toString();
+    const method = options2?.method || "GET";
+    debugLog(`\u2192 ${method} ${url}`, {
+      headers: options2?.headers,
+      body: options2?.body ? JSON.parse(options2.body) : void 0
+    });
+    try {
+      const response = await originalFetch(input, options2);
+      const duration = Date.now() - startTime;
+      debugLog(`\u2190 ${response.status} ${response.statusText} (${duration}ms)`, {
+        url,
+        method,
+        status: response.status
+      });
+      return response;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      debugLog(`\u2716 Request failed (${duration}ms)`, {
+        url,
+        method,
+        error: error instanceof Error ? error.message : error
+      });
+      throw error;
+    }
+  };
+}
+
+// src/api/polling.ts
+async function pollUntilComplete(options) {
+  const {
+    fetch: fetch2,
+    url,
+    headers = {},
+    maxAttempts = 30,
+    initialDelay = 50,
+    maxDelay = 1e3,
+    successStatus = 200,
+    pendingStatus = 202,
+    resultExtractor = (response) => response
+  } = options;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const response = await fetch2(url, { headers });
+    if (response.status === successStatus) {
+      const result = await response.json();
+      return resultExtractor(result);
+    } else if (response.status === pendingStatus) {
+      if (attempt < maxAttempts - 1) {
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, maxDelay);
+        continue;
+      }
+    } else {
+      throw new Error(
+        `Request failed: GET ${url} - ${response.status} ${response.statusText}`
+      );
+    }
+  }
+  throw new Error(`Operation timed out after ${maxAttempts} attempts`);
+}
+
+// src/api/client.ts
+init_auth2();
+init_auth();
+var SUBDOMAIN_PREFIXES = /* @__PURE__ */ new Set(["relay"]);
+function createZapierApi(options) {
+  const {
+    baseUrl,
+    token,
+    getToken,
+    debug = false,
+    fetch: originalFetch = globalThis.fetch,
+    onEvent
+  } = options;
+  const debugLog = createDebugLogger(debug);
+  const fetch2 = createDebugFetch({ originalFetch, debugLog });
+  function buildUrl(path, searchParams) {
+    const pathSegments = path.split("/").filter(Boolean);
+    let finalBaseUrl = baseUrl;
+    if (pathSegments.length > 0 && SUBDOMAIN_PREFIXES.has(pathSegments[0])) {
+      const subdomain = pathSegments[0];
+      const baseUrlObj = new URL(baseUrl);
+      baseUrlObj.hostname = `${subdomain}.${baseUrlObj.hostname}`;
+      finalBaseUrl = baseUrlObj.toString();
+      path = "/" + pathSegments.slice(1).join("/");
+    }
+    const url = new URL(path, finalBaseUrl);
+    if (searchParams) {
+      Object.entries(searchParams).forEach(([key, value]) => {
+        url.searchParams.set(key, value);
+      });
+    }
+    return url.toString();
+  }
+  async function buildHeaders(options2 = {}) {
+    const headers = {
+      ...options2.headers
+    };
+    if (options2.authRequired !== false) {
+      let resolvedToken = token;
+      if (!resolvedToken && getToken) {
+        resolvedToken = await getToken();
+      }
+      if (!resolvedToken) {
+        resolvedToken = await getTokenFromEnvOrConfig({
+          onEvent,
+          fetch: originalFetch
+        });
+      }
+      if (resolvedToken) {
+        headers.Authorization = getAuthorizationHeader(resolvedToken);
+      }
+    }
+    return headers;
+  }
+  async function handleResponse(response, customErrorHandler, hadAuthToken) {
+    if (!response.ok) {
+      if (customErrorHandler) {
+        const customError = customErrorHandler(response);
+        if (customError) {
+          throw customError;
+        }
+      }
+      if (response.status >= 400 && response.status < 500 && !hadAuthToken) {
+        throw new Error(
+          `Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`
+        );
+      }
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    try {
+      return await response.json();
+    } catch {
+      return await response.text();
+    }
+  }
+  async function plainFetch(input, init) {
+    const url = typeof input === "string" && !input.startsWith("http") ? buildUrl(input, init?.searchParams) : input.toString();
+    const headers = await buildHeaders(init);
+    const finalHeaders = {
+      ...headers,
+      ...init?.headers ? init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers : {}
+    };
+    return await fetch2(url, {
+      ...init,
+      headers: finalHeaders
+    });
+  }
+  async function fetchJson(method, path, data, options2 = {}) {
+    const headers = { ...options2.headers };
+    if (data && typeof data === "object") {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await plainFetch(path, {
+      method,
+      body: data ? JSON.stringify(data) : void 0,
+      headers,
+      searchParams: options2.searchParams,
+      authRequired: options2.authRequired,
+      customErrorHandler: options2.customErrorHandler
+    });
+    const hadAuthToken = !!(await buildHeaders(options2)).Authorization;
+    return handleResponse(response, options2.customErrorHandler, hadAuthToken);
+  }
+  return {
+    async get(path, options2 = {}) {
+      return fetchJson("GET", path, void 0, options2);
+    },
+    async post(path, data, options2 = {}) {
+      return fetchJson("POST", path, data, options2);
+    },
+    async put(path, data, options2 = {}) {
+      return fetchJson("PUT", path, data, options2);
+    },
+    async delete(path, options2 = {}) {
+      return fetchJson("DELETE", path, void 0, options2);
+    },
+    async poll(path, options2 = {}) {
+      const url = buildUrl(path, options2.searchParams);
+      const headers = await buildHeaders(options2);
+      return pollUntilComplete({
+        fetch: fetch2,
+        url,
+        headers,
+        maxAttempts: options2.maxAttempts,
+        initialDelay: options2.initialDelay,
+        maxDelay: options2.maxDelay,
+        successStatus: options2.successStatus,
+        pendingStatus: options2.pendingStatus,
+        resultExtractor: options2.resultExtractor
+      });
+    },
+    async fetch(input, init) {
+      return plainFetch(input, init);
+    }
+  };
+}
+
+// src/api/index.ts
+function generateRequestId() {
+  return Math.random().toString(36).substring(2) + Date.now().toString(36);
+}
+function getOrCreateApiClient(config) {
+  const {
+    baseUrl = "https://zapier.com",
+    token,
+    getToken,
+    api: providedApi,
+    debug = false,
+    fetch: customFetch
+  } = config;
+  if (providedApi) {
+    return providedApi;
+  }
+  return createZapierApi({
+    baseUrl,
+    token,
+    getToken,
+    debug,
+    fetch: customFetch
+  });
+}
+
+// src/functions/getApp/index.ts
+async function getApp(options) {
+  const api = getOrCreateApiClient(options);
+  const { appKey } = options;
+  const app = await api.get(`/api/v4/apps/${appKey}/`, {
+    customErrorHandler: (response) => {
+      if (response.status === 404) {
+        return new AppNotFoundError(appKey);
+      }
+      return void 0;
+    }
+  });
+  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
+  };
+}
+
+// src/functions/listAuthentications/index.ts
+async function listAuthentications(options = {}) {
+  const api = getOrCreateApiClient(options);
+  const listAuthenticationsInternal = async (options2 = {}) => {
+    const searchParams = {};
+    if (options2.appKey) {
+      try {
+        const app = await getApp({
+          appKey: options2.appKey,
+          api,
+          token: options2.token,
+          baseUrl: options2.baseUrl,
+          debug: options2.debug,
+          fetch: options2.fetch
+        });
+        const selectedApi = app.current_implementation_id;
+        if (selectedApi) {
+          const versionlessApi = selectedApi.split("@")[0];
+          searchParams.versionless_selected_api = versionlessApi;
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name === "AppNotFoundError") {
+          throw error;
+        }
+        console.warn(
+          `Warning: Could not filter by app ${options2.appKey}:`,
+          error instanceof Error ? error.message : "Unknown error"
+        );
+      }
+    }
+    if (options2.search) {
+      searchParams.search = options2.search;
+    } else if (options2.title) {
+      searchParams.search = options2.title;
+    }
+    if (options2.account_id) {
+      searchParams.account_id = options2.account_id;
+    }
+    if (options2.owner) {
+      searchParams.owner = options2.owner;
+    }
+    if (options2.limit) {
+      searchParams.limit = options2.limit.toString();
+    }
+    if (options2.offset) {
+      searchParams.offset = options2.offset.toString();
+    }
+    const data = await api.get(
+      "/api/v4/authentications/",
+      {
+        searchParams,
+        customErrorHandler: (response) => {
+          if (response.status === 401) {
+            return new Error(
+              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`
+            );
+          }
+          if (response.status === 403) {
+            return new Error(
+              `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${response.status})`
+            );
+          }
+          return void 0;
+        }
+      }
+    );
+    let auths = data.results || [];
+    auths = auths.map((auth) => ({
+      ...auth,
+      title: auth.title || auth.label || void 0
+    }));
+    if (options2.title) {
+      auths = auths.filter((auth) => auth.title === options2.title);
+    }
+    if (auths.length > 0) {
+      auths.__pagination = {
+        count: data.count,
+        hasNext: !!data.next,
+        hasPrevious: !!data.previous,
+        nextUrl: data.next,
+        previousUrl: data.previous
+      };
+    }
+    return auths;
+  };
+  if (options.limit && options.owner === void 0) {
+    const ownedAuths = await listAuthenticationsInternal({
+      ...options,
+      owner: "me"
+    });
+    if (ownedAuths.length >= options.limit) {
+      return ownedAuths.slice(0, options.limit);
+    }
+    const allAuths = await listAuthenticationsInternal({
+      ...options,
+      owner: void 0
+    });
+    const ownedAuthenticationIds = new Set(ownedAuths.map((auth) => auth.id));
+    const additionalAuths = allAuths.filter(
+      (auth) => !ownedAuthenticationIds.has(auth.id)
+    );
+    const combined = [...ownedAuths, ...additionalAuths];
+    return combined.slice(0, options.limit);
+  }
+  return listAuthenticationsInternal(options);
+}
+
+// src/functions/getAuthentication/index.ts
+async function getAuthentication(options) {
+  const { authenticationId } = options;
+  const api = getOrCreateApiClient(options);
+  const data = await api.get(
+    `/api/v4/authentications/${authenticationId}/`,
+    {
+      customErrorHandler: (response) => {
+        if (response.status === 401) {
+          return new Error(
+            `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${response.status})`
+          );
+        }
+        if (response.status === 403) {
+          return new Error(
+            `Access forbidden. Your token may not have the required scopes to get authentication ${authenticationId}. (HTTP ${response.status})`
+          );
+        }
+        if (response.status === 404) {
+          return new Error(
+            `Authentication ${authenticationId} not found. It may not exist or you may not have access to it. (HTTP ${response.status})`
+          );
+        }
+        return void 0;
+      }
+    }
+  );
+  return {
+    ...data,
+    title: data.title || data.label || void 0
+  };
+}
+
+// src/functions/findFirstAuthentication/index.ts
+async function findFirstAuthentication(options = {}) {
+  const auths = await listAuthentications({
+    ...options,
+    limit: 1
+  });
+  return auths.length > 0 ? auths[0] : null;
+}
+
+// src/functions/findUniqueAuthentication/index.ts
+async function findUniqueAuthentication(options = {}) {
+  const auths = await 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];
+}
+
+// src/functions/listApps/index.ts
+async function listApps(options = {}) {
+  const api = getOrCreateApiClient(options);
+  const searchParams = {};
+  if (options.category) {
+    searchParams.category = options.category;
+  }
+  if (options.limit) {
+    searchParams.limit = options.limit.toString();
+  }
+  if (options.offset) {
+    searchParams.offset = options.offset.toString();
+  }
+  const data = await api.get("/api/v4/apps/", { searchParams });
+  const apps = data.results?.map(
+    (app) => ({
+      key: app.slug,
+      name: app.name,
+      description: app.description,
+      version: "1.0.0",
+      // API doesn't provide version
+      category: app.category?.name,
+      actions: [],
+      // Will be populated separately
+      triggers: [],
+      current_implementation_id: app.current_implementation_id
+    })
+  ) || [];
+  if (apps.length > 0) {
+    apps.__pagination = {
+      count: data.count,
+      hasNext: !!data.next,
+      hasPrevious: !!data.previous,
+      nextUrl: data.next,
+      previousUrl: data.previous
+    };
+  }
+  return apps;
+}
+
+// src/functions/listActions/index.ts
+async function listActions(options = {}) {
+  const api = getOrCreateApiClient(options);
+  if (options.appKey) {
+    try {
+      const appData = await getApp({
+        appKey: options.appKey,
+        api,
+        token: options.token,
+        baseUrl: options.baseUrl,
+        debug: options.debug,
+        fetch: options.fetch
+      });
+      const implementationId = appData.current_implementation_id?.split("@")[0];
+      if (!implementationId) {
+        throw new Error("No current_implementation_id found for app");
+      }
+      const searchParams2 = {
+        global: "true",
+        public_only: "true",
+        selected_apis: implementationId
+      };
+      const data2 = await api.get("/api/v4/implementations/", {
+        searchParams: searchParams2
+      });
+      const actions2 = [];
+      for (const implementation of data2.results || []) {
+        if (implementation.actions) {
+          for (const action of implementation.actions) {
+            const transformedAction = {
+              key: action.key,
+              name: action.name || action.label,
+              description: action.description || "",
+              appKey: implementation.slug || "",
+              type: action.type || action.type_of || "read",
+              inputFields: [],
+              // Would need additional API call for detailed fields
+              outputFields: []
+            };
+            if (options?.type && transformedAction.type !== options.type) {
+              continue;
+            }
+            actions2.push(transformedAction);
+          }
+        }
+      }
+      if (actions2.length > 0) {
+        actions2.__pagination = {
+          count: data2.count,
+          hasNext: !!data2.next,
+          hasPrevious: !!data2.previous,
+          nextUrl: data2.next,
+          previousUrl: data2.previous
+        };
+      }
+      return actions2;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AppNotFoundError") {
+        throw error;
+      }
+      console.warn(
+        "Optimized app lookup failed, falling back to full scan:",
+        error
+      );
+    }
+  }
+  const searchParams = {
+    global: "true",
+    public_only: "true"
+  };
+  const data = await api.get("/api/v4/implementations/", { searchParams });
+  const actions = [];
+  for (const implementation of data.results || []) {
+    if (implementation.actions) {
+      for (const action of implementation.actions) {
+        const transformedAction = {
+          key: action.key,
+          name: action.name || action.label,
+          description: action.description || "",
+          appKey: implementation.slug || "",
+          type: action.type || action.type_of || "read",
+          inputFields: [],
+          // Would need additional API call for detailed fields
+          outputFields: []
+        };
+        if (options?.appKey && transformedAction.appKey !== options.appKey) {
+          continue;
+        }
+        if (options?.type && transformedAction.type !== options.type) {
+          continue;
+        }
+        actions.push(transformedAction);
+      }
+    }
+  }
+  if (actions.length > 0) {
+    actions.__pagination = {
+      count: data.count,
+      hasNext: !!data.next,
+      hasPrevious: !!data.previous,
+      nextUrl: data.next,
+      previousUrl: data.previous
+    };
+  }
+  return actions;
+}
+
+// src/functions/getAction/index.ts
+async function getAction(options) {
+  const { appKey, actionKey, actionType } = options;
+  const actions = await listActions({
+    ...options,
+    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;
+}
+
+// src/functions/runAction/index.ts
+async function runAction(options) {
+  const {
+    appKey,
+    actionType,
+    actionKey,
+    inputs,
+    authenticationId: providedAuthenticationId
+  } = options;
+  const api = getOrCreateApiClient(options);
+  const actionData = await getAction({
+    ...options,
+    appKey,
+    actionKey,
+    actionType
+  });
+  if (actionData.type !== actionType) {
+    throw new Error(
+      `Action type mismatch: expected ${actionType}, got ${actionData.type}`
+    );
+  }
+  const startTime = Date.now();
+  const result = await executeAction({
+    api,
+    appSlug: appKey,
+    actionKey,
+    actionType: actionData.type,
+    executionOptions: { inputs: inputs || {} },
+    authenticationId: providedAuthenticationId,
+    options
+  });
+  const executionTime = Date.now() - startTime;
+  return {
+    success: true,
+    data: result,
+    metadata: {
+      executionTime,
+      requestId: generateRequestId()
+    }
+  };
+}
+async function executeAction(actionOptions) {
+  const {
+    api,
+    appSlug,
+    actionKey,
+    actionType,
+    executionOptions,
+    authenticationId,
+    options
+  } = actionOptions;
+  const appData = await getApp({
+    appKey: appSlug,
+    api,
+    token: options.token,
+    baseUrl: options.baseUrl,
+    debug: options.debug,
+    fetch: options.fetch
+  });
+  const selectedApi = appData.current_implementation_id;
+  if (!selectedApi) {
+    throw new Error("No current_implementation_id found for app");
+  }
+  const runRequest = {
+    data: {
+      authentication_id: authenticationId || 1,
+      selected_api: selectedApi,
+      action_key: actionKey,
+      action_type: actionType,
+      inputs: executionOptions.inputs || {}
+    }
+  };
+  const runData = await api.post("/api/actions/v1/runs", runRequest);
+  const runId = runData.data.id;
+  return await api.poll(`/api/actions/v1/runs/${runId}`, {
+    successStatus: 200,
+    pendingStatus: 202,
+    resultExtractor: (result) => result.data
+  });
+}
+
+// src/functions/listFields/index.ts
+async function listFields(options) {
+  const api = getOrCreateApiClient(options);
+  const { appKey, actionKey, actionType, authenticationId, params } = options;
+  const appData = await getApp({
+    appKey,
+    api,
+    token: options.token,
+    baseUrl: options.baseUrl,
+    debug: options.debug,
+    fetch: options.fetch
+  });
+  const selectedApi = appData.current_implementation_id;
+  if (!selectedApi) {
+    throw new Error("No current_implementation_id found for app");
+  }
+  const needsRequest = {
+    selected_api: selectedApi,
+    action: actionKey,
+    type_of: actionType,
+    authentication_id: authenticationId,
+    params: params || {}
+  };
+  const needsData = await api.post(
+    "/api/v4/implementations/needs/",
+    needsRequest
+  );
+  if (!needsData.success) {
+    throw new Error(
+      `Failed to get action fields: ${needsData.errors?.join(", ") || "Unknown error"}`
+    );
+  }
+  return (needsData.needs || []).map((need) => ({
+    key: need.key,
+    label: need.label,
+    required: need.required || false,
+    type: need.type,
+    helpText: need.help_text,
+    helpTextHtml: need.help_text_html,
+    choices: need.choices?.map((choice) => ({
+      value: choice.value,
+      label: choice.label
+    })),
+    default: need.default,
+    placeholder: need.placeholder,
+    computed: need.computed,
+    customField: need.custom_field,
+    dependsOn: need.depends_on,
+    format: need.format,
+    inputFormat: need.input_format
+  }));
+}
+
+// src/functions/generateTypes/index.ts
+function generateFetchMethodSignature() {
+  return `  /** Make authenticated HTTP requests through Zapier's Relay service */
+  fetch: (options: Omit<z.infer<typeof RelayFetchSchema>, 'authenticationId'>) => Promise<Response>`;
+}
+async function generateTypes(options) {
+  const {
+    appKey,
+    authenticationId,
+    output = `./types/${appKey}.d.ts`
+  } = options;
+  const { app, version } = parseAppIdentifier(appKey);
+  const actions = await listActions({
+    ...options,
+    appKey: app
+  });
+  if (actions.length === 0) {
+    const typeDefinitions2 = generateEmptyTypesFile(app, version);
+    if (output) {
+      const fs = await import('fs');
+      const path = await import('path');
+      fs.mkdirSync(path.dirname(output), { recursive: true });
+      fs.writeFileSync(output, typeDefinitions2, "utf8");
+    }
+    return typeDefinitions2;
+  }
+  const actionsWithFields = [];
+  if (authenticationId) {
+    for (const action of actions) {
+      try {
+        const fields = await listFields({
+          ...options,
+          appKey: action.appKey,
+          actionKey: action.key,
+          actionType: action.type,
+          authenticationId
+        });
+        actionsWithFields.push({ ...action, inputFields: fields });
+      } catch {
+        actionsWithFields.push({ ...action, inputFields: [] });
+      }
+    }
+  } else {
+    actions.forEach((action) => {
+      actionsWithFields.push({ ...action, inputFields: [] });
+    });
+  }
+  const typeDefinitions = generateTypeDefinitions(
+    app,
+    actionsWithFields,
+    version
+  );
+  if (output) {
+    const fs = await import('fs');
+    const path = await import('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) {
+  if (actions.length === 0) {
+    return generateEmptyTypesFile(appKey, version);
+  }
+  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: ${(/* @__PURE__ */ 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'
+import { z } from 'zod'
+import { RelayFetchSchema } from '@zapier/zapier-sdk'
+
+`;
+  actions.forEach((action) => {
+    if (action.inputFields.length > 0) {
+      const inputTypeName = `${appName}${capitalize(action.type)}${capitalize(
+        sanitizeActionName(action.key)
+      )}Inputs`;
+      output += `interface ${inputTypeName} {
+`;
+      action.inputFields.forEach((field) => {
+        const isOptional = !field.required;
+        const fieldType = mapFieldTypeToTypeScript(field);
+        const description = field.helpText ? `  /** ${escapeComment(field.helpText)} */
+` : "";
+        output += `${description}  ${sanitizeFieldName(field.key)}${isOptional ? "?" : ""}: ${fieldType}
+`;
+      });
+      output += `}
+
+`;
+    }
+  });
+  Object.entries(actionsByType).forEach(([actionType, typeActions]) => {
+    const typeName = `${appName}${capitalize(actionType)}Actions`;
+    output += `interface ${typeName} {
+`;
+    typeActions.forEach((action) => {
+      const actionName = sanitizeActionName(action.key);
+      const description = action.description ? `  /** ${escapeComment(action.description)} */
+` : "";
+      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>
+`;
+      } else {
+        output += `${description}  ${actionName}: (options?: { inputs?: Record<string, any> } & ActionExecutionOptions) => Promise<ActionExecutionResult>
+`;
+      }
+    });
+    output += `}
+
+`;
+  });
+  output += `interface ${appName}AppProxy {
+`;
+  Object.keys(actionsByType).forEach((actionType) => {
+    const typeName = `${appName}${capitalize(actionType)}Actions`;
+    output += `  ${actionType}: ${typeName}
+`;
+  });
+  output += generateFetchMethodSignature() + "\n";
+  output += `}
+
+`;
+  output += `interface ${appName}AppFactory {
+`;
+  output += `  (options: { authenticationId: number }): ${appName}AppProxy
+`;
+  output += `}
+
+`;
+  output += `type ${appName}AppWithFactory = ${appName}AppFactory & ${appName}AppProxy
+
+`;
+  output += `export interface ${appName}Sdk {
+`;
+  output += `  apps: {
+`;
+  output += `    ${appKey}: ${appName}AppWithFactory
+`;
+  output += `  }
+`;
+  output += `}
+`;
+  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: ${(/* @__PURE__ */ new Date()).toISOString()}
+ * 
+ * No actions found for this app.
+ */
+
+import type { ActionExecutionOptions, ActionExecutionResult } from '@zapier/zapier-sdk'
+import { z } from 'zod'
+import { RelayFetchSchema } from '@zapier/zapier-sdk'
+
+interface ${appName}AppProxy {
+  // No actions available
+${generateFetchMethodSignature()}
+}
+
+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) {
+  let sanitized = actionKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "_" + sanitized;
+  }
+  return sanitized;
+}
+function sanitizeFieldName(fieldKey) {
+  let sanitized = fieldKey.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^[0-9]/.test(sanitized)) {
+    sanitized = "_" + sanitized;
+  }
+  return sanitized;
+}
+function escapeComment(comment) {
+  return comment.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ");
+}
+function mapFieldTypeToTypeScript(field) {
+  if (field.choices && field.choices.length > 0) {
+    const choiceValues = field.choices.filter(
+      (choice) => choice.value !== void 0 && choice.value !== null && choice.value !== ""
+    ).map(
+      (choice) => typeof choice.value === "string" ? `"${choice.value}"` : choice.value
+    );
+    if (choiceValues.length > 0) {
+      return choiceValues.join(" | ");
+    }
+  }
+  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:
+      return "string | number | boolean";
+  }
+}
+
+// src/functions/bundleCode/index.ts
+async function bundleCode(options) {
+  const {
+    input,
+    output,
+    target = "es2020",
+    cjs = false,
+    minify = false,
+    string: returnString = false
+  } = options;
+  const { buildSync } = await import('esbuild');
+  const fs = await import('fs');
+  const path = await import('path');
+  const resolvedInput = path.resolve(process.cwd(), input);
+  try {
+    const result = buildSync({
+      entryPoints: [resolvedInput],
+      bundle: true,
+      platform: "node",
+      target,
+      format: cjs ? "cjs" : "esm",
+      minify,
+      write: false,
+      external: [],
+      // Bundle everything
+      banner: {
+        js: "#!/usr/bin/env node"
+      }
+    });
+    if (result.errors.length > 0) {
+      throw new Error(
+        `Bundle failed: ${result.errors.map((e) => e.text).join(", ")}`
+      );
+    }
+    const bundledCode = result.outputFiles?.[0]?.text;
+    if (!bundledCode) {
+      throw new Error("No output generated");
+    }
+    let finalOutput = bundledCode;
+    if (returnString) {
+      finalOutput = JSON.stringify(bundledCode);
+    }
+    if (output) {
+      fs.mkdirSync(path.dirname(output), { recursive: true });
+      fs.writeFileSync(output, finalOutput, "utf8");
+    }
+    return finalOutput;
+  } catch (error) {
+    throw new Error(
+      `Bundle failed: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+// src/functions/fetch/index.ts
+function transformUrlToRelayPath(url) {
+  const targetUrl = new URL(url);
+  const relayPath = `/relay/${targetUrl.hostname}${targetUrl.pathname}${targetUrl.search}${targetUrl.hash}`;
+  return relayPath;
+}
+async function fetch(options) {
+  const {
+    url,
+    method = "GET",
+    body,
+    headers,
+    authenticationId,
+    callbackUrl,
+    authenticationTemplate,
+    ...config
+  } = options;
+  return relayFetch(
+    url,
+    {
+      method,
+      body,
+      headers,
+      authenticationId,
+      callbackUrl,
+      authenticationTemplate
+    },
+    config
+  );
+}
+async function relayFetch(url, options = {}, config = {}) {
+  const api = getOrCreateApiClient(config);
+  const {
+    authenticationId,
+    callbackUrl,
+    authenticationTemplate,
+    method = "GET",
+    body,
+    ...fetchOptions
+  } = options;
+  const relayPath = transformUrlToRelayPath(url);
+  const headers = {};
+  if (fetchOptions.headers) {
+    const headerEntries = fetchOptions.headers instanceof Headers ? Array.from(fetchOptions.headers.entries()) : Object.entries(fetchOptions.headers);
+    for (const [key, value] of headerEntries) {
+      headers[key] = value;
+    }
+  }
+  if (authenticationId) {
+    headers["X-Relay-Authentication-Id"] = authenticationId.toString();
+  }
+  if (callbackUrl) {
+    headers["X-Relay-Callback-Url"] = callbackUrl;
+  }
+  if (authenticationTemplate) {
+    headers["X-Authentication-Template"] = authenticationTemplate;
+  }
+  const requestOptions = {
+    headers,
+    authRequired: false,
+    // Disable automatic Authorization header
+    customErrorHandler: (response) => {
+      if (!response.ok) {
+        return new Error(
+          `Relay request failed: ${response.status} ${response.statusText}`
+        );
+      }
+      return void 0;
+    }
+  };
+  let token = config.token;
+  if (!token && config.getToken) {
+    token = await config.getToken();
+  }
+  if (!token) {
+    const { getTokenFromEnvOrConfig: getTokenFromEnvOrConfig2 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
+    token = await getTokenFromEnvOrConfig2({
+      onEvent: config.onEvent,
+      fetch: config.fetch
+    });
+  }
+  if (token) {
+    const { getAuthorizationHeader: getAuthorizationHeader2 } = await Promise.resolve().then(() => (init_auth2(), auth_exports2));
+    headers["X-Relay-Authorization"] = getAuthorizationHeader2(token);
+  }
+  return await api.fetch(relayPath, {
+    method,
+    body,
+    headers: requestOptions.headers,
+    authRequired: requestOptions.authRequired,
+    customErrorHandler: requestOptions.customErrorHandler
+  });
+}
+var RelayFetchSchema = zod.z.object({
+  url: zod.z.string().url().describe("The URL to fetch (will be proxied through Relay)"),
+  method: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method"),
+  body: zod.z.string().optional().describe("Request body as a string"),
+  authenticationId: zod.z.number().int().optional().describe("Zapier authentication ID to use for the request"),
+  callbackUrl: zod.z.string().url().optional().describe("URL to send async response to (makes request async)"),
+  authenticationTemplate: zod.z.string().optional().describe(
+    "Optional JSON string authentication template to bypass Notary lookup"
+  ),
+  headers: zod.z.record(zod.z.string()).optional().describe("Request headers")
+}).describe("Make authenticated HTTP requests through Zapier's Relay service");
+var AppItemSchema = withFormatter(
+  zod.z.object({
+    key: zod.z.string(),
+    name: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    category: zod.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
+      };
+    }
+  }
+);
+
+// src/functions/listApps/schemas.ts
+var ListAppsSchema = withOutputSchema(
+  zod.z.object({
+    category: zod.z.string().optional().describe("Filter apps by category"),
+    limit: LimitPropertySchema.optional().describe(
+      "Maximum number of items to return (1-200)"
+    ),
+    offset: OffsetPropertySchema.optional().describe(
+      "Number of items to skip for pagination"
+    )
+  }).describe("List all available apps with optional filtering"),
+  AppItemSchema
+);
+
+// src/functions/listApps/info.ts
+var listAppsInfo = {
+  name: listApps.name,
+  inputSchema: ListAppsSchema,
+  implementation: listApps
+};
+var GetAppSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.describe(
+    "App key or slug to fetch (e.g., google-sheets, slack, github)"
+  )
+}).describe("Get detailed information about a specific app");
+
+// src/functions/getApp/info.ts
+var getAppInfo = {
+  name: getApp.name,
+  inputSchema: GetAppSchema,
+  implementation: getApp
+};
+var ActionItemSchema = withFormatter(
+  zod.z.object({
+    key: zod.z.string(),
+    name: zod.z.string().optional(),
+    type: zod.z.string(),
+    appKey: zod.z.string().optional(),
+    description: zod.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
+      };
+    }
+  }
+);
+
+// src/functions/listActions/schemas.ts
+var ListActionsSchema = withOutputSchema(
+  zod.z.object({
+    appKey: AppKeyPropertySchema.optional(),
+    type: ActionTypePropertySchema.optional().describe(
+      "Filter actions by type"
+    )
+  }).describe("List all actions for a specific app"),
+  ActionItemSchema
+);
+
+// src/functions/listActions/info.ts
+var listActionsInfo = {
+  name: listActions.name,
+  inputSchema: ListActionsSchema,
+  implementation: listActions
+};
+var GetActionSchema = zod.z.object({
+  appKey: AppKeyPropertySchema,
+  actionType: ActionTypePropertySchema,
+  actionKey: ActionKeyPropertySchema
+}).describe("Get detailed information about a specific action");
+
+// src/functions/getAction/info.ts
+var getActionInfo = {
+  name: getAction.name,
+  inputSchema: GetActionSchema,
+  implementation: getAction
+};
+var RunActionSchema = zod.z.object({
+  appKey: AppKeyPropertySchema,
+  actionType: ActionTypePropertySchema,
+  actionKey: ActionKeyPropertySchema,
+  inputs: InputsPropertySchema.optional().describe(
+    "Input parameters for the action"
+  ),
+  authenticationId: AuthenticationIdPropertySchema.optional()
+}).describe("Execute an action with the given inputs");
+
+// src/functions/runAction/info.ts
+var runActionInfo = {
+  name: runAction.name,
+  inputSchema: RunActionSchema,
+  implementation: runAction
+};
+var AuthItemSchema = withFormatter(
+  zod.z.object({
+    id: zod.z.number(),
+    title: zod.z.string().optional(),
+    identifier: zod.z.string().optional(),
+    account_id: zod.z.string().optional(),
+    is_private: zod.z.boolean().optional(),
+    shared_with_all: zod.z.boolean().optional(),
+    marked_stale_at: zod.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: `\u26A0\uFE0F  Marked stale: ${new Date(item.marked_stale_at).toLocaleDateString()}`,
+          style: "warning"
+        });
+      }
+      return {
+        title: item.title || `Authentication ${item.id}`,
+        subtitle: `(ID: ${item.id})`,
+        details
+      };
+    }
+  }
+);
+
+// src/functions/listAuthentications/schemas.ts
+var ListAuthenticationsSchema = withOutputSchema(
+  zod.z.object({
+    appKey: AppKeyPropertySchema.optional().describe(
+      "App slug to get authentications for (e.g., 'slack', 'github')"
+    ),
+    search: zod.z.string().optional().describe("Search term to filter authentications by title"),
+    title: zod.z.string().optional().describe("Filter authentications by exact title match"),
+    account_id: zod.z.string().optional().describe("Filter by account ID"),
+    owner: zod.z.string().optional().describe("Filter by owner"),
+    limit: LimitPropertySchema.optional().describe(
+      "Maximum number of items to return (1-200)"
+    ),
+    offset: OffsetPropertySchema.optional().describe(
+      "Number of items to skip for pagination"
+    )
+  }).describe("List available authentications with optional filtering"),
+  AuthItemSchema
+);
+
+// src/functions/listAuthentications/info.ts
+var listAuthenticationsInfo = {
+  name: listAuthentications.name,
+  inputSchema: ListAuthenticationsSchema,
+  implementation: listAuthentications
+};
+var GetAuthenticationSchema = withOutputSchema(
+  zod.z.object({
+    authenticationId: zod.z.number().int().positive().describe("Authentication ID to retrieve")
+  }).describe("Get a specific authentication by ID"),
+  AuthItemSchema
+);
+
+// src/functions/getAuthentication/info.ts
+var getAuthenticationInfo = {
+  name: getAuthentication.name,
+  inputSchema: GetAuthenticationSchema,
+  implementation: getAuthentication
+};
+var FindFirstAuthenticationSchema = withOutputSchema(
+  zod.z.object({
+    appKey: AppKeyPropertySchema.optional().describe(
+      "App slug to get authentications for (e.g., 'slack', 'github')"
+    ),
+    search: zod.z.string().optional().describe("Search term to filter authentications by title"),
+    title: zod.z.string().optional().describe("Filter authentications by exact title match"),
+    account_id: zod.z.string().optional().describe("Filter by account ID"),
+    owner: zod.z.string().optional().describe("Filter by owner"),
+    limit: LimitPropertySchema.optional().describe(
+      "Maximum number of items to return (1-200)"
+    ),
+    offset: OffsetPropertySchema.optional().describe(
+      "Number of items to skip for pagination"
+    )
+  }).describe("Find the first authentication matching the criteria"),
+  AuthItemSchema
+);
+
+// src/functions/findFirstAuthentication/info.ts
+var findFirstAuthenticationInfo = {
+  name: findFirstAuthentication.name,
+  inputSchema: FindFirstAuthenticationSchema,
+  implementation: findFirstAuthentication
+};
+var FindUniqueAuthenticationSchema = withOutputSchema(
+  zod.z.object({
+    appKey: AppKeyPropertySchema.optional().describe(
+      "App slug to get authentications for (e.g., 'slack', 'github')"
+    ),
+    search: zod.z.string().optional().describe("Search term to filter authentications by title"),
+    title: zod.z.string().optional().describe("Filter authentications by exact title match"),
+    account_id: zod.z.string().optional().describe("Filter by account ID"),
+    owner: zod.z.string().optional().describe("Filter by owner"),
+    limit: LimitPropertySchema.optional().describe(
+      "Maximum number of items to return (1-200)"
+    ),
+    offset: OffsetPropertySchema.optional().describe(
+      "Number of items to skip for pagination"
+    )
+  }).describe("Find a unique authentication matching the criteria"),
+  AuthItemSchema
+);
+
+// src/functions/findUniqueAuthentication/info.ts
+var findUniqueAuthenticationInfo = {
+  name: findUniqueAuthentication.name,
+  inputSchema: FindUniqueAuthenticationSchema,
+  implementation: findUniqueAuthentication
+};
+var FieldItemSchema = withFormatter(
+  zod.z.object({
+    key: zod.z.string(),
+    name: zod.z.string().optional(),
+    description: zod.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
+      };
+    }
+  }
+);
+
+// src/functions/listFields/schemas.ts
+var ListFieldsSchema = withOutputSchema(
+  zod.z.object({
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+    authenticationId: AuthenticationIdPropertySchema.optional(),
+    params: ParamsPropertySchema.optional().describe(
+      "Additional parameters that may affect available fields"
+    )
+  }).describe("Get the input fields required for a specific action"),
+  FieldItemSchema
+);
+
+// src/functions/listFields/info.ts
+var listFieldsInfo = {
+  name: listFields.name,
+  inputSchema: ListFieldsSchema,
+  implementation: listFields
+};
+var GenerateTypesSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.describe("App key to generate SDK code for"),
+  authenticationId: AuthenticationIdPropertySchema.optional(),
+  output: OutputPropertySchema.optional().describe(
+    "Output file path (defaults to generated/<appKey>.ts)"
+  ),
+  debug: DebugPropertySchema.describe(
+    "Enable debug logging during generation"
+  )
+}).describe("Generate TypeScript SDK code for a specific app");
+
+// src/functions/generateTypes/info.ts
+var generateTypesInfo = {
+  name: generateTypes.name,
+  inputSchema: GenerateTypesSchema,
+  implementation: generateTypes
+};
+var BundleCodeSchema = zod.z.object({
+  input: zod.z.string().min(1).describe("Input TypeScript file path to bundle"),
+  output: OutputPropertySchema.optional().describe(
+    "Output file path (defaults to input with .js extension)"
+  ),
+  string: zod.z.boolean().default(false).describe("Return bundled code as string instead of writing to file"),
+  minify: zod.z.boolean().default(false).describe("Minify the bundled output"),
+  target: zod.z.string().default("es2017").describe("ECMAScript target version"),
+  cjs: zod.z.boolean().default(false).describe("Output CommonJS format instead of ESM")
+}).describe("Bundle TypeScript code into executable JavaScript");
+
+// src/functions/bundleCode/info.ts
+var bundleCodeInfo = {
+  name: bundleCode.name,
+  inputSchema: BundleCodeSchema,
+  implementation: bundleCode
+};
+
+// src/functions/fetch/info.ts
+var fetchInfo = {
+  name: "fetch",
+  inputSchema: RelayFetchSchema,
+  implementation: fetch
+};
+
+// src/sdk.ts
+var functionRegistry = [
+  listAppsInfo,
+  getAppInfo,
+  listActionsInfo,
+  getActionInfo,
+  runActionInfo,
+  listAuthenticationsInfo,
+  getAuthenticationInfo,
+  findFirstAuthenticationInfo,
+  findUniqueAuthenticationInfo,
+  listFieldsInfo,
+  generateTypesInfo,
+  bundleCodeInfo,
+  fetchInfo
+];
+function createZapierSdk(options = {}) {
+  const {
+    fetch: customFetch = globalThis.fetch,
+    baseUrl = "https://zapier.com",
+    token,
+    getToken,
+    onEvent,
+    debug = false
+  } = options;
+  const api = createZapierApi({
+    baseUrl,
+    token,
+    getToken,
+    debug,
+    fetch: customFetch,
+    onEvent
+  });
+  const baseSdk = {
+    // Registry for CLI
+    __registry: functionRegistry,
+    // Function implementations with API config injection
+    listApps: (options2 = {}) => listApps({ ...options2, api }),
+    getApp: (options2) => getApp({ ...options2, api }),
+    listActions: (options2 = {}) => listActions({ ...options2, api }),
+    getAction: (options2) => getAction({ ...options2, api }),
+    runAction: (options2) => runAction({ ...options2, api }),
+    listAuthentications: (options2 = {}) => listAuthentications({ ...options2, api }),
+    getAuthentication: (options2) => getAuthentication({ ...options2, api }),
+    findFirstAuthentication: (options2 = {}) => findFirstAuthentication({ ...options2, api }),
+    findUniqueAuthentication: (options2 = {}) => findUniqueAuthentication({ ...options2, api }),
+    listFields: (options2) => listFields({ ...options2, api }),
+    generateTypes: (options2) => generateTypes({ ...options2, api }),
+    bundleCode: (options2) => bundleCode(options2),
+    // No API config needed
+    fetch: (options2) => fetch({ ...options2, api })
+  };
+  const fullSdk = {
+    ...baseSdk,
+    // Add plugins - apps plugin gets the base SDK cast as full ZapierSdk type
+    // This is safe because by the time plugin functions are called, fullSdk will be complete
+    apps: createAppsPlugin({
+      sdk: baseSdk
+    })
+  };
+  return fullSdk;
+}
+
+exports.ActionKeyPropertySchema = ActionKeyPropertySchema;
+exports.ActionTypePropertySchema = ActionTypePropertySchema;
+exports.AppKeyPropertySchema = AppKeyPropertySchema;
+exports.AppNotFoundError = AppNotFoundError;
+exports.AuthenticationIdPropertySchema = AuthenticationIdPropertySchema;
+exports.DebugPropertySchema = DebugPropertySchema;
+exports.InputsPropertySchema = InputsPropertySchema;
+exports.LimitPropertySchema = LimitPropertySchema;
+exports.OffsetPropertySchema = OffsetPropertySchema;
+exports.OutputPropertySchema = OutputPropertySchema;
+exports.ParamsPropertySchema = ParamsPropertySchema;
+exports.RelayFetchSchema = RelayFetchSchema;
+exports.ZapierSdkError = ZapierSdkError;
+exports.actionKeyResolver = actionKeyResolver;
+exports.actionTypeResolver = actionTypeResolver;
+exports.appKeyResolver = appKeyResolver;
+exports.authenticationIdResolver = authenticationIdResolver;
+exports.bundleCode = bundleCode;
+exports.createAppsPlugin = createAppsPlugin;
+exports.createZapierSdk = createZapierSdk;
+exports.fetch = fetch;
+exports.findFirstAuthentication = findFirstAuthentication;
+exports.findUniqueAuthentication = findUniqueAuthentication;
+exports.generateTypes = generateTypes;
+exports.getAction = getAction;
+exports.getApp = getApp;
+exports.getAuthentication = getAuthentication;
+exports.getResolutionOrder = getResolutionOrder;
+exports.getResolutionOrderForParams = getResolutionOrderForParams;
+exports.getResolvableParams = getResolvableParams;
+exports.getResolver = getResolver;
+exports.getResolversForMissingParams = getResolversForMissingParams;
+exports.getTokenFromCliLogin = getTokenFromCliLogin;
+exports.getTokenFromEnv = getTokenFromEnv;
+exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
+exports.hasResolver = hasResolver;
+exports.inputsResolver = inputsResolver;
+exports.isPositional = isPositional;
+exports.listActions = listActions;
+exports.listApps = listApps;
+exports.listAuthentications = listAuthentications;
+exports.listFields = listFields;
+exports.relayFetch = relayFetch;
+exports.resolverRegistry = resolverRegistry;
+exports.runAction = runAction;