@zapier/zapier-sdk 0.18.4 → 1.0.0

package/dist/credentials.js

@@ -0,0 +1,174 @@
+/**
+ * Credentials Resolution
+ *
+ * This module provides the core logic for resolving credentials from various sources:
+ * - Explicit credentials option
+ * - Deprecated token option
+ * - Environment variables (new and deprecated)
+ * - CLI login stored tokens
+ */
+import { isCredentialsFunction, isCredentialsObject, } from "./types/credentials";
+import { logDeprecation } from "./utils/logging";
+import { getZapierBaseUrl } from "./utils/url-utils";
+import { ZAPIER_CREDENTIALS, ZAPIER_CREDENTIALS_CLIENT_ID, ZAPIER_CREDENTIALS_CLIENT_SECRET, ZAPIER_CREDENTIALS_BASE_URL, ZAPIER_CREDENTIALS_SCOPE, ZAPIER_TOKEN, ZAPIER_AUTH_BASE_URL, ZAPIER_AUTH_CLIENT_ID, } from "./constants";
+/**
+ * Derive the auth base URL from the SDK base URL.
+ * Returns the Zapier root domain (e.g., https://zapier.com from https://api.zapier.com).
+ */
+function deriveAuthBaseUrl(sdkBaseUrl) {
+    if (!sdkBaseUrl)
+        return undefined;
+    return getZapierBaseUrl(sdkBaseUrl);
+}
+/**
+ * Normalize a credentials object by ensuring it has a type and resolved baseUrl.
+ */
+function normalizeCredentialsObject(obj, sdkBaseUrl) {
+    // Resolve baseUrl: use credentials baseUrl, or derive from SDK baseUrl
+    const resolvedBaseUrl = obj.baseUrl || deriveAuthBaseUrl(sdkBaseUrl);
+    // Explicitly construct the correct typed object to satisfy TypeScript
+    if (obj.type === "client_credentials" ||
+        ("clientSecret" in obj && obj.clientSecret)) {
+        return {
+            type: "client_credentials",
+            clientId: obj.clientId,
+            clientSecret: obj.clientSecret,
+            baseUrl: resolvedBaseUrl,
+            scope: obj.scope,
+        };
+    }
+    return {
+        type: "pkce",
+        clientId: obj.clientId,
+        baseUrl: resolvedBaseUrl,
+        scope: obj.scope,
+    };
+}
+/**
+ * Resolve credentials from environment variables.
+ *
+ * Precedence:
+ * 1. ZAPIER_CREDENTIALS (string token)
+ * 2. ZAPIER_CREDENTIALS_CLIENT_ID + ZAPIER_CREDENTIALS_CLIENT_SECRET (client credentials)
+ * 3. ZAPIER_CREDENTIALS_CLIENT_ID alone (PKCE)
+ * 4. Deprecated ZAPIER_TOKEN, ZAPIER_AUTH_* vars (with warnings)
+ *
+ * @param sdkBaseUrl - SDK base URL used to derive auth base URL if not specified
+ */
+export function resolveCredentialsFromEnv(sdkBaseUrl) {
+    // 1. Check ZAPIER_CREDENTIALS (string token only)
+    if (ZAPIER_CREDENTIALS) {
+        return ZAPIER_CREDENTIALS;
+    }
+    // 2. Check ZAPIER_CREDENTIALS_* individual vars
+    if (ZAPIER_CREDENTIALS_CLIENT_ID) {
+        const resolvedBaseUrl = ZAPIER_CREDENTIALS_BASE_URL || deriveAuthBaseUrl(sdkBaseUrl);
+        // Infer type from presence of clientSecret
+        if (ZAPIER_CREDENTIALS_CLIENT_SECRET) {
+            return {
+                type: "client_credentials",
+                clientId: ZAPIER_CREDENTIALS_CLIENT_ID,
+                clientSecret: ZAPIER_CREDENTIALS_CLIENT_SECRET,
+                baseUrl: resolvedBaseUrl,
+                scope: ZAPIER_CREDENTIALS_SCOPE,
+            };
+        }
+        else {
+            return {
+                type: "pkce",
+                clientId: ZAPIER_CREDENTIALS_CLIENT_ID,
+                baseUrl: resolvedBaseUrl,
+                scope: ZAPIER_CREDENTIALS_SCOPE,
+            };
+        }
+    }
+    // 3. Check deprecated env vars (with warnings)
+    if (ZAPIER_TOKEN) {
+        logDeprecation("ZAPIER_TOKEN is deprecated. Use ZAPIER_CREDENTIALS instead.");
+        return ZAPIER_TOKEN;
+    }
+    if (ZAPIER_AUTH_CLIENT_ID) {
+        logDeprecation("ZAPIER_AUTH_CLIENT_ID is deprecated. Use ZAPIER_CREDENTIALS_CLIENT_ID instead.");
+        if (ZAPIER_AUTH_BASE_URL) {
+            logDeprecation("ZAPIER_AUTH_BASE_URL is deprecated. Use ZAPIER_CREDENTIALS_BASE_URL instead.");
+        }
+        const resolvedBaseUrl = ZAPIER_AUTH_BASE_URL || deriveAuthBaseUrl(sdkBaseUrl);
+        return {
+            type: "pkce",
+            clientId: ZAPIER_AUTH_CLIENT_ID,
+            baseUrl: resolvedBaseUrl,
+        };
+    }
+    return undefined;
+}
+/**
+ * Resolve credentials from all possible sources.
+ *
+ * Precedence:
+ * 1. Explicit credentials option
+ * 2. Deprecated token option (with warning)
+ * 3. Environment variables
+ * 4. CLI login stored token (handled separately in auth.ts)
+ *
+ * If credentials is a function, it is called and must return
+ * a string or credentials object (not another function).
+ *
+ * The baseUrl option is used to derive the auth base URL if not
+ * specified in credentials.
+ */
+export async function resolveCredentials(options = {}) {
+    const { baseUrl } = options;
+    // 1. Check explicit credentials option
+    if (options.credentials !== undefined) {
+        // If it's a function, call it
+        if (isCredentialsFunction(options.credentials)) {
+            const resolved = await options.credentials();
+            // Validate that the function didn't return another function
+            if (typeof resolved === "function") {
+                throw new Error("Credentials function returned another function. " +
+                    "Credentials functions must return a string or credentials object.");
+            }
+            // Normalize object if needed
+            if (isCredentialsObject(resolved)) {
+                return normalizeCredentialsObject(resolved, baseUrl);
+            }
+            return resolved;
+        }
+        // If it's an object, normalize it
+        if (isCredentialsObject(options.credentials)) {
+            return normalizeCredentialsObject(options.credentials, baseUrl);
+        }
+        // It's a string token
+        return options.credentials;
+    }
+    // 2. Check deprecated token option (with warning)
+    if (options.token !== undefined) {
+        logDeprecation("The `token` option is deprecated. Use `credentials` instead.");
+        return options.token;
+    }
+    // 3. Check environment variables
+    const envCredentials = resolveCredentialsFromEnv(baseUrl);
+    if (envCredentials !== undefined) {
+        return envCredentials;
+    }
+    // 4. CLI login is handled separately in auth.ts
+    return undefined;
+}
+/**
+ * Extract the base URL from credentials for use in auth flows.
+ */
+export function getBaseUrlFromCredentials(credentials) {
+    if (credentials && isCredentialsObject(credentials)) {
+        return credentials.baseUrl;
+    }
+    return undefined;
+}
+/**
+ * Extract the client ID from credentials for use in auth flows.
+ */
+export function getClientIdFromCredentials(credentials) {
+    if (credentials && isCredentialsObject(credentials)) {
+        return credentials.clientId;
+    }
+    return undefined;
+}

