devflare 1.0.0-next.23 → 1.0.0-next.27

package/dist/index-jwd3fanx.js

@@ -1,412 +0,0 @@
-import {
-  createContextProxy,
-  createFetchEvent,
-  getContextOrNull,
-  runWithEventContext
-} from "./index-c1cj9085.js";
-
-// src/runtime/exports.ts
-function createReadonlyProxy(getter, name) {
-  return createContextProxy(getter, name, { mutable: false });
-}
-var env = createReadonlyProxy(() => getContextOrNull()?.env, "env");
-var ctx = createReadonlyProxy(() => getContextOrNull()?.ctx, "ctx");
-var event = createReadonlyProxy(() => getContextOrNull()?.event, "event");
-var locals = createContextProxy(() => getContextOrNull()?.locals, "locals");
-// src/runtime/middleware.ts
-var FETCH_SEQUENCE_SYMBOL = Symbol.for("devflare.fetch-sequence");
-var FETCH_RESOLVE_STYLE_SYMBOL = Symbol.for("devflare.fetch-resolve-style");
-var FETCH_WORKER_STYLE_SYMBOL = Symbol.for("devflare.fetch-worker-style");
-var QUEUE_WORKER_STYLE_SYMBOL = Symbol.for("devflare.queue-worker-style");
-var SCHEDULED_WORKER_STYLE_SYMBOL = Symbol.for("devflare.scheduled-worker-style");
-function createNotFoundResponse() {
-  return new Response("Not Found", { status: 404 });
-}
-function isFunction(value) {
-  return typeof value === "function";
-}
-function markResolveStyle(handler) {
-  Object.defineProperty(handler, FETCH_RESOLVE_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function markWorkerStyle(handler) {
-  Object.defineProperty(handler, FETCH_WORKER_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function defineFetchHandler(handler, options) {
-  if (options?.style === "resolve") {
-    return markResolveStyle(handler);
-  }
-  if (options?.style === "worker") {
-    return markWorkerStyle(handler);
-  }
-  return handler;
-}
-function hasResolveStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[FETCH_RESOLVE_STYLE_SYMBOL] || record[FETCH_SEQUENCE_SYMBOL]);
-}
-function hasWorkerStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[FETCH_WORKER_STYLE_SYMBOL]);
-}
-function isResolveStyleFunction(handler) {
-  return hasResolveStyleMarker(handler);
-}
-function assertExplicit2ArgStyle(handler) {
-  if (handler.length !== 2) {
-    return;
-  }
-  if (hasResolveStyleMarker(handler) || hasWorkerStyleMarker(handler)) {
-    return;
-  }
-  throw new Error("[devflare] Ambiguous 2-argument fetch handler. The calling convention must be declared explicitly via " + "`defineFetchHandler(fn, { style: 'resolve' })` (for `(event, resolve) => Response`) or " + "`defineFetchHandler(fn, { style: 'worker' })` (for `(request, env) => Response`). " + "Single-arg `(event) => Response` and 3-arg worker-style `(request, env, ctx) => Response` " + "handlers do not require wrapping.");
-}
-function defineQueueHandler(handler) {
-  Object.defineProperty(handler, QUEUE_WORKER_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function defineScheduledHandler(handler) {
-  Object.defineProperty(handler, SCHEDULED_WORKER_STYLE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: true,
-    writable: false
-  });
-  return handler;
-}
-function hasQueueWorkerStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[QUEUE_WORKER_STYLE_SYMBOL]);
-}
-function hasScheduledWorkerStyleMarker(handler) {
-  const record = handler;
-  return Boolean(record[SCHEDULED_WORKER_STYLE_SYMBOL]);
-}
-function assertExplicitQueueHandlerStyle(handler) {
-  if (handler.length !== 2) {
-    return;
-  }
-  if (hasQueueWorkerStyleMarker(handler)) {
-    return;
-  }
-  throw new Error("[devflare] Ambiguous 2-argument queue handler. The calling convention must be declared explicitly via " + "`defineQueueHandler(fn)` for `(batch, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(batch, env, ctx) => void` handlers do not require wrapping.");
-}
-function assertExplicitScheduledHandlerStyle(handler) {
-  if (handler.length !== 2) {
-    return;
-  }
-  if (hasScheduledWorkerStyleMarker(handler)) {
-    return;
-  }
-  throw new Error("[devflare] Ambiguous 2-argument scheduled handler. The calling convention must be declared explicitly via " + "`defineScheduledHandler(fn)` for `(controller, env) => void` worker-style handlers. " + "Single-arg `(event) => void` and 3-arg `(controller, env, ctx) => void` handlers do not require wrapping.");
-}
-function isWorkerStyleFetchFunction(handler) {
-  if (isResolveStyleFunction(handler)) {
-    return false;
-  }
-  if (handler.length >= 3) {
-    return true;
-  }
-  return hasWorkerStyleMarker(handler);
-}
-function invokeWorkerStyleFetchFunction(handler, event2) {
-  return handler(event2.request, event2.env, event2.ctx);
-}
-function bindMethod(target, key) {
-  if (!target || typeof target !== "object") {
-    return null;
-  }
-  const value = target[key];
-  if (!isFunction(value)) {
-    return null;
-  }
-  const boundHandler = value.bind(target);
-  if (isResolveStyleFunction(value)) {
-    markResolveStyle(boundHandler);
-  }
-  if (hasWorkerStyleMarker(value)) {
-    markWorkerStyle(boundHandler);
-  }
-  return boundHandler;
-}
-function createFetchSequence(middlewares) {
-  return async (event2, resolve = async () => createNotFoundResponse()) => {
-    const executeMiddleware = async (index, activeEvent) => {
-      if (index >= middlewares.length) {
-        return resolve(activeEvent);
-      }
-      const middleware = middlewares[index];
-      return middleware(activeEvent, async (nextEvent = activeEvent) => {
-        return executeMiddleware(index + 1, nextEvent);
-      });
-    };
-    return executeMiddleware(0, event2);
-  };
-}
-function sequence(...middlewares) {
-  const composed = createFetchSequence(middlewares);
-  Object.defineProperty(composed, FETCH_SEQUENCE_SYMBOL, {
-    value: true,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-  return markResolveStyle(composed);
-}
-function getDefaultHandleHandler(module) {
-  return bindMethod(module.default, "handle");
-}
-function getDefaultFetchHandler(module) {
-  const defaultExport = module.default;
-  if (isFunction(defaultExport)) {
-    return defaultExport;
-  }
-  return bindMethod(defaultExport, "fetch");
-}
-function getPrimaryFetchEntryCandidates(module) {
-  const candidates = [];
-  const namedHandle = isFunction(module.handle) ? module.handle : null;
-  if (namedHandle) {
-    candidates.push({
-      name: "handle",
-      handler: namedHandle
-    });
-  }
-  const namedFetch = isFunction(module.fetch) ? module.fetch : null;
-  if (namedFetch) {
-    candidates.push({
-      name: "fetch",
-      handler: namedFetch
-    });
-  }
-  const defaultHandle = getDefaultHandleHandler(module);
-  if (defaultHandle) {
-    candidates.push({
-      name: "default.handle",
-      handler: defaultHandle
-    });
-  }
-  const defaultFetch = getDefaultFetchHandler(module);
-  if (defaultFetch) {
-    candidates.push({
-      name: isFunction(module.default) ? "default" : "default.fetch",
-      handler: defaultFetch
-    });
-  }
-  return candidates;
-}
-function assertSinglePrimaryFetchEntry(candidates) {
-  if (candidates.length <= 1) {
-    return;
-  }
-  const foundEntries = candidates.map(({ name }) => `"${name}"`).join(", ");
-  throw new Error(`Ambiguous fetch entry module. Export exactly one primary fetch entry per module. ` + `Use either "fetch" or "handle" (or one default equivalent), not both. ` + `Found: ${foundEntries}`);
-}
-function resolveMethodHandler(module, method) {
-  const normalizedMethod = method.toUpperCase();
-  const directHandler = isFunction(module[normalizedMethod]) ? module[normalizedMethod] : bindMethod(module.default, normalizedMethod);
-  if (directHandler) {
-    return {
-      handler: directHandler,
-      stripBody: false
-    };
-  }
-  if (normalizedMethod === "HEAD") {
-    const getHandler = isFunction(module.GET) ? module.GET : bindMethod(module.default, "GET");
-    if (getHandler) {
-      return {
-        handler: getHandler,
-        stripBody: true
-      };
-    }
-  }
-  const allHandler = isFunction(module.ALL) ? module.ALL : bindMethod(module.default, "ALL");
-  if (allHandler) {
-    return {
-      handler: allHandler,
-      stripBody: false
-    };
-  }
-  return null;
-}
-async function invokeResolvedFetchHandler(handler, event2) {
-  if (isResolveStyleFunction(handler)) {
-    return handler(event2, async () => createNotFoundResponse());
-  }
-  if (isWorkerStyleFetchFunction(handler)) {
-    return invokeWorkerStyleFetchFunction(handler, event2);
-  }
-  assertExplicit2ArgStyle(handler);
-  return handler(event2);
-}
-function resolveFetchHandler(module) {
-  const candidates = getPrimaryFetchEntryCandidates(module);
-  assertSinglePrimaryFetchEntry(candidates);
-  return candidates[0]?.handler ?? null;
-}
-async function invokeFetchHandler(handler, event2, resolve = async () => createNotFoundResponse()) {
-  if (!isFunction(handler)) {
-    return resolve(event2);
-  }
-  if (isResolveStyleFunction(handler)) {
-    const response2 = await handler(event2, resolve);
-    return response2 ?? createNotFoundResponse();
-  }
-  if (isWorkerStyleFetchFunction(handler)) {
-    const response2 = await invokeWorkerStyleFetchFunction(handler, event2);
-    return response2 ?? createNotFoundResponse();
-  }
-  assertExplicit2ArgStyle(handler);
-  const response = await handler(event2);
-  return response ?? createNotFoundResponse();
-}
-function createResolveFetch(module, _currentEntry, initialEvent, options = {}) {
-  return async (nextEvent = initialEvent) => {
-    return runWithEventContext(nextEvent, async () => {
-      const methodResolution = resolveMethodHandler(module, nextEvent.request.method);
-      if (methodResolution) {
-        const response = await invokeResolvedFetchHandler(methodResolution.handler, nextEvent);
-        const finalResponse = response ?? createNotFoundResponse();
-        if (methodResolution.stripBody) {
-          return new Response(null, finalResponse);
-        }
-        return finalResponse;
-      }
-      if (options.fallbackResolve) {
-        return options.fallbackResolve(nextEvent);
-      }
-      return createNotFoundResponse();
-    });
-  };
-}
-async function invokeFetchModule(module, event2, fallbackResolve) {
-  const handler = resolveFetchHandler(module);
-  if (!handler) {
-    return createResolveFetch(module, null, event2, { fallbackResolve })(event2);
-  }
-  return invokeFetchHandler(handler, event2, createResolveFetch(module, handler, event2, { fallbackResolve }));
-}
-// src/runtime/router/index.ts
-function normalizePathname(pathname) {
-  if (!pathname || pathname === "/") {
-    return "/";
-  }
-  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  const trimmed = normalized.replace(/\/+$|\/+$/g, "");
-  return trimmed === "" ? "/" : trimmed;
-}
-function decodePathSegment(segment) {
-  try {
-    return decodeURIComponent(segment);
-  } catch {
-    return segment;
-  }
-}
-function getPathSegments(pathname) {
-  const normalizedPathname = normalizePathname(pathname);
-  if (normalizedPathname === "/") {
-    return [];
-  }
-  return normalizedPathname.slice(1).split("/").filter(Boolean).map(decodePathSegment);
-}
-function getMatchPathname(input) {
-  if (input instanceof Request) {
-    return new URL(input.url).pathname;
-  }
-  if (input instanceof URL) {
-    return input.pathname;
-  }
-  if (input.includes("://")) {
-    return new URL(input).pathname;
-  }
-  return input;
-}
-function matchRouteSegments(routeSegments, pathnameSegments) {
-  if (routeSegments.length === 0) {
-    return pathnameSegments.length === 0 ? {} : null;
-  }
-  const params = {};
-  let routeIndex = 0;
-  let pathIndex = 0;
-  while (routeIndex < routeSegments.length) {
-    const routeSegment = routeSegments[routeIndex];
-    if (routeSegment.type === "optional-rest") {
-      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
-      pathIndex = pathnameSegments.length;
-      routeIndex += 1;
-      continue;
-    }
-    if (routeSegment.type === "rest") {
-      if (pathIndex >= pathnameSegments.length) {
-        return null;
-      }
-      params[routeSegment.name] = pathnameSegments.slice(pathIndex).join("/");
-      pathIndex = pathnameSegments.length;
-      routeIndex += 1;
-      continue;
-    }
-    const pathnameSegment = pathnameSegments[pathIndex];
-    if (pathnameSegment === undefined) {
-      return null;
-    }
-    if (routeSegment.type === "static") {
-      if (pathnameSegment !== routeSegment.value) {
-        return null;
-      }
-    } else {
-      params[routeSegment.name] = pathnameSegment;
-    }
-    pathIndex += 1;
-    routeIndex += 1;
-  }
-  if (pathIndex !== pathnameSegments.length) {
-    return null;
-  }
-  return params;
-}
-function matchFetchRoute(routes, input) {
-  const pathnameSegments = getPathSegments(getMatchPathname(input));
-  for (const route of routes) {
-    const params = matchRouteSegments(route.segments, pathnameSegments);
-    if (params) {
-      return {
-        route,
-        params
-      };
-    }
-  }
-  return null;
-}
-async function invokeRouteModules(routes, event2) {
-  const match = matchFetchRoute(routes, event2.request);
-  if (!match) {
-    return new Response("Not Found", { status: 404 });
-  }
-  const routeEvent = createFetchEvent(event2.request, event2.env, event2.ctx, {
-    params: match.params,
-    locals: event2.locals
-  });
-  return runWithEventContext(routeEvent, () => invokeFetchModule(match.route.module, routeEvent));
-}
-function createRouteResolve(routes, initialEvent) {
-  return async (nextEvent = initialEvent) => {
-    return invokeRouteModules(routes, nextEvent);
-  };
-}
-export { env, ctx, event, locals, markResolveStyle, markWorkerStyle, defineFetchHandler, defineQueueHandler, defineScheduledHandler, assertExplicitQueueHandlerStyle, assertExplicitScheduledHandlerStyle, sequence, resolveFetchHandler, invokeFetchHandler, createResolveFetch, invokeFetchModule, matchFetchRoute, invokeRouteModules, createRouteResolve };

package/dist/index-jwvy32xk.js

@@ -1,188 +0,0 @@
-import {
-  apiDelete,
-  apiGetAll,
-  apiPost,
-  apiPut
-} from "./index-abrqnq3e.js";
-
-// src/cloudflare/known-permission-group-ids.generated.ts
-var KNOWN_PERMISSION_GROUP_IDS_DATA = {
-  WORKERS_SCRIPTS_WRITE: null,
-  WORKERS_SCRIPTS_READ: null,
-  ACCOUNT_SETTINGS_READ: null,
-  WORKERS_KV_STORAGE_WRITE: null,
-  WORKERS_KV_STORAGE_READ: null,
-  ACCOUNT_API_TOKENS_WRITE: null,
-  ACCOUNT_API_TOKENS_READ: null
-};
-
-// src/cloudflare/tokens.ts
-var MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS = 300;
-var DEVFLARE_MANAGED_TOKEN_PREFIX = "devflare-";
-var ACCOUNT_OWNED_TOKEN_SCOPE = "com.cloudflare.api.account";
-var ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN = /^Account API Tokens\b/i;
-var DEVFLARE_MANAGED_TOKEN_NAME_PATTERN = /^devflare-/i;
-var DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS = [
-  /^Account Analytics Read$/i,
-  /^Account Settings Read$/i,
-  /^Analytics Read$/i,
-  /^AI /i,
-  /^Browser Rendering /i,
-  /^D1 (Metadata Read|Read|Write)$/i,
-  /^Email (Routing|Sending) /i,
-  /^Hyperdrive /i,
-  /^Queues /i,
-  /^Vectorize /i,
-  /^Workers /i
-];
-function deriveKnownPermissionGroupIds(data) {
-  const result = {};
-  for (const key of Object.keys(data)) {
-    const value = data[key];
-    result[key] = value === null ? undefined : value;
-  }
-  return result;
-}
-var KNOWN_PERMISSION_GROUP_IDS = deriveKnownPermissionGroupIds(KNOWN_PERMISSION_GROUP_IDS_DATA);
-function dedupePermissionGroups(permissionGroups) {
-  const seenIds = new Set;
-  return permissionGroups.filter((permissionGroup) => {
-    if (seenIds.has(permissionGroup.id)) {
-      return false;
-    }
-    seenIds.add(permissionGroup.id);
-    return true;
-  });
-}
-function dedupePermissionGroupIds(permissionGroupIds) {
-  return Array.from(new Set(permissionGroupIds.map((id) => id.trim()).filter(Boolean)));
-}
-function excludeAccountApiTokensPermissionGroups(permissionGroups) {
-  return permissionGroups.filter((permissionGroup) => {
-    return !ACCOUNT_API_TOKENS_PERMISSION_GROUP_NAME_PATTERN.test(permissionGroup.name);
-  });
-}
-function keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups) {
-  return permissionGroups.filter((permissionGroup) => {
-    return permissionGroup.scopes.some((scope) => scope.trim() === ACCOUNT_OWNED_TOKEN_SCOPE);
-  });
-}
-function selectReusableAccountOwnedTokenPermissionGroups(permissionGroups) {
-  return dedupePermissionGroups(excludeAccountApiTokensPermissionGroups(keepAccountOwnedTokenCompatiblePermissionGroups(permissionGroups)));
-}
-function parseOptionalDate(value) {
-  if (!value) {
-    return;
-  }
-  const parsed = new Date(value);
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed;
-}
-function mapAccountOwnedAPITokenPolicy(policy) {
-  return {
-    id: policy.id,
-    effect: policy.effect,
-    permissionGroups: policy.permission_groups?.map((permissionGroup) => ({
-      id: permissionGroup.id,
-      name: permissionGroup.name
-    }))
-  };
-}
-function mapAccountOwnedAPIToken(token) {
-  return {
-    id: token.id,
-    name: token.name ?? token.id,
-    status: token.status,
-    value: token.value,
-    issuedOn: parseOptionalDate(token.issued_on),
-    modifiedOn: parseOptionalDate(token.modified_on),
-    lastUsedOn: parseOptionalDate(token.last_used_on),
-    policies: token.policies?.map(mapAccountOwnedAPITokenPolicy)
-  };
-}
-function isDevflareManagedTokenName(name) {
-  return DEVFLARE_MANAGED_TOKEN_NAME_PATTERN.test(name.trim());
-}
-function normalizeDevflareTokenName(name) {
-  const trimmedName = name.trim();
-  if (!trimmedName) {
-    throw new Error("Devflare token name cannot be empty");
-  }
-  const suffix = isDevflareManagedTokenName(trimmedName) ? trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "") : trimmedName;
-  if (!suffix) {
-    throw new Error("Devflare token name cannot be empty");
-  }
-  return `${DEVFLARE_MANAGED_TOKEN_PREFIX}${suffix}`;
-}
-function stripDevflareTokenNamePrefix(name) {
-  const trimmedName = name.trim();
-  if (!trimmedName) {
-    return trimmedName;
-  }
-  const strippedName = trimmedName.replace(DEVFLARE_MANAGED_TOKEN_NAME_PATTERN, "");
-  return strippedName || trimmedName;
-}
-function filterDevflareManagedTokens(tokens) {
-  return tokens.filter((token) => isDevflareManagedTokenName(token.name));
-}
-function selectDevflarePermissionGroups(permissionGroups) {
-  const selectedPermissionGroups = dedupePermissionGroups(selectReusableAccountOwnedTokenPermissionGroups(permissionGroups).filter((permissionGroup) => {
-    return DEVFLARE_PERMISSION_GROUP_NAME_PATTERNS.some((pattern) => {
-      return pattern.test(permissionGroup.name);
-    });
-  }));
-  if (selectedPermissionGroups.length === 0) {
-    throw new Error("Could not map the available Cloudflare permission groups to a Devflare token policy.");
-  }
-  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
-    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
-  }
-  return selectedPermissionGroups;
-}
-function selectAllReusablePermissionGroups(permissionGroups) {
-  const selectedPermissionGroups = selectReusableAccountOwnedTokenPermissionGroups(permissionGroups);
-  if (selectedPermissionGroups.length === 0) {
-    throw new Error("Could not find any reusable account-scoped Cloudflare permission groups for this Devflare token.");
-  }
-  if (selectedPermissionGroups.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
-    throw new Error(`Devflare selected ${selectedPermissionGroups.length} permission groups, which exceeds Cloudflare's ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS}-group limit for account-owned tokens.`);
-  }
-  return selectedPermissionGroups;
-}
-async function listAccountTokenPermissionGroups(accountId, options) {
-  const permissionGroups = await apiGetAll(`/accounts/${accountId}/tokens/permission_groups`, options);
-  return dedupePermissionGroups(permissionGroups);
-}
-async function listAccountOwnedAPITokens(accountId, options) {
-  const tokens = await apiGetAll(`/accounts/${accountId}/tokens`, options);
-  return tokens.map(mapAccountOwnedAPIToken);
-}
-async function deleteAccountOwnedAPIToken(accountId, tokenId, options) {
-  return apiDelete(`/accounts/${accountId}/tokens/${tokenId}`, options);
-}
-async function rollAccountOwnedAPITokenValue(accountId, tokenId, options) {
-  return apiPut(`/accounts/${accountId}/tokens/${tokenId}/value`, {}, options);
-}
-async function createAccountOwnedAPIToken(accountId, options, clientOptions) {
-  const permissionGroupIds = dedupePermissionGroupIds(options.permissionGroupIds);
-  if (permissionGroupIds.length === 0) {
-    throw new Error("Cannot create a Devflare token without any permission groups");
-  }
-  if (permissionGroupIds.length > MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS) {
-    throw new Error(`Cannot create a Devflare token with more than ${MAX_ACCOUNT_OWNED_TOKEN_PERMISSION_GROUPS} permission groups.`);
-  }
-  const createdToken = await apiPost(`/accounts/${accountId}/tokens`, {
-    name: options.name,
-    policies: [
-      {
-        effect: "allow",
-        resources: {
-          [`com.cloudflare.api.account.${accountId}`]: "*"
-        },
-        permission_groups: permissionGroupIds.map((id) => ({ id }))
-      }
-    ]
-  }, clientOptions);
-  return mapAccountOwnedAPIToken(createdToken);
-}
-
-export { normalizeDevflareTokenName, stripDevflareTokenNamePrefix, filterDevflareManagedTokens, selectDevflarePermissionGroups, selectAllReusablePermissionGroups, listAccountTokenPermissionGroups, listAccountOwnedAPITokens, deleteAccountOwnedAPIToken, rollAccountOwnedAPITokenValue, createAccountOwnedAPIToken };