@zapier/zapier-sdk 0.4.0 → 0.4.1

package/dist/index.cjs

@@ -2,71 +2,6 @@
 
 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) {
@@ -153,16 +88,16 @@ function createActionFunction(appKey, actionType, actionKey, options, pinnedAuth
 }
 function createActionTypeProxy(appKey, actionType, options, pinnedAuthId) {
   if (actionType === "fetch") {
-    return async (fetchOptions) => {
+    return async (url, init) => {
       const { sdk } = options;
-      const authenticationId = pinnedAuthId || fetchOptions.authenticationId;
+      const authenticationId = pinnedAuthId || init?.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,
+      return sdk.fetch(url, {
+        ...init,
         authenticationId
       });
     };
@@ -235,8 +170,47 @@ function createAppsPlugin(options) {
   return createAppsProxy(options);
 }
 
-// src/index.ts
-init_auth();
+// src/plugins/fetch/index.ts
+function createFetchPlugin(options) {
+  const { sdk } = options;
+  return async function fetch(url, init) {
+    const {
+      authenticationId,
+      callbackUrl,
+      authenticationTemplate,
+      ...fetchInit
+    } = init || {};
+    return sdk.request({
+      url: url.toString(),
+      method: fetchInit.method,
+      body: fetchInit.body,
+      headers: fetchInit.headers,
+      authenticationId,
+      callbackUrl,
+      authenticationTemplate
+    });
+  };
+}
+
+// src/auth.ts
+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);
+}
 
 // src/resolvers/appKey.ts
 var appKeyResolver = {
@@ -388,8 +362,21 @@ function getResolutionOrderForParams(paramNames) {
   return order;
 }
 
-// src/api/index.ts
-init_auth2();
+// src/api/auth.ts
+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}`;
+}
 
 // src/api/debug.ts
 function createDebugLogger(enabled) {
@@ -435,9 +422,7 @@ function createDebugFetch(options) {
 // src/api/polling.ts
 async function pollUntilComplete(options) {
   const {
-    fetch: fetch2,
-    url,
-    headers = {},
+    fetchPoll,
     maxAttempts = 30,
     initialDelay = 50,
     maxDelay = 1e3,
@@ -447,7 +432,7 @@ async function pollUntilComplete(options) {
   } = options;
   let delay = initialDelay;
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const response = await fetch2(url, { headers });
+    const response = await fetchPoll();
     if (response.status === successStatus) {
       const result = await response.json();
       return resultExtractor(result);
@@ -459,7 +444,7 @@ async function pollUntilComplete(options) {
       }
     } else {
       throw new Error(
-        `Request failed: GET ${url} - ${response.status} ${response.statusText}`
+        `Poll request failed: ${response.status} ${response.statusText}`
       );
     }
   }
@@ -467,9 +452,11 @@ async function pollUntilComplete(options) {
 }
 
 // src/api/client.ts
-init_auth2();
-init_auth();
-var SUBDOMAIN_PREFIXES = /* @__PURE__ */ new Set(["relay"]);
+var SUBDOMAIN_PREFIXES = {
+  relay: {
+    authHeader: "X-Relay-Authorization"
+  }
+};
 function createZapierApi(options) {
   const {
     baseUrl,
@@ -480,12 +467,14 @@ function createZapierApi(options) {
     onEvent
   } = options;
   const debugLog = createDebugLogger(debug);
-  const fetch2 = createDebugFetch({ originalFetch, debugLog });
+  const fetch = 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])) {
+    let subdomainConfig;
+    if (pathSegments.length > 0 && pathSegments[0] in SUBDOMAIN_PREFIXES) {
       const subdomain = pathSegments[0];
+      subdomainConfig = SUBDOMAIN_PREFIXES[subdomain];
       const baseUrlObj = new URL(baseUrl);
       baseUrlObj.hostname = `${subdomain}.${baseUrlObj.hostname}`;
       finalBaseUrl = baseUrlObj.toString();
@@ -497,9 +486,9 @@ function createZapierApi(options) {
         url.searchParams.set(key, value);
       });
     }
-    return url.toString();
+    return { url: url.toString(), subdomainConfig };
   }
-  async function buildHeaders(options2 = {}) {
+  async function buildHeaders(options2 = {}, subdomainConfig) {
     const headers = {
       ...options2.headers
     };
@@ -515,7 +504,8 @@ function createZapierApi(options) {
         });
       }
       if (resolvedToken) {
-        headers.Authorization = getAuthorizationHeader(resolvedToken);
+        const authHeaderName = subdomainConfig?.authHeader || "Authorization";
+        headers[authHeaderName] = getAuthorizationHeader(resolvedToken);
       }
     }
     return headers;
@@ -528,7 +518,7 @@ function createZapierApi(options) {
           throw customError;
         }
       }
-      if (response.status >= 400 && response.status < 500 && !hadAuthToken) {
+      if (response.status >= 400 && response.status < 500 && true) {
         throw new Error(
           `Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`
         );
@@ -541,14 +531,19 @@ function createZapierApi(options) {
       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);
+  async function plainFetch(path, init) {
+    if (!path.startsWith("/")) {
+      throw new Error(
+        `plainFetch expects a path starting with '/', got: ${path}`
+      );
+    }
+    const { url, subdomainConfig } = buildUrl(path, init?.searchParams);
+    const headers = await buildHeaders(init, subdomainConfig);
     const finalHeaders = {
       ...headers,
       ...init?.headers ? init.headers instanceof Headers ? Object.fromEntries(init.headers.entries()) : init.headers : {}
     };
-    return await fetch2(url, {
+    return await fetch(url, {
       ...init,
       headers: finalHeaders
     });
@@ -563,11 +558,9 @@ function createZapierApi(options) {
       body: data ? JSON.stringify(data) : void 0,
       headers,
       searchParams: options2.searchParams,
-      authRequired: options2.authRequired,
-      customErrorHandler: options2.customErrorHandler
+      authRequired: options2.authRequired
     });
-    const hadAuthToken = !!(await buildHeaders(options2)).Authorization;
-    return handleResponse(response, options2.customErrorHandler, hadAuthToken);
+    return handleResponse(response, options2.customErrorHandler);
   }
   return {
     async get(path, options2 = {}) {
@@ -583,12 +576,12 @@ function createZapierApi(options) {
       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,
+        fetchPoll: () => plainFetch(path, {
+          method: "GET",
+          searchParams: options2.searchParams,
+          authRequired: options2.authRequired
+        }),
         maxAttempts: options2.maxAttempts,
         initialDelay: options2.initialDelay,
         maxDelay: options2.maxDelay,
@@ -597,8 +590,8 @@ function createZapierApi(options) {
         resultExtractor: options2.resultExtractor
       });
     },
-    async fetch(input, init) {
-      return plainFetch(input, init);
+    async fetch(path, init) {
+      return plainFetch(path, init);
     }
   };
 }
@@ -1445,13 +1438,13 @@ async function bundleCode(options) {
   }
 }
 
-// src/functions/fetch/index.ts
+// src/functions/request/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) {
+async function request(options) {
   const {
     url,
     method = "GET",
@@ -1502,44 +1495,14 @@ async function relayFetch(url, options = {}, config = {}) {
   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
+    headers
   });
 }
-var RelayFetchSchema = zod.z.object({
-  url: zod.z.string().url().describe("The URL to fetch (will be proxied through Relay)"),
+var RelayRequestSchema = zod.z.object({
+  url: zod.z.string().url().describe("The URL to request (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"),
@@ -1549,6 +1512,7 @@ var RelayFetchSchema = zod.z.object({
   ),
   headers: zod.z.record(zod.z.string()).optional().describe("Request headers")
 }).describe("Make authenticated HTTP requests through Zapier's Relay service");
+var RelayFetchSchema = RelayRequestSchema;
 var AppItemSchema = withFormatter(
   zod.z.object({
     key: zod.z.string(),
@@ -1884,11 +1848,11 @@ var bundleCodeInfo = {
   implementation: bundleCode
 };
 
-// src/functions/fetch/info.ts
-var fetchInfo = {
-  name: "fetch",
-  inputSchema: RelayFetchSchema,
-  implementation: fetch
+// src/functions/request/info.ts
+var requestInfo = {
+  name: "request",
+  inputSchema: RelayRequestSchema,
+  implementation: request
 };
 
 // src/sdk.ts
@@ -1905,7 +1869,7 @@ var functionRegistry = [
   listFieldsInfo,
   generateTypesInfo,
   bundleCodeInfo,
-  fetchInfo
+  requestInfo
 ];
 function createZapierSdk(options = {}) {
   const {
@@ -1941,16 +1905,11 @@ function createZapierSdk(options = {}) {
     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
-    })
+    request: (options2) => request({ ...options2, api })
   };
+  const fullSdk = baseSdk;
+  fullSdk.apps = createAppsPlugin({ sdk: fullSdk });
+  fullSdk.fetch = createFetchPlugin({ sdk: fullSdk });
   return fullSdk;
 }
 
@@ -1966,6 +1925,7 @@ exports.OffsetPropertySchema = OffsetPropertySchema;
 exports.OutputPropertySchema = OutputPropertySchema;
 exports.ParamsPropertySchema = ParamsPropertySchema;
 exports.RelayFetchSchema = RelayFetchSchema;
+exports.RelayRequestSchema = RelayRequestSchema;
 exports.ZapierSdkError = ZapierSdkError;
 exports.actionKeyResolver = actionKeyResolver;
 exports.actionTypeResolver = actionTypeResolver;
@@ -1973,8 +1933,8 @@ exports.appKeyResolver = appKeyResolver;
 exports.authenticationIdResolver = authenticationIdResolver;
 exports.bundleCode = bundleCode;
 exports.createAppsPlugin = createAppsPlugin;
+exports.createFetchPlugin = createFetchPlugin;
 exports.createZapierSdk = createZapierSdk;
-exports.fetch = fetch;
 exports.findFirstAuthentication = findFirstAuthentication;
 exports.findUniqueAuthentication = findUniqueAuthentication;
 exports.generateTypes = generateTypes;
@@ -1997,5 +1957,6 @@ exports.listApps = listApps;
 exports.listAuthentications = listAuthentications;
 exports.listFields = listFields;
 exports.relayFetch = relayFetch;
+exports.request = request;
 exports.resolverRegistry = resolverRegistry;
 exports.runAction = runAction;

package/dist/index.d.mts

@@ -209,9 +209,17 @@ type ParamsProperty = z.infer<typeof ParamsPropertySchema>;
 interface AppFactoryOptions {
     authenticationId: number;
 }
-interface ActionTypeProxy {
+interface BaseActionTypeProxy {
     [action: string]: (options?: ActionExecutionOptions) => Promise<ActionExecutionResult>;
 }
+interface FetchActionType {
+    fetch: (url: string | URL, init?: RequestInit & {
+        authenticationId?: number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+    }) => Promise<Response>;
+}
+type ActionTypeProxy = BaseActionTypeProxy & Partial<FetchActionType>;
 interface AppProxy {
     [type: string]: ActionTypeProxy;
 }
@@ -487,7 +495,7 @@ interface BundleCodeSdkFunction {
     bundleCode: (options: BundleCodeOptions) => Promise<string>;
 }
 
-declare const RelayFetchSchema: z.ZodObject<{
+declare const RelayRequestSchema: z.ZodObject<{
     url: z.ZodString;
     method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]>>;
     body: z.ZodOptional<z.ZodString>;
@@ -512,17 +520,61 @@ declare const RelayFetchSchema: z.ZodObject<{
     authenticationTemplate?: string | undefined;
     headers?: Record<string, string> | undefined;
 }>;
-type RelayFetchOptions$1 = z.infer<typeof RelayFetchSchema> & FunctionOptions & {
+type RelayRequestOptions$1 = z.infer<typeof RelayRequestSchema> & FunctionOptions & {
     /** Base URL for Relay service */
     relayBaseUrl?: string;
 };
-interface RelayFetchSdkFunction {
-    fetch: (options: RelayFetchOptions$1) => Promise<Response>;
+interface RelayRequestSdkFunction {
+    request: (options: RelayRequestOptions$1) => Promise<Response>;
+}
+declare const RelayFetchSchema: z.ZodObject<{
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]>>;
+    body: z.ZodOptional<z.ZodString>;
+    authenticationId: z.ZodOptional<z.ZodNumber>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    authenticationTemplate: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    authenticationId?: number | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: string | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}, {
+    url: string;
+    authenticationId?: number | undefined;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+    body?: string | undefined;
+    callbackUrl?: string | undefined;
+    authenticationTemplate?: string | undefined;
+    headers?: Record<string, string> | undefined;
+}>;
+
+interface FetchPluginOptions {
+    sdk: ZapierSdk;
+}
+/**
+ * Creates a fetch function with standard fetch signature that delegates to sdk.request
+ */
+declare function createFetchPlugin(options: FetchPluginOptions): (url: string | URL, init?: RequestInit & {
+    authenticationId?: number;
+    callbackUrl?: string;
+    authenticationTemplate?: string;
+}) => Promise<Response>;
+interface FetchPluginSdkExtension {
+    fetch: (url: string | URL, init?: RequestInit & {
+        authenticationId?: number;
+        callbackUrl?: string;
+        authenticationTemplate?: string;
+    }) => Promise<Response>;
 }
 
-interface ZapierSdkFunctions extends ListActionsSdkFunction, GetActionSdkFunction, GetAppSdkFunction, RunActionSdkFunction, ListFieldsSdkFunction, ListAuthenticationsSdkFunction, GetAuthenticationSdkFunction, FindFirstAuthenticationSdkFunction, FindUniqueAuthenticationSdkFunction, GenerateTypesSdkFunction, ListAppsSdkFunction, BundleCodeSdkFunction, RelayFetchSdkFunction {
+interface ZapierSdkFunctions extends ListActionsSdkFunction, GetActionSdkFunction, GetAppSdkFunction, RunActionSdkFunction, ListFieldsSdkFunction, ListAuthenticationsSdkFunction, GetAuthenticationSdkFunction, FindFirstAuthenticationSdkFunction, FindUniqueAuthenticationSdkFunction, GenerateTypesSdkFunction, ListAppsSdkFunction, BundleCodeSdkFunction, RelayRequestSdkFunction {
 }
-interface ZapierSdkPlugins extends AppsPluginSdkExtension {
+interface ZapierSdkPlugins extends AppsPluginSdkExtension, FetchPluginSdkExtension {
 }
 interface BaseZapierSdk extends ZapierSdkFunctions {
     __registry: Array<{
@@ -786,11 +838,11 @@ declare function generateTypes(options: GenerateTypesOptions): Promise<string>;
  */
 declare function bundleCode(options: BundleCodeOptions): Promise<string>;
 
-interface RelayFetchOptions {
+interface RelayRequestOptions {
     /** HTTP method */
     method?: string;
-    /** Request body as a string */
-    body?: string;
+    /** Request body (can be string, FormData, Blob, etc.) */
+    body?: BodyInit | null;
     /** Request headers */
     headers?: HeadersInit;
     /** Zapier authentication ID to use for the request */
@@ -817,13 +869,13 @@ interface RelayFetchConfig extends FunctionOptions {
  * @returns Promise<Response> - The response from the request
  */
 /**
- * Schema-compatible wrapper function for the fetch functionality
+ * Schema-compatible wrapper function for the request functionality
  */
-declare function fetch$1(options: {
+declare function request(options: {
     url: string;
     method?: string;
-    body?: string;
-    headers?: Record<string, string>;
+    body?: BodyInit | null;
+    headers?: HeadersInit;
     authenticationId?: number;
     callbackUrl?: string;
     authenticationTemplate?: string;
@@ -831,10 +883,10 @@ declare function fetch$1(options: {
 /**
  * Internal fetch implementation
  */
-declare function relayFetch(url: string | URL, options?: RelayFetchOptions, config?: RelayFetchConfig): Promise<Response>;
+declare function relayFetch(url: string | URL, options?: RelayRequestOptions, config?: RelayFetchConfig): Promise<Response>;
 
 interface ZapierSdkOptions extends BaseSdkOptions {
 }
 declare function createZapierSdk(options?: ZapierSdkOptions): ZapierSdk;
 
-export { type Action, type ActionExecutionOptions, type ActionExecutionResult, type ActionField, type ActionFieldChoice, type ActionKeyProperty, ActionKeyPropertySchema, type ActionProxy, type ActionTypeProperty, ActionTypePropertySchema, type ApiEvent, type AppKeyProperty, AppKeyPropertySchema, AppNotFoundError, type AppsPluginOptions, type AppsPluginSdkExtension, type AuthEvent, type AuthObject, type AuthOptions, type Authentication, type AuthenticationIdProperty, AuthenticationIdPropertySchema, type AuthenticationsResponse, type BaseSdkOptions, type BaseZapierSdk, type Choice, type DebugProperty, DebugPropertySchema, type EventCallback, type Field, type FunctionOptions, type InputsProperty, InputsPropertySchema, type Integration, type LimitProperty, LimitPropertySchema, type LoadingEvent, type NeedsRequest, type NeedsResponse, type OffsetProperty, OffsetPropertySchema, type OutputProperty, OutputPropertySchema, type ParamsProperty, ParamsPropertySchema, RelayFetchSchema, type ResolverName, type ResolverType, type SdkEvent, type Trigger, type ZapierSdk, ZapierSdkError, type ZapierSdkOptions, actionKeyResolver, actionTypeResolver, appKeyResolver, authenticationIdResolver, bundleCode, createAppsPlugin, createZapierSdk, fetch$1 as fetch, findFirstAuthentication, findUniqueAuthentication, generateTypes, getAction, getApp, getAuthentication, getResolutionOrder, getResolutionOrderForParams, getResolvableParams, getResolver, getResolversForMissingParams, getTokenFromCliLogin, getTokenFromEnv, getTokenFromEnvOrConfig, hasResolver, inputsResolver, isPositional, listActions, listApps, listAuthentications, listFields, relayFetch, resolverRegistry, runAction };
+export { type Action, type ActionExecutionOptions, type ActionExecutionResult, type ActionField, type ActionFieldChoice, type ActionKeyProperty, ActionKeyPropertySchema, type ActionProxy, type ActionTypeProperty, ActionTypePropertySchema, type ApiEvent, type AppKeyProperty, AppKeyPropertySchema, AppNotFoundError, type AppsPluginOptions, type AppsPluginSdkExtension, type AuthEvent, type AuthObject, type AuthOptions, type Authentication, type AuthenticationIdProperty, AuthenticationIdPropertySchema, type AuthenticationsResponse, type BaseSdkOptions, type BaseZapierSdk, type Choice, type DebugProperty, DebugPropertySchema, type EventCallback, type FetchPluginOptions, type FetchPluginSdkExtension, type Field, type FunctionOptions, type InputsProperty, InputsPropertySchema, type Integration, type LimitProperty, LimitPropertySchema, type LoadingEvent, type NeedsRequest, type NeedsResponse, type OffsetProperty, OffsetPropertySchema, type OutputProperty, OutputPropertySchema, type ParamsProperty, ParamsPropertySchema, RelayFetchSchema, RelayRequestSchema, type ResolverName, type ResolverType, type SdkEvent, type Trigger, type ZapierSdk, ZapierSdkError, type ZapierSdkOptions, actionKeyResolver, actionTypeResolver, appKeyResolver, authenticationIdResolver, bundleCode, createAppsPlugin, createFetchPlugin, createZapierSdk, findFirstAuthentication, findUniqueAuthentication, generateTypes, getAction, getApp, getAuthentication, getResolutionOrder, getResolutionOrderForParams, getResolvableParams, getResolver, getResolversForMissingParams, getTokenFromCliLogin, getTokenFromEnv, getTokenFromEnvOrConfig, hasResolver, inputsResolver, isPositional, listActions, listApps, listAuthentications, listFields, relayFetch, request, resolverRegistry, runAction };