package/dist/index.cjs

@@ -58,6 +58,14 @@ function isPositional(schema) {
 // src/constants.ts
 var ZAPIER_BASE_URL = process.env.ZAPIER_BASE_URL || "https://zapier.com";
 var MAX_PAGE_LIMIT = 1e4;
+var ZAPIER_CREDENTIALS = process.env.ZAPIER_CREDENTIALS;
+var ZAPIER_CREDENTIALS_CLIENT_ID = process.env.ZAPIER_CREDENTIALS_CLIENT_ID;
+var ZAPIER_CREDENTIALS_CLIENT_SECRET = process.env.ZAPIER_CREDENTIALS_CLIENT_SECRET;
+var ZAPIER_CREDENTIALS_BASE_URL = process.env.ZAPIER_CREDENTIALS_BASE_URL;
+var ZAPIER_CREDENTIALS_SCOPE = process.env.ZAPIER_CREDENTIALS_SCOPE;
+var ZAPIER_TOKEN = process.env.ZAPIER_TOKEN;
+var ZAPIER_AUTH_BASE_URL = process.env.ZAPIER_AUTH_BASE_URL;
+var ZAPIER_AUTH_CLIENT_ID = process.env.ZAPIER_AUTH_CLIENT_ID;
 
 // src/types/properties.ts
 var AppKeyPropertySchema = withPositional(
@@ -3465,36 +3473,29 @@ async function pollUntilComplete(options) {
   }
 }
 
-// src/auth.ts
-function getTokenFromEnv() {
-  return process.env.ZAPIER_TOKEN;
+// src/types/credentials.ts
+function isClientCredentials(credentials) {
+  return typeof credentials === "object" && credentials !== null && "clientId" in credentials && "clientSecret" in credentials;
 }
-async function getTokenFromCliLogin(options = {}) {
-  try {
-    const { getToken } = await import('@zapier/zapier-sdk-cli-login');
-    return await getToken(options);
-  } catch {
-    return void 0;
-  }
+function isPkceCredentials(credentials) {
+  return typeof credentials === "object" && credentials !== null && "clientId" in credentials && !("clientSecret" in credentials);
 }
-async function getTokenFromEnvOrConfig(options = {}) {
-  const envToken = getTokenFromEnv();
-  if (envToken) {
-    return envToken;
-  }
-  return getTokenFromCliLogin(options);
+function isCredentialsObject(credentials) {
+  return typeof credentials === "object" && credentials !== null && "clientId" in credentials;
 }
-async function resolveAuthToken(options = {}) {
-  if (options.token) {
-    return options.token;
-  }
-  if (options.getToken) {
-    const token = await options.getToken();
-    if (token) {
-      return token;
-    }
-  }
-  return getTokenFromEnvOrConfig(options);
+function isCredentialsFunction(credentials) {
+  return typeof credentials === "function";
+}
+
+// src/utils/logging.ts
+var loggedDeprecations = /* @__PURE__ */ new Set();
+function logDeprecation(message) {
+  if (loggedDeprecations.has(message)) return;
+  loggedDeprecations.add(message);
+  console.warn(`[zapier-sdk] Deprecation: ${message}`);
+}
+function resetDeprecationWarnings() {
+  loggedDeprecations.clear();
 }
 
 // src/utils/url-utils.ts
@@ -3543,6 +3544,278 @@ function getTrackingBaseUrl({
   return ZAPIER_BASE_URL;
 }
 
+// src/credentials.ts
+function deriveAuthBaseUrl(sdkBaseUrl) {
+  if (!sdkBaseUrl) return void 0;
+  return getZapierBaseUrl(sdkBaseUrl);
+}
+function normalizeCredentialsObject(obj, sdkBaseUrl) {
+  const resolvedBaseUrl = obj.baseUrl || deriveAuthBaseUrl(sdkBaseUrl);
+  if (obj.type === "client_credentials" || "clientSecret" in obj && obj.clientSecret) {
+    return {
+      type: "client_credentials",
+      clientId: obj.clientId,
+      clientSecret: obj.clientSecret,
+      baseUrl: resolvedBaseUrl,
+      scope: obj.scope
+    };
+  }
+  return {
+    type: "pkce",
+    clientId: obj.clientId,
+    baseUrl: resolvedBaseUrl,
+    scope: obj.scope
+  };
+}
+function resolveCredentialsFromEnv(sdkBaseUrl) {
+  if (ZAPIER_CREDENTIALS) {
+    return ZAPIER_CREDENTIALS;
+  }
+  if (ZAPIER_CREDENTIALS_CLIENT_ID) {
+    const resolvedBaseUrl = ZAPIER_CREDENTIALS_BASE_URL || deriveAuthBaseUrl(sdkBaseUrl);
+    if (ZAPIER_CREDENTIALS_CLIENT_SECRET) {
+      return {
+        type: "client_credentials",
+        clientId: ZAPIER_CREDENTIALS_CLIENT_ID,
+        clientSecret: ZAPIER_CREDENTIALS_CLIENT_SECRET,
+        baseUrl: resolvedBaseUrl,
+        scope: ZAPIER_CREDENTIALS_SCOPE
+      };
+    } else {
+      return {
+        type: "pkce",
+        clientId: ZAPIER_CREDENTIALS_CLIENT_ID,
+        baseUrl: resolvedBaseUrl,
+        scope: ZAPIER_CREDENTIALS_SCOPE
+      };
+    }
+  }
+  if (ZAPIER_TOKEN) {
+    logDeprecation(
+      "ZAPIER_TOKEN is deprecated. Use ZAPIER_CREDENTIALS instead."
+    );
+    return ZAPIER_TOKEN;
+  }
+  if (ZAPIER_AUTH_CLIENT_ID) {
+    logDeprecation(
+      "ZAPIER_AUTH_CLIENT_ID is deprecated. Use ZAPIER_CREDENTIALS_CLIENT_ID instead."
+    );
+    if (ZAPIER_AUTH_BASE_URL) {
+      logDeprecation(
+        "ZAPIER_AUTH_BASE_URL is deprecated. Use ZAPIER_CREDENTIALS_BASE_URL instead."
+      );
+    }
+    const resolvedBaseUrl = ZAPIER_AUTH_BASE_URL || deriveAuthBaseUrl(sdkBaseUrl);
+    return {
+      type: "pkce",
+      clientId: ZAPIER_AUTH_CLIENT_ID,
+      baseUrl: resolvedBaseUrl
+    };
+  }
+  return void 0;
+}
+async function resolveCredentials(options = {}) {
+  const { baseUrl } = options;
+  if (options.credentials !== void 0) {
+    if (isCredentialsFunction(options.credentials)) {
+      const resolved = await options.credentials();
+      if (typeof resolved === "function") {
+        throw new Error(
+          "Credentials function returned another function. Credentials functions must return a string or credentials object."
+        );
+      }
+      if (isCredentialsObject(resolved)) {
+        return normalizeCredentialsObject(resolved, baseUrl);
+      }
+      return resolved;
+    }
+    if (isCredentialsObject(options.credentials)) {
+      return normalizeCredentialsObject(options.credentials, baseUrl);
+    }
+    return options.credentials;
+  }
+  if (options.token !== void 0) {
+    logDeprecation(
+      "The `token` option is deprecated. Use `credentials` instead."
+    );
+    return options.token;
+  }
+  const envCredentials = resolveCredentialsFromEnv(baseUrl);
+  if (envCredentials !== void 0) {
+    return envCredentials;
+  }
+  return void 0;
+}
+function getBaseUrlFromCredentials(credentials) {
+  if (credentials && isCredentialsObject(credentials)) {
+    return credentials.baseUrl;
+  }
+  return void 0;
+}
+function getClientIdFromCredentials(credentials) {
+  if (credentials && isCredentialsObject(credentials)) {
+    return credentials.clientId;
+  }
+  return void 0;
+}
+
+// src/auth.ts
+var tokenCache = /* @__PURE__ */ new Map();
+var pendingExchanges = /* @__PURE__ */ new Map();
+function clearTokenCache() {
+  tokenCache.clear();
+  pendingExchanges.clear();
+}
+var TOKEN_EXPIRATION_BUFFER = 5 * 60 * 1e3;
+function getCachedToken(clientId) {
+  const cached = tokenCache.get(clientId);
+  if (!cached) return void 0;
+  if (cached.expiresAt > Date.now() + TOKEN_EXPIRATION_BUFFER) {
+    return cached.accessToken;
+  }
+  tokenCache.delete(clientId);
+  return void 0;
+}
+function cacheToken(clientId, accessToken, expiresIn) {
+  tokenCache.set(clientId, {
+    accessToken,
+    expiresAt: Date.now() + expiresIn * 1e3
+  });
+}
+function invalidateCachedToken(clientId) {
+  tokenCache.delete(clientId);
+}
+function getTokenEndpointUrl(baseUrl) {
+  const base = baseUrl || ZAPIER_BASE_URL;
+  return `${base}/oauth/token/`;
+}
+async function exchangeClientCredentials(options) {
+  const { clientId, clientSecret, baseUrl, scope, onEvent } = options;
+  const fetchFn = options.fetch || globalThis.fetch;
+  const tokenUrl = getTokenEndpointUrl(baseUrl);
+  onEvent?.({
+    type: "auth_exchanging",
+    payload: {
+      message: "Exchanging client credentials for token...",
+      operation: "client_credentials"
+    },
+    timestamp: Date.now()
+  });
+  const response = await fetchFn(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: clientId,
+      client_secret: clientSecret,
+      scope: scope || "external",
+      audience: "zapier.com"
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    onEvent?.({
+      type: "auth_error",
+      payload: {
+        message: `Client credentials exchange failed: ${response.status}`,
+        error: errorText,
+        operation: "client_credentials"
+      },
+      timestamp: Date.now()
+    });
+    throw new Error(
+      `Client credentials exchange failed: ${response.status} ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.access_token) {
+    throw new Error("Client credentials response missing access_token");
+  }
+  const expiresIn = data.expires_in || 3600;
+  cacheToken(clientId, data.access_token, expiresIn);
+  onEvent?.({
+    type: "auth_success",
+    payload: {
+      message: "Client credentials exchange successful",
+      operation: "client_credentials"
+    },
+    timestamp: Date.now()
+  });
+  return data.access_token;
+}
+async function getTokenFromCliLogin(options) {
+  try {
+    const cliLogin = await import('@zapier/zapier-sdk-cli-login');
+    return await cliLogin.getToken(options);
+  } catch {
+    return void 0;
+  }
+}
+async function resolveAuthToken(options = {}) {
+  const credentials = await resolveCredentials({
+    credentials: options.credentials,
+    token: options.token
+  });
+  if (credentials !== void 0) {
+    return resolveAuthTokenFromCredentials(credentials, options);
+  }
+  return getTokenFromCliLogin({
+    onEvent: options.onEvent,
+    fetch: options.fetch
+  });
+}
+async function resolveAuthTokenFromCredentials(credentials, options) {
+  if (typeof credentials === "string") {
+    return credentials;
+  }
+  if (isClientCredentials(credentials)) {
+    const { clientId } = credentials;
+    const cached = getCachedToken(clientId);
+    if (cached) {
+      return cached;
+    }
+    const pending = pendingExchanges.get(clientId);
+    if (pending) {
+      return pending;
+    }
+    const exchangePromise = exchangeClientCredentials({
+      clientId: credentials.clientId,
+      clientSecret: credentials.clientSecret,
+      baseUrl: credentials.baseUrl || options.baseUrl,
+      scope: credentials.scope,
+      fetch: options.fetch,
+      onEvent: options.onEvent
+    }).finally(() => {
+      pendingExchanges.delete(clientId);
+    });
+    pendingExchanges.set(clientId, exchangePromise);
+    return exchangePromise;
+  }
+  if (isPkceCredentials(credentials)) {
+    const storedToken = await getTokenFromCliLogin({
+      onEvent: options.onEvent,
+      fetch: options.fetch,
+      credentials
+    });
+    if (storedToken) {
+      return storedToken;
+    }
+    throw new Error(
+      "PKCE credentials require interactive login. Please run the 'login' command with the CLI first, or use client_credentials flow."
+    );
+  }
+  throw new Error("Unknown credentials type");
+}
+async function invalidateCredentialsToken(options) {
+  const resolved = await resolveCredentials(options);
+  const clientId = getClientIdFromCredentials(resolved);
+  if (clientId) {
+    invalidateCachedToken(clientId);
+  }
+}
+
 // src/api/client.ts
 var pathConfig = {
   // e.g. /relay -> https://sdkapi.zapier.com/api/v0/sdk/relay/...
@@ -3600,13 +3873,11 @@ var ZapierApiClient = class {
   // Helper to get a token from the different places it could be gotten
   async getAuthToken() {
     return resolveAuthToken({
+      credentials: this.options.credentials,
       token: this.options.token,
-      getToken: this.options.getToken,
       onEvent: this.options.onEvent,
       fetch: this.options.fetch,
-      baseUrl: this.options.baseUrl,
-      authBaseUrl: this.options.authBaseUrl,
-      authClientId: this.options.authClientId
+      baseUrl: this.options.baseUrl
     });
   }
   // Helper to handle responses
@@ -3644,10 +3915,16 @@ var ZapierApiClient = class {
     if (response.status === 401 || response.status === 403) {
       if (wasMissingAuthToken) {
         throw new ZapierAuthenticationError(
-          `Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`,
+          `Authentication required (HTTP ${response.status}). Please provide credentials in options or set ZAPIER_CREDENTIALS environment variable.`,
           errorOptions
         );
       }
+      if (response.status === 401) {
+        await invalidateCredentialsToken({
+          credentials: this.options.credentials,
+          token: this.options.token
+        });
+      }
       throw new ZapierAuthenticationError(message, errorOptions);
     }
     if (response.status === 400) {
@@ -3783,7 +4060,7 @@ var ZapierApiClient = class {
     if (options.authRequired) {
       if (headers.get("Authorization") == null && authToken == null) {
         throw new ZapierAuthenticationError(
-          `Authentication required but no token available. Please set ZAPIER_TOKEN, or run the 'login' command with the CLI.`
+          `Authentication required but no credentials available. Please set ZAPIER_CREDENTIALS, or run the 'login' command with the CLI.`
         );
       }
     }
@@ -3859,27 +4136,28 @@ var apiPlugin = (params) => {
   const {
     fetch: customFetch = globalThis.fetch,
     baseUrl = ZAPIER_BASE_URL,
-    authBaseUrl,
-    authClientId,
+    credentials,
     token,
-    getToken,
     onEvent,
     debug = false
   } = params.context.options;
   const api = createZapierApi({
     baseUrl,
-    authBaseUrl,
-    authClientId,
+    credentials,
     token,
-    getToken,
     debug,
     fetch: customFetch,
     onEvent
   });
   return {
     context: {
-      api
+      api,
       // Provide API client in context for other plugins to use
+      resolveCredentials: () => resolveCredentials({
+        credentials,
+        token,
+        baseUrl
+      })
     }
   };
 };
@@ -4473,7 +4751,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.18.4"};
+  version: "1.0.0"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4646,11 +4924,9 @@ var eventEmissionPlugin = ({ context }) => {
   const getUserContext = (async () => {
     try {
       const token = await resolveAuthToken({
+        credentials: context.options.credentials,
         token: context.options.token,
-        getToken: context.options.getToken,
         baseUrl: context.options.baseUrl,
-        authBaseUrl: context.options.authBaseUrl,
-        authClientId: context.options.authClientId,
         onEvent: context.options.onEvent,
         fetch: context.options.fetch
       });
@@ -4929,7 +5205,15 @@ exports.OutputPropertySchema = OutputPropertySchema;
 exports.ParamsPropertySchema = ParamsPropertySchema;
 exports.RelayFetchSchema = RelayFetchSchema;
 exports.RelayRequestSchema = RelayRequestSchema;
+exports.ZAPIER_AUTH_BASE_URL = ZAPIER_AUTH_BASE_URL;
+exports.ZAPIER_AUTH_CLIENT_ID = ZAPIER_AUTH_CLIENT_ID;
 exports.ZAPIER_BASE_URL = ZAPIER_BASE_URL;
+exports.ZAPIER_CREDENTIALS = ZAPIER_CREDENTIALS;
+exports.ZAPIER_CREDENTIALS_BASE_URL = ZAPIER_CREDENTIALS_BASE_URL;
+exports.ZAPIER_CREDENTIALS_CLIENT_ID = ZAPIER_CREDENTIALS_CLIENT_ID;
+exports.ZAPIER_CREDENTIALS_CLIENT_SECRET = ZAPIER_CREDENTIALS_CLIENT_SECRET;
+exports.ZAPIER_CREDENTIALS_SCOPE = ZAPIER_CREDENTIALS_SCOPE;
+exports.ZAPIER_TOKEN = ZAPIER_TOKEN;
 exports.ZapierActionError = ZapierActionError;
 exports.ZapierApiError = ZapierApiError;
 exports.ZapierAppNotFoundError = ZapierAppNotFoundError;
@@ -4954,6 +5238,7 @@ exports.buildApplicationLifecycleEvent = buildApplicationLifecycleEvent;
 exports.buildErrorEvent = buildErrorEvent;
 exports.buildErrorEventWithContext = buildErrorEventWithContext;
 exports.buildMethodCalledEvent = buildMethodCalledEvent;
+exports.clearTokenCache = clearTokenCache;
 exports.createBaseEvent = createBaseEvent;
 exports.createFunction = createFunction;
 exports.createSdk = createSdk;
@@ -4968,7 +5253,9 @@ exports.generateEventId = generateEventId;
 exports.getActionPlugin = getActionPlugin;
 exports.getAppPlugin = getAppPlugin;
 exports.getAuthenticationPlugin = getAuthenticationPlugin;
+exports.getBaseUrlFromCredentials = getBaseUrlFromCredentials;
 exports.getCiPlatform = getCiPlatform;
+exports.getClientIdFromCredentials = getClientIdFromCredentials;
 exports.getCpuTime = getCpuTime;
 exports.getCurrentTimestamp = getCurrentTimestamp;
 exports.getMemoryUsage = getMemoryUsage;
@@ -4978,22 +5265,30 @@ exports.getPreferredManifestEntryKey = getPreferredManifestEntryKey;
 exports.getProfilePlugin = getProfilePlugin;
 exports.getReleaseId = getReleaseId;
 exports.getTokenFromCliLogin = getTokenFromCliLogin;
-exports.getTokenFromEnv = getTokenFromEnv;
-exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
 exports.inputFieldKeyResolver = inputFieldKeyResolver;
 exports.inputsAllOptionalResolver = inputsAllOptionalResolver;
 exports.inputsResolver = inputsResolver;
+exports.invalidateCachedToken = invalidateCachedToken;
+exports.invalidateCredentialsToken = invalidateCredentialsToken;
 exports.isCi = isCi;
+exports.isClientCredentials = isClientCredentials;
+exports.isCredentialsFunction = isCredentialsFunction;
+exports.isCredentialsObject = isCredentialsObject;
+exports.isPkceCredentials = isPkceCredentials;
 exports.isPositional = isPositional;
 exports.listActionsPlugin = listActionsPlugin;
 exports.listAppsPlugin = listAppsPlugin;
 exports.listAuthenticationsPlugin = listAuthenticationsPlugin;
 exports.listInputFieldsPlugin = listInputFieldsPlugin;
+exports.logDeprecation = logDeprecation;
 exports.manifestPlugin = manifestPlugin;
 exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
 exports.requestPlugin = requestPlugin;
+exports.resetDeprecationWarnings = resetDeprecationWarnings;
 exports.resolveAuthToken = resolveAuthToken;
+exports.resolveCredentials = resolveCredentials;
+exports.resolveCredentialsFromEnv = resolveCredentialsFromEnv;
 exports.runActionPlugin = runActionPlugin;
 exports.toSnakeCase = toSnakeCase;
 exports.toTitleCase = toTitleCase;