@globus/sdk 3.9.0 → 4.0.0-rc.2

package/dist/cjs/index.js

@@ -0,0 +1,3135 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  auth: () => auth_exports,
+  authorization: () => authorization_exports,
+  compute: () => compute_exports,
+  errors: () => errors_exports,
+  flows: () => flows_exports2,
+  gcs: () => globus_connect_server_exports,
+  groups: () => groups_exports2,
+  info: () => info_exports,
+  logger: () => logger_exports,
+  search: () => search_exports,
+  timer: () => timer_exports,
+  transfer: () => transfer_exports,
+  webapp: () => web_exports
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/info/index.ts
+var info_exports = {};
+__export(info_exports, {
+  CLIENT_INFO: () => CLIENT_INFO,
+  VERSION: () => VERSION2,
+  addClientInfo: () => addClientInfo,
+  getClientInfo: () => getClientInfo,
+  getClientInfoRequestHeaders: () => getClientInfoRequestHeaders
+});
+
+// src/core/info/private.ts
+var CLIENT_INFO_HEADER = `X-Globus-Client-Info`;
+var ENABLED = true;
+function isEnabled() {
+  return ENABLED;
+}
+var INFOS_SEPERATOR = ";";
+var INFO_ITEM_SEPARATOR = ",";
+function toString(info2) {
+  const infos = Array.isArray(info2) ? info2 : [info2];
+  return infos.map(
+    (i) => Object.entries(i).map(([key, value]) => `${key}=${value}`).join(INFO_ITEM_SEPARATOR)
+  ).join(INFOS_SEPERATOR);
+}
+
+// src/core/info/version.ts
+var VERSION = "3.9.0";
+
+// src/core/info/index.ts
+var VERSION2 = VERSION;
+var CLIENT_INFO = {
+  product: "javascript-sdk",
+  version: VERSION2
+};
+var INFOS = [CLIENT_INFO];
+function addClientInfo(info2) {
+  INFOS = INFOS.concat(info2);
+}
+function getClientInfo() {
+  return toString(INFOS);
+}
+function getClientInfoRequestHeaders() {
+  if (!isEnabled()) {
+    return {};
+  }
+  return {
+    [CLIENT_INFO_HEADER]: getClientInfo()
+  };
+}
+
+// src/core/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  log: () => log,
+  setLogLevel: () => setLogLevel,
+  setLogger: () => setLogger
+});
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+var logger;
+var level = LOG_LEVELS.indexOf("error");
+function setLogger(logMechanism) {
+  logger = logMechanism;
+}
+function setLogLevel(severity) {
+  level = LOG_LEVELS.indexOf(severity);
+}
+function log(severity, ...args) {
+  if (!logger) return;
+  if (LOG_LEVELS.indexOf(severity) < level) {
+    return;
+  }
+  const handler = logger[severity] ?? logger.log;
+  handler(...args);
+}
+
+// src/core/authorization/index.ts
+var authorization_exports = {};
+__export(authorization_exports, {
+  AuthorizationManager: () => AuthorizationManager,
+  create: () => create
+});
+
+// src/core/authorization/AuthorizationManager.ts
+var import_jwt_decode = require("jwt-decode");
+
+// src/services/auth/index.ts
+var auth_exports = {};
+__export(auth_exports, {
+  CONFIG: () => CONFIG,
+  getAuthorizationEndpoint: () => getAuthorizationEndpoint,
+  getTokenEndpoint: () => getTokenEndpoint,
+  identities: () => identities_exports,
+  isGlobusAuthTokenResponse: () => isGlobusAuthTokenResponse,
+  isRefreshToken: () => isRefreshToken,
+  isToken: () => isToken,
+  oauth2: () => oauth2_exports
+});
+
+// src/services/auth/config.ts
+var config_exports7 = {};
+__export(config_exports7, {
+  HOSTS: () => HOSTS7,
+  ID: () => ID7,
+  RESOURCE_SERVERS: () => RESOURCE_SERVERS,
+  SCOPES: () => SCOPES6
+});
+
+// src/services/transfer/config.ts
+var config_exports = {};
+__export(config_exports, {
+  HOSTS: () => HOSTS,
+  ID: () => ID,
+  SCOPES: () => SCOPES
+});
+var ID = "TRANSFER";
+var SCOPES = {
+  ALL: "urn:globus:auth:scope:transfer.api.globus.org:all"
+};
+var HOSTS = {
+  sandbox: "transfer.api.sandbox.globuscs.info",
+  production: "transfer.api.globusonline.org",
+  staging: "transfer.api.staging.globuscs.info",
+  integration: "transfer.api.integration.globuscs.info",
+  test: "transfer.api.test.globuscs.info",
+  preview: "transfer.api.preview.globus.org"
+};
+
+// src/services/flows/config.ts
+var config_exports2 = {};
+__export(config_exports2, {
+  HOSTS: () => HOSTS2,
+  ID: () => ID2,
+  SCOPES: () => SCOPES2
+});
+var ID2 = "FLOWS";
+var HOSTS2 = {
+  sandbox: "sandbox.flows.automate.globus.org",
+  production: "flows.globus.org",
+  staging: "staging.flows.automate.globus.org",
+  integration: "integration.flows.automate.globus.org",
+  test: "test.flows.automate.globus.org",
+  preview: "preview.flows.automate.globus.org"
+};
+var SCOPES2 = {
+  MANAGE_FLOWS: "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/manage_flows",
+  VIEW_FLOWS: "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/view_flows",
+  RUN: "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/run",
+  RUN_STATUS: "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/run_status",
+  RUN_MANAGE: "https://auth.globus.org/scopes/eec9b274-0c81-4334-bdc2-54e90e689b9a/run_manage"
+};
+
+// src/services/timer/config.ts
+var config_exports3 = {};
+__export(config_exports3, {
+  HOSTS: () => HOSTS3,
+  ID: () => ID3
+});
+var ID3 = "TIMER";
+var HOSTS3 = {
+  sandbox: "sandbox.timer.automate.globus.org",
+  production: "timer.automate.globus.org",
+  staging: "staging.timer.automate.globus.org",
+  integration: "integration.timer.automate.globus.org",
+  test: "test.timer.automate.globus.org",
+  preview: "preview.timer.automate.globus.org"
+};
+
+// src/services/groups/config.ts
+var config_exports4 = {};
+__export(config_exports4, {
+  HOSTS: () => HOSTS4,
+  ID: () => ID4,
+  SCOPES: () => SCOPES3
+});
+var ID4 = "GROUPS";
+var HOSTS4 = {
+  sandbox: "groups.api.sandbox.globuscs.info",
+  production: "groups.api.globus.org",
+  staging: "groups.api.staging.globuscs.info",
+  integration: "groups.api.integration.globuscs.info",
+  test: "groups.api.test.globuscs.info",
+  preview: "groups.api.preview.globuscs.info"
+};
+var SCOPES3 = {
+  ALL: "urn:globus:auth:scope:groups.api.globus.org:all",
+  VIEW_MY: "urn:globus:auth:scope:groups.api.globus.org:view_my_groups_and_membership"
+};
+
+// src/services/search/config.ts
+var config_exports5 = {};
+__export(config_exports5, {
+  HOSTS: () => HOSTS5,
+  ID: () => ID5,
+  SCOPES: () => SCOPES4
+});
+var ID5 = "SEARCH";
+var HOSTS5 = {
+  sandbox: "search.api.sandbox.globuscs.info",
+  production: "search.api.globus.org",
+  staging: "search.api.staging.globuscs.info",
+  integration: "search.api.integration.globuscs.info",
+  test: "search.api.test.globuscs.info",
+  preview: "search.api.preview.globus.org"
+};
+var SCOPES4 = {
+  ALL: "urn:globus:auth:scope:search.api.globus.org:all",
+  INGEST: "urn:globus:auth:scope:search.api.globus.org:ingest",
+  SEARCH: "urn:globus:auth:scope:search.api.globus.org:search"
+};
+
+// src/services/compute/config.ts
+var config_exports6 = {};
+__export(config_exports6, {
+  HOSTS: () => HOSTS6,
+  ID: () => ID6,
+  SCOPES: () => SCOPES5
+});
+var ID6 = "COMPUTE";
+var HOSTS6 = {
+  sandbox: "compute.api.sandbox.globuscs.info",
+  production: "compute.api.globus.org",
+  staging: "compute.api.staging.globuscs.info",
+  integration: "compute.api.integration.globuscs.info",
+  test: "compute.api.test.globuscs.info",
+  preview: "compute.api.preview.globus.org"
+};
+var SCOPES5 = {
+  ALL: "https://auth.globus.org/scopes/facd7ccc-c5f4-42aa-916b-a0e270e2c2a9/all"
+};
+
+// src/services/auth/config.ts
+var ID7 = "AUTH";
+var HOSTS7 = {
+  integration: "auth.integration.globuscs.info",
+  sandbox: "auth.sandbox.globuscs.info",
+  production: "auth.globus.org",
+  test: "auth.test.globuscs.info",
+  staging: "auth.staging.globuscs.info",
+  preview: "auth.preview.globus.org"
+};
+var SCOPES6 = {
+  VIEW_IDENTITIES: "urn:globus:auth:scope:auth.globus.org:view_identities"
+};
+var RESOURCE_SERVERS = {
+  [ID7]: "auth.globus.org",
+  [ID]: "transfer.api.globus.org",
+  [ID2]: "flows.api.globus.org",
+  [ID4]: "groups.api.globus.org",
+  [ID5]: "search.api.globus.org",
+  [ID3]: "524230d7-ea86-4a52-8312-86065a9e0417",
+  [ID6]: "funcx_service"
+};
+
+// src/core/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  EnvironmentConfigurationError: () => EnvironmentConfigurationError,
+  isAuthorizationRequirementsError: () => isAuthorizationRequirementsError,
+  isConsentRequiredError: () => isConsentRequiredError,
+  isErrorWellFormed: () => isErrorWellFormed,
+  toAuthorizationQueryParams: () => toAuthorizationQueryParams
+});
+var EnvironmentConfigurationError = class extends Error {
+  name = "EnvironmentConfigurationError";
+  constructor(variable, value) {
+    super();
+    this.message = `Invalid configuration value provided for ${variable} (${value}).`;
+  }
+};
+function isErrorWellFormed(test) {
+  return typeof test === "object" && test !== null && "code" in test && "message" in test;
+}
+function isConsentRequiredError(test) {
+  return isErrorWellFormed(test) && test.code === "ConsentRequired" && "required_scopes" in test && Array.isArray(test.required_scopes);
+}
+var NO_OP_KEYS = ["required_scopes"];
+function toAuthorizationQueryParams(error) {
+  return Object.entries(error.authorization_parameters).reduce((acc, [key, v]) => {
+    if (NO_OP_KEYS.includes(key) || v === void 0 || v === null) {
+      return acc;
+    }
+    let value = v;
+    if (Array.isArray(value)) {
+      value = value.join(",");
+    } else if (typeof v === "boolean") {
+      value = value ? "true" : "false";
+    }
+    return { ...acc, [key]: value };
+  }, {});
+}
+function isAuthorizationRequirementsError(test) {
+  return typeof test === "object" && test !== null && "authorization_parameters" in test && typeof test.authorization_parameters === "object" && test.authorization_parameters !== null;
+}
+
+// src/core/global.ts
+function getRuntime() {
+  return typeof window !== "undefined" ? window : process;
+}
+function isBrowser(runtime) {
+  return typeof window === typeof runtime;
+}
+function env(key, fallback) {
+  const runtime = getRuntime();
+  let envConfiguration;
+  if (isBrowser(runtime)) {
+    envConfiguration = runtime;
+  } else {
+    envConfiguration = runtime.env;
+  }
+  if (key in envConfiguration) {
+    return envConfiguration[key];
+  }
+  return fallback;
+}
+var ENVIRONMENTS = {
+  PRODUCTION: "production",
+  PREVIEW: "preview",
+  STAGING: "staging",
+  SANDBOX: "sandbox",
+  INTEGRATION: "integration",
+  TEST: "test"
+};
+var SERVICES = {
+  [ID7]: ID7,
+  [ID]: ID,
+  [ID2]: ID2,
+  [ID4]: ID4,
+  [ID5]: ID5,
+  [ID3]: ID3,
+  [ID6]: ID6
+};
+var SERVICE_HOSTS = {
+  [ID7]: HOSTS7,
+  [ID]: HOSTS,
+  [ID2]: HOSTS2,
+  [ID4]: HOSTS4,
+  [ID5]: HOSTS5,
+  [ID3]: HOSTS3,
+  [ID6]: HOSTS6
+};
+function getSDKOptions(options) {
+  let globalOptions = env("GLOBUS_SDK_OPTIONS", {});
+  if (typeof globalOptions === "string") {
+    globalOptions = JSON.parse(globalOptions);
+  }
+  return {
+    ...globalOptions,
+    ...options,
+    fetch: {
+      ...globalOptions?.fetch,
+      ...options?.fetch,
+      options: {
+        ...globalOptions?.fetch?.options,
+        ...options?.fetch?.options,
+        headers: {
+          ...globalOptions?.fetch?.options?.headers,
+          ...options?.fetch?.options?.headers
+        }
+      }
+    }
+  };
+}
+function getEnvironment() {
+  const globalOptions = getSDKOptions();
+  const environment = env(
+    "GLOBUS_SDK_ENVIRONMENT",
+    globalOptions?.environment ?? ENVIRONMENTS.PRODUCTION
+  );
+  if (globalOptions?.environment && environment !== globalOptions.environment) {
+    log(
+      "debug",
+      "GLOBUS_SDK_ENVIRONMENT and GLOBUS_SDK_OPTIONS.environment are set to different values. GLOBUS_SDK_ENVIRONMENT will take precedence"
+    );
+  }
+  if (!environment || !Object.values(ENVIRONMENTS).includes(environment)) {
+    throw new EnvironmentConfigurationError("GLOBUS_SDK_ENVIRONMENT", environment);
+  }
+  return environment;
+}
+function getServiceHost(service, environment = getEnvironment()) {
+  return SERVICE_HOSTS[service][environment];
+}
+function getServiceBaseUrl(service, environment = getEnvironment()) {
+  const host2 = getServiceHost(service, environment);
+  return env(`GLOBUS_SDK_SERVICE_URL_${service}`, host2 ? `https://${host2}` : void 0);
+}
+
+// src/core/url.ts
+function stringifyParameters(parameters) {
+  const search = new URLSearchParams();
+  Array.from(Object.entries(parameters)).forEach(([key, value]) => {
+    if (Array.isArray(value)) {
+      search.set(key, value.join(","));
+    } else if (value !== void 0) {
+      search.set(key, String(value));
+    }
+  });
+  return search.toString();
+}
+function getServiceURL(service, path = "", environment = getEnvironment()) {
+  const base = getServiceBaseUrl(service, environment);
+  return new URL(path, base);
+}
+function build(serviceOrConfiguration, path, options, sdkOptions) {
+  let url2;
+  if (typeof serviceOrConfiguration === "object") {
+    url2 = new URL(path, serviceOrConfiguration.host);
+  } else {
+    url2 = getServiceURL(serviceOrConfiguration, path, sdkOptions?.environment);
+  }
+  if (options && options.search) {
+    url2.search = stringifyParameters(options.search);
+  }
+  return url2.toString();
+}
+
+// src/services/auth/service/identities.ts
+var identities_exports = {};
+__export(identities_exports, {
+  get: () => get,
+  getAll: () => getAll
+});
+
+// src/services/shared.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+async function serviceRequest(config, options, passedSdkOptions) {
+  const sdkOptions = getSDKOptions(passedSdkOptions);
+  const injectedFetchOptions = sdkOptions?.fetch?.options || {};
+  const headers = {
+    ...getClientInfoRequestHeaders(),
+    ...options?.headers,
+    /**
+     * Key/value pairs found in the `fetch` options override those found in the
+     * service method options.
+     */
+    ...injectedFetchOptions.headers
+  };
+  const manager = sdkOptions?.manager;
+  let token2;
+  if (config.resource_server && manager) {
+    token2 = manager.tokens.getByResourceServer(config.resource_server);
+    if (token2) {
+      headers["Authorization"] = `Bearer ${token2.access_token}`;
+    }
+  }
+  if (config.scope && manager) {
+    const resourceServer = typeof config.service === "string" ? RESOURCE_SERVERS[config.service] : (
+      // For `GCSConfiguration` objects, the `endpoint_id` is the resource server.
+      config.service.endpoint_id
+    );
+    token2 = manager.tokens.getByResourceServer(resourceServer);
+    if (token2) {
+      headers["Authorization"] = `Bearer ${token2.access_token}`;
+    }
+  }
+  let body = options?.body;
+  if (!body && options?.payload) {
+    body = JSON.stringify(options.payload);
+  }
+  if (!headers?.["Content-Type"] && body) {
+    headers["Content-Type"] = "application/json";
+  }
+  const url2 = build(
+    config.service,
+    config.path,
+    {
+      search: options?.query
+    },
+    sdkOptions
+  );
+  const init = {
+    method: config.method,
+    body,
+    ...injectedFetchOptions,
+    /**
+     * Merge the headers from the options and SDK options.
+     */
+    headers
+  };
+  let handler = import_cross_fetch.default;
+  if (injectedFetchOptions?.__callable) {
+    handler = injectedFetchOptions.__callable.bind(this);
+    delete init.__callable;
+  }
+  if (config.preventRetry || !manager || !token2 || !isRefreshToken(token2)) {
+    return handler(url2, init);
+  }
+  const initialResponse = await handler(url2, init);
+  if (initialResponse.ok) {
+    return initialResponse;
+  }
+  let hasAuthorizationRequirements;
+  try {
+    hasAuthorizationRequirements = isAuthorizationRequirementsError(
+      /**
+       * It is important to clone the response before calling `json` avoid
+       * `body used already for [...]` errors when the initial response is
+       * returned.
+       */
+      await initialResponse.clone().json()
+    );
+  } catch (_e) {
+    hasAuthorizationRequirements = false;
+  }
+  const shouldAttemptTokenRefresh = initialResponse.status === 401 && !hasAuthorizationRequirements;
+  if (shouldAttemptTokenRefresh) {
+    const newToken = await manager.refreshToken(token2);
+    if (!newToken) {
+      return initialResponse;
+    }
+    return handler(url2, {
+      ...init,
+      headers: {
+        ...init.headers,
+        Authorization: `Bearer ${newToken.access_token}`
+      }
+    });
+  }
+  return initialResponse;
+}
+
+// src/services/auth/service/identities.ts
+var get = function(identity_id, options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: SCOPES6.VIEW_IDENTITIES,
+      path: `/identities/${identity_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getAll = function(options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: SCOPES6.VIEW_IDENTITIES,
+      path: `/identities`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/auth/service/oauth2/index.ts
+var oauth2_exports = {};
+__export(oauth2_exports, {
+  token: () => token_exports,
+  userinfo: () => userinfo
+});
+
+// src/services/auth/service/oauth2/token.ts
+var token_exports = {};
+__export(token_exports, {
+  exchange: () => exchange,
+  introspect: () => introspect,
+  refresh: () => refresh,
+  revoke: () => revoke,
+  token: () => token,
+  validate: () => validate
+});
+function serialize(payload) {
+  return new URLSearchParams(payload);
+}
+function injectServiceOptions(options) {
+  return {
+    ...options,
+    /**
+     * The `token` service methods always expect a form-encoded body. We still allow
+     * end-consumers to pass a raw body, but if `payload` is provided it is serialized.
+     */
+    body: options.payload ? serialize(options.payload) : void 0,
+    headers: {
+      ...options?.headers || {},
+      Accept: "application/json",
+      /**
+       * Force the `Content-Type` header to be `application/x-www-form-urlencoded` and `charset=UTF-8`.
+       */
+      "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+    }
+  };
+}
+var token = function(options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: void 0,
+      path: `/v2/oauth2/token`,
+      method: "POST" /* POST */,
+      preventRetry: true
+    },
+    injectServiceOptions(options),
+    sdkOptions
+  );
+};
+var exchange = token;
+var introspect = function(options, sdkOptions) {
+  if (!options?.payload) {
+    throw new Error(`'payload' is required for introspect`);
+  }
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: void 0,
+      path: `/v2/oauth2/token/introspect`,
+      method: "POST" /* POST */,
+      preventRetry: true
+    },
+    injectServiceOptions(options),
+    sdkOptions
+  );
+};
+var revoke = function(options, sdkOptions) {
+  if (!options?.payload) {
+    throw new Error(`'payload' is required for revoke`);
+  }
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: void 0,
+      path: `/v2/oauth2/token/revoke`,
+      method: "POST" /* POST */,
+      preventRetry: true
+    },
+    injectServiceOptions(options),
+    sdkOptions
+  );
+};
+var refresh = function(options, sdkOptions) {
+  if (!options?.payload) {
+    throw new Error(`'payload' is required for revoke`);
+  }
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: void 0,
+      path: `/v2/oauth2/token`,
+      method: "POST" /* POST */,
+      preventRetry: true
+    },
+    injectServiceOptions(options),
+    sdkOptions
+  );
+};
+var validate = function(options, sdkOptions) {
+  if (!options?.payload) {
+    throw new Error(`'payload' is required for validate`);
+  }
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: void 0,
+      path: `/v2/oauth2/token/validate`,
+      method: "POST" /* POST */,
+      preventRetry: true
+    },
+    injectServiceOptions(options),
+    sdkOptions
+  );
+};
+
+// src/services/auth/service/oauth2/index.ts
+var userinfo = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID7,
+      scope: void 0,
+      path: `/v2/oauth2/userinfo`,
+      method: "GET" /* GET */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/auth/index.ts
+var CONFIG = config_exports7;
+function getAuthorizationEndpoint() {
+  return build(ID7, "/v2/oauth2/authorize");
+}
+function getTokenEndpoint() {
+  return build(ID7, "/v2/oauth2/token");
+}
+function isToken(check) {
+  return typeof check === "object" && check !== null && "access_token" in check;
+}
+function isRefreshToken(check) {
+  return isToken(check) && check !== null && "refresh_token" in check;
+}
+function isGlobusAuthTokenResponse(check) {
+  return isToken(check) && check !== null && "resource_server" in check;
+}
+
+// src/core/storage/memory.ts
+var MemoryStorage = class {
+  #storage = {};
+  get(key) {
+    return this.#storage[key] !== void 0 ? this.#storage[key] : null;
+  }
+  set(key, value) {
+    this.#storage[key] = typeof value !== "string" ? JSON.stringify(value) : value;
+  }
+  remove(key) {
+    delete this.#storage[key];
+  }
+  keys() {
+    return Object.keys(this.#storage);
+  }
+  clear() {
+    this.#storage = {};
+  }
+};
+
+// src/core/storage/local-storage.ts
+var LocalStorage = class {
+  #storage = globalThis.localStorage;
+  get(key) {
+    return this.#storage.getItem(key);
+  }
+  set(key, value) {
+    this.#storage.setItem(key, typeof value !== "string" ? JSON.stringify(value) : value);
+  }
+  keys() {
+    return Object.keys(this.#storage);
+  }
+  remove(key) {
+    this.#storage.removeItem(key);
+  }
+  clear() {
+    this.#storage.clear();
+  }
+};
+
+// src/core/storage/index.ts
+var storage;
+function createStorage(storageType = "memory") {
+  if (!storage) {
+    let Factory;
+    if (storageType === "localStorage") {
+      Factory = LocalStorage;
+    } else if (storageType === "memory") {
+      Factory = MemoryStorage;
+    } else {
+      Factory = storageType;
+    }
+    storage = new Factory();
+  }
+  return storage;
+}
+var getStorage = createStorage;
+
+// src/core/authorization/Event.ts
+var Event = class {
+  constructor(name) {
+    this.name = name;
+  }
+  #callbacks = [];
+  addListener(callback) {
+    this.#callbacks.push(callback);
+    return () => this.removeListener(callback);
+  }
+  removeListener(callback) {
+    this.#callbacks = this.#callbacks.filter((cb) => cb !== callback);
+  }
+  clearListeners() {
+    this.#callbacks = [];
+  }
+  async dispatch(payload) {
+    await Promise.all(this.#callbacks.map((callback) => callback(payload)));
+  }
+};
+
+// src/core/authorization/pkce.ts
+function isSupported() {
+  return "crypto" in globalThis;
+}
+function getCrypto() {
+  return "webcrypto" in globalThis.crypto ? globalThis.crypto.webcrypto : globalThis.crypto;
+}
+var encode = (value) => btoa(value).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+async function sha256(input) {
+  const hashBuffer = await getCrypto().subtle.digest("SHA-256", new TextEncoder().encode(input));
+  return String.fromCharCode(...new Uint8Array(hashBuffer));
+}
+var CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+var PKCE_SAFE_CHARSET = `${CHARSET}-._~`;
+function generateCodeVerifier() {
+  return Array.from(getCrypto().getRandomValues(new Uint8Array(43))).map((v) => PKCE_SAFE_CHARSET[v % PKCE_SAFE_CHARSET.length]).join("");
+}
+async function generateCodeChallenge(verifier) {
+  const hashed = await sha256(verifier);
+  return encode(hashed);
+}
+function generateState() {
+  return Array.from(getCrypto().getRandomValues(new Uint8Array(16))).map((v) => CHARSET[v % CHARSET.length]).join("");
+}
+
+// src/core/authorization/RedirectTransport.ts
+var KEYS = {
+  PKCE_STATE: "pkce_state",
+  PKCE_CODE_VERIFIER: "pkce_code_verifier"
+};
+function resetPKCE() {
+  sessionStorage.removeItem(KEYS.PKCE_STATE);
+  sessionStorage.removeItem(KEYS.PKCE_CODE_VERIFIER);
+}
+var RedirectTransport = class _RedirectTransport {
+  #options;
+  constructor(options) {
+    this.#options = options;
+    if (_RedirectTransport.supported === false) {
+      throw new Error("RedirectTransport is not supported in this environment.");
+    }
+  }
+  static supported = isSupported();
+  /**
+   * For the redirect transport, sending the request will redirect the user to the authorization endpoint, initiating the OAuth flow.
+   */
+  async send() {
+    const verifier = generateCodeVerifier();
+    const challenge = await generateCodeChallenge(verifier);
+    const state = generateState();
+    sessionStorage.setItem(KEYS.PKCE_CODE_VERIFIER, verifier);
+    sessionStorage.setItem(KEYS.PKCE_STATE, state);
+    const params = {
+      response_type: "code",
+      client_id: this.#options.client,
+      scope: this.#options.scopes || "",
+      redirect_uri: this.#options.redirect,
+      state,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      ...this.#options.params || {}
+    };
+    const url2 = new URL(getAuthorizationEndpoint());
+    url2.search = new URLSearchParams(params).toString();
+    window.location.assign(url2.toString());
+  }
+  /**
+   * Parse the current URL for the authorization code (`?code=...`) and exchange it for an access token when available.
+   * - When the URL is processed and exchanged for an access token, the page is redirected to the current URL without the `?code=...&state=...` parameters.
+   */
+  async getToken(options = { shouldReplace: true }) {
+    const url2 = new URL(window.location.href);
+    const params = new URLSearchParams(url2.search);
+    if (params.get("error")) {
+      throw new Error(
+        params.get("error_description") || "An error occurred during the authorization process."
+      );
+    }
+    const code = params.get("code");
+    if (!code) return void 0;
+    const state = sessionStorage.getItem(KEYS.PKCE_STATE);
+    const verifier = sessionStorage.getItem(KEYS.PKCE_CODE_VERIFIER);
+    resetPKCE();
+    if (params.get("state") !== state) {
+      throw new Error("Invalid State");
+    }
+    if (!verifier) {
+      throw new Error("Invalid Code Verifier");
+    }
+    const payload = {
+      code,
+      client_id: this.#options.client,
+      /**
+       * Retrieve the code verifier from session storage.
+       */
+      code_verifier: verifier,
+      redirect_uri: this.#options.redirect,
+      grant_type: "authorization_code"
+    };
+    const response = await (await oauth2_exports.token.exchange({
+      payload
+    })).json();
+    if (options.shouldReplace) {
+      params.delete("code");
+      params.delete("state");
+      url2.search = params.toString();
+      window.location.replace(url2);
+    }
+    return response;
+  }
+};
+
+// src/core/authorization/TokenLookup.ts
+function getTokenFromStorage(key) {
+  const raw = getStorage().get(key) || "null";
+  let token2 = null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (isToken(parsed)) {
+      token2 = parsed;
+    }
+  } catch (e) {
+  }
+  return token2;
+}
+var TokenLookup = class {
+  #manager;
+  constructor(options) {
+    this.#manager = options.manager;
+  }
+  #getClientStorageEntry(identifier) {
+    return getTokenFromStorage(`${this.#manager.storageKeyPrefix}${identifier}`);
+  }
+  #getTokenForService(service) {
+    const resourceServer = CONFIG.RESOURCE_SERVERS?.[service];
+    return this.#getClientStorageEntry(resourceServer);
+  }
+  get auth() {
+    return this.#getTokenForService(SERVICES.AUTH);
+  }
+  get transfer() {
+    return this.#getTokenForService(SERVICES.TRANSFER);
+  }
+  get flows() {
+    return this.#getTokenForService(SERVICES.FLOWS);
+  }
+  get groups() {
+    return this.#getTokenForService(SERVICES.GROUPS);
+  }
+  get search() {
+    return this.#getTokenForService(SERVICES.SEARCH);
+  }
+  get timer() {
+    return this.#getTokenForService(SERVICES.TIMER);
+  }
+  get compute() {
+    return this.#getTokenForService(SERVICES.COMPUTE);
+  }
+  gcs(endpoint) {
+    return this.getByResourceServer(endpoint);
+  }
+  getByResourceServer(resourceServer) {
+    return this.#getClientStorageEntry(resourceServer);
+  }
+  getAll() {
+    const entries = getStorage().keys().reduce((acc, key) => {
+      if (key.startsWith(this.#manager.storageKeyPrefix)) {
+        acc.push(getTokenFromStorage(key));
+      }
+      return acc;
+    }, []);
+    return entries.filter(isToken);
+  }
+};
+
+// src/core/authorization/AuthorizationManager.ts
+var DEFAULT_CONFIGURATION = {
+  useRefreshTokens: false,
+  defaultScopes: "openid profile email"
+};
+var DEFAULT_HANDLE_ERROR_OPTIONS = {
+  execute: true,
+  additionalParams: void 0
+};
+var AuthorizationManager = class {
+  #transport;
+  configuration;
+  #authenticated = false;
+  /**
+   * The `AuthorizationManager` is considered `authenticated` if it has a valid Globus Auth token.
+   * It does not necessarily mean that it has a valid token for a specific resource server.
+   */
+  get authenticated() {
+    return this.#authenticated;
+  }
+  /**
+   * Set the authenticated state and emit the `authenticated` event.
+   */
+  set authenticated(value) {
+    if (value === this.#authenticated) {
+      return;
+    }
+    this.#authenticated = value;
+    this.#emitAuthenticatedState();
+  }
+  tokens;
+  events = {
+    /**
+     * Emitted when the authenticated state changes.
+     * @event AuthorizationManager.events#authenticated
+     * @type {object}
+     * @property {boolean} isAuthenticated - Whether the `AuthorizationManager` is authenticated.
+     * @property {TokenResponse} [token] - The token response if the `AuthorizationManager` is authenticated.
+     */
+    authenticated: new Event("authenticated"),
+    /**
+     * Emitted when the user revokes their authentication.
+     * @event AuthorizationManager.events#revoke
+     */
+    revoke: new Event("revoke")
+  };
+  constructor(configuration) {
+    createStorage("localStorage");
+    if (!configuration.client) {
+      throw new Error("You must provide a `client` for your application.");
+    }
+    const scopes = configuration.defaultScopes === false ? "" : configuration.defaultScopes ?? DEFAULT_CONFIGURATION.defaultScopes;
+    this.configuration = {
+      ...DEFAULT_CONFIGURATION,
+      ...configuration,
+      scopes: [configuration.scopes ? configuration.scopes : "", scopes].filter((s) => s.length).join(" ")
+    };
+    if (this.configuration.events) {
+      Object.entries(this.configuration.events).forEach(([name, callback]) => {
+        if (name in this.events) {
+          this.events[name].addListener(callback);
+        }
+      });
+    }
+    this.tokens = new TokenLookup({
+      manager: this
+    });
+    this.#checkAuthorizationState();
+  }
+  get storageKeyPrefix() {
+    return `${this.configuration.client}:`;
+  }
+  /**
+   * The user information decoded from the `id_token` (JWT) of the current Globus Auth token.
+   * This method can be used instead of `auth.oauth2.userinfo` to get the user information without an additional request.
+   *
+   * **IMPORTANT**: The `id_token` can only be processed if the `openid` scope is requested during the authorization process.
+   *
+   * Additionally, the `profile` and `email` scopes are required to get the full user information.
+   *
+   * @see {@link https://docs.globus.org/api/auth/reference/#oidc_userinfo_endpoint}
+   */
+  get user() {
+    const token2 = this.getGlobusAuthToken();
+    return token2 && token2.id_token ? (0, import_jwt_decode.jwtDecode)(token2.id_token) : null;
+  }
+  /**
+   * Attempt to refresh all of the tokens managed by the instance.
+   * This method will only attempt to refresh tokens that have a `refresh_token` attribute.
+   */
+  async refreshTokens() {
+    log("debug", "AuthorizationManager.refreshTokens");
+    const tokens = await Promise.allSettled(
+      this.tokens.getAll().map((token2) => {
+        if (isRefreshToken(token2)) {
+          return this.refreshToken(token2);
+        }
+        return Promise.resolve(null);
+      })
+    );
+    this.#checkAuthorizationState();
+    return tokens;
+  }
+  /**
+   * Use the `refresh_token` attribute of a token to obtain a new access token.
+   * @param token The well-formed token with a `refresh_token` attribute.
+   */
+  async refreshToken(token2) {
+    log("debug", `AuthorizationManager.refreshToken | resource_server=${token2.resource_server}`);
+    try {
+      const response = await (await oauth2_exports.token.refresh({
+        payload: {
+          client_id: this.configuration.client,
+          refresh_token: token2.refresh_token,
+          grant_type: "refresh_token"
+        }
+      })).json();
+      if (isGlobusAuthTokenResponse(response)) {
+        this.addTokenResponse(response);
+        return response;
+      }
+    } catch (error) {
+      log("error", `AuthorizationManager.refreshToken | resource_server=${token2.resource_server}`);
+    }
+    return null;
+  }
+  /**
+   * Whether or not the instance has a reference to a Globus Auth token.
+   */
+  hasGlobusAuthToken() {
+    return this.getGlobusAuthToken() !== null;
+  }
+  /**
+   * Retrieve the Globus Auth token managed by the instance.
+   */
+  getGlobusAuthToken() {
+    const entry = getStorage().get(`${this.storageKeyPrefix}auth.globus.org`);
+    return entry ? JSON.parse(entry) : null;
+  }
+  #checkAuthorizationState() {
+    log("debug", "AuthorizationManager.#checkAuthorizationState");
+    if (this.hasGlobusAuthToken()) {
+      this.authenticated = true;
+    }
+  }
+  async #emitAuthenticatedState() {
+    const isAuthenticated = this.authenticated;
+    const token2 = this.getGlobusAuthToken() ?? void 0;
+    await this.events.authenticated.dispatch({
+      isAuthenticated,
+      token: token2
+    });
+  }
+  /**
+   * Reset the authenticated state and clear all tokens from storage.
+   * This method **does not** emit the `revoke` event. If you need to emit the `revoke` event, use the `AuthorizationManager.revoke` method.
+   */
+  reset() {
+    getStorage().keys().forEach((key) => {
+      if (key.startsWith(this.storageKeyPrefix)) {
+        getStorage().remove(key);
+      }
+    });
+    this.authenticated = false;
+  }
+  /**
+   * A private utility method to add the `offline_access` scope to a scope string if the `useRefreshTokens` configuration is set to `true`.
+   * @param scopes The scope string to modify.
+   */
+  #withOfflineAccess(scopes) {
+    return `${scopes}${this.configuration.useRefreshTokens ? " offline_access" : ""}`;
+  }
+  #buildTransport(overrides) {
+    const scopes = this.#withOfflineAccess(overrides?.scopes ?? (this.configuration.scopes || ""));
+    return new RedirectTransport({
+      client: this.configuration.client,
+      redirect: this.configuration.redirect,
+      scopes,
+      ...overrides,
+      // @todo Decide if we want to include the `include_consented_scopes` parameter by default.
+      params: {
+        // include_consented_scopes: true,
+        ...overrides?.params
+      }
+    });
+  }
+  /**
+   * Initiate the login process by redirecting to the Globus Auth login page.
+   */
+  async login(options = { additionalParams: {} }) {
+    log("debug", "AuthorizationManager.login");
+    this.reset();
+    const transport = this.#buildTransport({ params: options?.additionalParams });
+    await transport.send();
+  }
+  /**
+   * This method will attempt to complete the PKCE protocol flow.
+   */
+  async handleCodeRedirect(options = { shouldReplace: true, additionalParams: {} }) {
+    log("debug", "AuthorizationManager.handleCodeRedirect");
+    const response = await this.#buildTransport({ params: options?.additionalParams }).getToken({
+      shouldReplace: options?.shouldReplace
+    });
+    if (isGlobusAuthTokenResponse(response)) {
+      log(
+        "debug",
+        `AuthorizationManager.handleCodeRedirect | response=${JSON.stringify(response)}`
+      );
+      this.addTokenResponse(response);
+    }
+  }
+  async handleErrorResponse(response, options) {
+    const opts = typeof options === "boolean" ? {
+      ...DEFAULT_HANDLE_ERROR_OPTIONS,
+      execute: options
+    } : {
+      ...DEFAULT_HANDLE_ERROR_OPTIONS,
+      ...options
+    };
+    log(
+      "debug",
+      `AuthorizationManager.handleErrorResponse | response=${JSON.stringify(response)} execute=${opts.execute}`
+    );
+    let handler = async () => {
+    };
+    if (isAuthorizationRequirementsError(response)) {
+      log(
+        "debug",
+        "AuthorizationManager.handleErrorResponse | error=AuthorizationRequirementsError"
+      );
+      handler = async () => {
+        await this.handleAuthorizationRequirementsError(response, {
+          additionalParams: opts.additionalParams
+        });
+      };
+    }
+    if (isConsentRequiredError(response)) {
+      log("debug", "AuthorizationManager.handleErrorResponse | error=ConsentRequiredError");
+      handler = async () => {
+        await this.handleConsentRequiredError(response, {
+          additionalParams: opts.additionalParams
+        });
+      };
+    }
+    if ("code" in response && response["code"] === "AuthenticationFailed") {
+      log("debug", "AuthorizationManager.handleErrorResponse | error=AuthenticationFailed");
+      handler = async () => {
+        await this.revoke();
+      };
+    }
+    const returnValue = opts.execute === true ? await handler() : handler;
+    return returnValue;
+  }
+  /**
+   * Process a well-formed Authorization Requirements error response from a Globus service
+   * and redirect the user to the Globus Auth login page with the necessary parameters.
+   */
+  async handleAuthorizationRequirementsError(response, options) {
+    this.#transport = this.#buildTransport({
+      params: {
+        prompt: "login",
+        ...toAuthorizationQueryParams(response),
+        ...options?.additionalParams
+      }
+    });
+    await this.#transport.send();
+  }
+  /**
+   * Process a well-formed `ConsentRequired` error response from a Globus service
+   * and redirect the user to the Globus Auth login page with the necessary parameters.
+   */
+  async handleConsentRequiredError(response, options) {
+    this.#transport = this.#buildTransport({
+      scopes: this.#withOfflineAccess(response.required_scopes.join(" ")),
+      params: {
+        ...options?.additionalParams
+      }
+    });
+    await this.#transport.send();
+  }
+  /**
+   * Add a Globus Auth token response to storage, if `other_tokens` are present they are also added.
+   * This method is mostly used internally by the `AuthorizationManager`, but can be used by downstream
+   * consumers to add tokens to storage if necessary.
+   */
+  addTokenResponse = (token2) => {
+    getStorage().set(`${this.configuration.client}:${token2.resource_server}`, token2);
+    if ("other_tokens" in token2) {
+      token2.other_tokens?.forEach(this.addTokenResponse);
+    }
+    this.#checkAuthorizationState();
+  };
+  /**
+   * Call `AuthroizationManager.reset`, revoke all of the available tokns, and emit the `revoke` event.
+   * @emits AuthorizationManager.events#revoke
+   * @see AuthorizationManager.reset
+   */
+  async revoke() {
+    log("debug", "AuthorizationManager.revoke");
+    const revocation = Promise.all(this.tokens.getAll().map(this.#revokeToken.bind(this)));
+    this.reset();
+    await revocation;
+    await this.events.revoke.dispatch();
+  }
+  /**
+   * Revoke a token from a resource server.
+   */
+  #revokeToken(token2) {
+    log("debug", `AuthorizationManager.revokeToken | resource_server=${token2.resource_server}`);
+    return oauth2_exports.token.revoke({
+      payload: {
+        client_id: this.configuration.client,
+        token: token2.access_token
+      }
+    });
+  }
+};
+
+// src/core/authorization/index.ts
+function create(configuration) {
+  return new AuthorizationManager(configuration);
+}
+
+// src/services/transfer/index.ts
+var transfer_exports = {};
+__export(transfer_exports, {
+  CONFIG: () => CONFIG2,
+  access: () => access_exports,
+  collectionBookmarks: () => collection_bookmarks_exports,
+  endpoint: () => endpoint_exports,
+  endpointManager: () => endpoint_manager_exports,
+  endpointSearch: () => endpointSearch,
+  fileOperations: () => file_operations_exports,
+  task: () => task_exports,
+  taskSubmission: () => task_submission_exports,
+  utils: () => utils_exports
+});
+
+// src/services/transfer/service/endpoint-search.ts
+var endpointSearch = function(options, sdkOptions) {
+  const serviceRequestOptions = {
+    ...options,
+    /**
+     * Since the exported type used here is an `interface`, we effectivley have to
+     * "seal" the type, otherwise the compiler will complain about potentially mismatching index types.
+     */
+    query: options?.query
+  };
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_search`
+    },
+    serviceRequestOptions,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/file-operations.ts
+var file_operations_exports = {};
+__export(file_operations_exports, {
+  ls: () => ls,
+  mkdir: () => mkdir,
+  rename: () => rename,
+  stat: () => stat,
+  symlink: () => symlink
+});
+
+// src/services/transfer/shared.ts
+function getHeadersForService(method) {
+  if (method === "GET" /* GET */) {
+    return {};
+  }
+  return {
+    "Content-Type": "application/json"
+  };
+}
+
+// src/services/transfer/service/file-operations.ts
+var ls = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/operation/endpoint/${endpoint_xid}/ls`
+    },
+    options,
+    sdkOptions
+  );
+};
+var mkdir = function(endpoint_xid, options, sdkOptions) {
+  const serviceRequestOptions = {
+    payload: {
+      DATA_TYPE: "mkdir",
+      ...options?.payload
+    },
+    headers: {
+      ...getHeadersForService("POST" /* POST */),
+      ...options?.headers
+    }
+  };
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/operation/endpoint/${endpoint_xid}/mkdir`,
+      method: "POST" /* POST */
+    },
+    serviceRequestOptions,
+    sdkOptions
+  );
+};
+var rename = function(endpoint_xid, options, sdkOptions) {
+  const serviceRequestOptions = {
+    payload: {
+      DATA_TYPE: "rename",
+      ...options?.payload
+    },
+    headers: {
+      ...getHeadersForService("POST" /* POST */),
+      ...options?.headers
+    }
+  };
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/operation/endpoint/${endpoint_xid}/rename`,
+      method: "POST" /* POST */
+    },
+    serviceRequestOptions,
+    sdkOptions
+  );
+};
+var symlink = function(endpoint_xid, options, sdkOptions) {
+  const serviceRequestOptions = {
+    payload: {
+      DATA_TYPE: "symlink",
+      ...options?.payload
+    },
+    headers: {
+      ...getHeadersForService("POST" /* POST */),
+      ...options?.headers
+    }
+  };
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/operation/endpoint/${endpoint_xid}/symlink`,
+      method: "POST" /* POST */
+    },
+    serviceRequestOptions,
+    sdkOptions
+  );
+};
+var stat = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/operation/endpoint/${endpoint_xid}/stat`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/task-submission.ts
+var task_submission_exports = {};
+__export(task_submission_exports, {
+  submissionId: () => submissionId,
+  submitDelete: () => submitDelete,
+  submitTransfer: () => submitTransfer
+});
+var submitDelete = function(options, sdkOptions) {
+  const serviceRequestOptions = {
+    payload: {
+      DATA_TYPE: "delete",
+      ...options?.payload
+    },
+    headers: {
+      ...getHeadersForService("POST" /* POST */),
+      ...options?.headers
+    }
+  };
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/delete`,
+      method: "POST" /* POST */
+    },
+    serviceRequestOptions,
+    sdkOptions
+  );
+};
+var submitTransfer = function(options, sdkOptions) {
+  const serviceRequestOptions = {
+    payload: {
+      DATA_TYPE: "transfer",
+      ...options?.payload
+    },
+    headers: {
+      ...getHeadersForService("POST" /* POST */),
+      ...options?.headers
+    }
+  };
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/transfer`,
+      method: "POST" /* POST */
+    },
+    serviceRequestOptions,
+    sdkOptions
+  );
+};
+var submissionId = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/submission_id`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/endpoint.ts
+var endpoint_exports = {};
+__export(endpoint_exports, {
+  create: () => create2,
+  get: () => get2,
+  remove: () => remove,
+  update: () => update
+});
+var get2 = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var create2 = function(options, sdkOptions) {
+  if (options?.payload) {
+    Object.assign(options.payload, { DATA_TYPE: "shared_endpoint" });
+  }
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: "/v0.10/shared_endpoint",
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update = function(endpoint_xid, options, sdkOptions) {
+  if (options?.payload) {
+    Object.assign(options.payload, { DATA_TYPE: "endpoint" });
+  }
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/task.ts
+var task_exports = {};
+__export(task_exports, {
+  cancel: () => cancel,
+  get: () => get3,
+  getAll: () => getAll2,
+  getEventList: () => getEventList,
+  getPauseInfo: () => getPauseInfo,
+  getSkippedErrors: () => getSkippedErrors,
+  getSuccessfulTransfers: () => getSuccessfulTransfers,
+  remove: () => remove2,
+  update: () => update2
+});
+var getAll2 = function(options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get3 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var update2 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var cancel = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}/cancel`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove2 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}/remove`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var getEventList = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}/event_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getSuccessfulTransfers = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}/successful_transfers`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getSkippedErrors = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}/skipped_errors`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getPauseInfo = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task/${task_id}/pause_info`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/access.ts
+var access_exports = {};
+__export(access_exports, {
+  create: () => create3,
+  get: () => get4,
+  getAll: () => getAll3,
+  remove: () => remove3,
+  update: () => update3
+});
+var getAll3 = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}/access_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var create3 = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}/access`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var get4 = function({ endpoint_xid, id }, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}/access/${id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var update3 = function({ endpoint_xid, id }, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}/access/${id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove3 = function({ endpoint_xid, id }, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint/${endpoint_xid}/access/${id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/collection-bookmarks.ts
+var collection_bookmarks_exports = {};
+__export(collection_bookmarks_exports, {
+  create: () => create4,
+  get: () => get5,
+  getAll: () => getAll4,
+  remove: () => remove4,
+  update: () => update4
+});
+var getAll4 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/bookmark_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var create4 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/bookmark`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var get5 = function(bookmark_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/bookmark/${bookmark_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var update4 = function(bookmark_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/bookmark/${bookmark_id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove4 = function(bookmark_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/bookmark/${bookmark_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/endpoint-manager/index.ts
+var endpoint_manager_exports = {};
+__export(endpoint_manager_exports, {
+  endpoint: () => endpoint_exports2,
+  pauseRule: () => pause_rule_exports,
+  task: () => task_exports2
+});
+
+// src/services/transfer/service/endpoint-manager/endpoint.ts
+var endpoint_exports2 = {};
+__export(endpoint_exports2, {
+  get: () => get6,
+  getAccessList: () => getAccessList,
+  getHostedEndpoints: () => getHostedEndpoints,
+  getMonitoredEndpoints: () => getMonitoredEndpoints
+});
+var get6 = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/endpoint/${endpoint_xid}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getHostedEndpoints = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/endpoint/${endpoint_xid}/hosted_endpoint_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getAccessList = function(endpoint_xid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/endpoint/${endpoint_xid}/access_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getMonitoredEndpoints = function(options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/monitored_endpoints`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/endpoint-manager/pause-rule.ts
+var pause_rule_exports = {};
+__export(pause_rule_exports, {
+  create: () => create5,
+  get: () => get7,
+  getAll: () => getAll5,
+  remove: () => remove5,
+  update: () => update5
+});
+var getAll5 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/pause_rule_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var create5 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/pause_rule`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var get7 = function(pause_rule_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/pause_rule/${pause_rule_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var update5 = function(pause_rule_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/pause_rule/${pause_rule_id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove5 = function(pause_rule_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/pause_rule/${pause_rule_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/service/endpoint-manager/task.ts
+var task_exports2 = {};
+__export(task_exports2, {
+  cancel: () => cancel2,
+  get: () => get8,
+  getAdminCancel: () => getAdminCancel,
+  getAll: () => getAll6,
+  getEventList: () => getEventList2,
+  getPauseInfo: () => getPauseInfo2,
+  getSkippedErrors: () => getSkippedErrors2,
+  getSuccessfulTransfers: () => getSuccessfulTransfers2,
+  pause: () => pause,
+  resume: () => resume
+});
+var getAll6 = function(options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/task_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get8 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/task/${task_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var cancel2 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/admin_cancel`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var getAdminCancel = function(admin_cancel_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/admin_cancel/${admin_cancel_id}`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var getEventList2 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/task/${task_id}/event_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getSuccessfulTransfers2 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/task/${task_id}/successful_transfers`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getSkippedErrors2 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/task/${task_id}/skipped_errors`
+    },
+    options,
+    sdkOptions
+  );
+};
+var pause = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/admin_pause`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var resume = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/admin_resume`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var getPauseInfo2 = function(task_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID,
+      scope: SCOPES.ALL,
+      path: `/v0.10/endpoint_manager/task/${task_id}/pause_info`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/transfer/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  getDomainFromEndpoint: () => getDomainFromEndpoint,
+  isDirectory: () => isDirectory,
+  isFileDocument: () => isFileDocument,
+  readableBytes: () => readableBytes
+});
+function isFileDocument(entry) {
+  return typeof entry === "object" && entry !== null && "DATA_TYPE" in entry && entry.DATA_TYPE === "file";
+}
+function isDirectory(entry) {
+  return isFileDocument(entry) && entry.type === "dir";
+}
+var KB = 1e3;
+var MB = KB * 1e3;
+var GB = MB * 1e3;
+var TB = GB * 1e3;
+var PB = TB * 1e3;
+function readableBytes(bytes, truncate = 2) {
+  let unit = "B";
+  let bytesInUnit = 1;
+  if (bytes < KB) {
+    return `${bytes} ${unit}`;
+  }
+  if (bytes < MB) {
+    unit = "KB";
+    bytesInUnit = KB;
+  } else if (bytes < GB) {
+    unit = "MB";
+    bytesInUnit = MB;
+  } else if (bytes < TB) {
+    unit = "GB";
+    bytesInUnit = GB;
+  } else if (bytes < PB) {
+    unit = "TB";
+    bytesInUnit = TB;
+  } else {
+    unit = "PB";
+    bytesInUnit = PB;
+  }
+  const value = bytes / bytesInUnit;
+  const [int, dec] = `${value}`.split(".");
+  let rendered = `${int}`;
+  if (dec && dec.length) {
+    const truncated = dec.slice(0, truncate);
+    if (truncated.length) {
+      rendered = `${int}.${truncated}`;
+    }
+  }
+  return `${rendered} ${unit}`;
+}
+var GLOBUS_DNS_DOMAINS = ["dnsteam.globuscs.info", "data.globus.org", "dn.glob.us"];
+function getDomainFromEndpoint(endpoint) {
+  const { tlsftp_server: tls } = endpoint;
+  if (!tls || typeof tls !== "string") {
+    return null;
+  }
+  const { hostname } = new URL(tls.replace("tlsftp", "https"));
+  const hasCustomDomain = !GLOBUS_DNS_DOMAINS.find((d) => hostname.endsWith(d));
+  const customDomain = hasCustomDomain && /(?:[gm]-\w{6}.)?(\w+(\.\w+)+)$/.exec(hostname)?.[1];
+  return customDomain || hostname || null;
+}
+
+// src/services/transfer/index.ts
+var CONFIG2 = config_exports;
+
+// src/services/search/index.ts
+var search_exports = {};
+__export(search_exports, {
+  CONFIG: () => CONFIG3,
+  entry: () => entry_exports,
+  index: () => search_index_exports,
+  query: () => query_exports,
+  subject: () => subject_exports
+});
+
+// src/services/search/service/query.ts
+var query_exports = {};
+__export(query_exports, {
+  get: () => get9,
+  post: () => post
+});
+var get9 = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.SEARCH,
+      path: `/v1/index/${index_id}/search`
+    },
+    options,
+    sdkOptions
+  );
+};
+var post = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.SEARCH,
+      path: `/v1/index/${index_id}/search`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/search/service/subject.ts
+var subject_exports = {};
+__export(subject_exports, {
+  get: () => get10
+});
+var get10 = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.SEARCH,
+      path: `/v1/index/${index_id}/subject`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/search/service/entry.ts
+var entry_exports = {};
+__export(entry_exports, {
+  get: () => get11
+});
+var get11 = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.SEARCH,
+      path: `/v1/index/${index_id}/entry`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/search/service/search-index.ts
+var search_index_exports = {};
+__export(search_index_exports, {
+  create: () => create6,
+  get: () => get12,
+  getAll: () => getAll7,
+  ingest: () => ingest,
+  remove: () => remove6,
+  reopen: () => reopen
+});
+var get12 = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      // scope: SCOPES.ALL,
+      path: `/v1/index/${index_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var getAll7 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.ALL,
+      path: `/v1/index_list`
+    },
+    options,
+    sdkOptions
+  );
+};
+var create6 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.ALL,
+      path: `/v1/index`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove6 = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.ALL,
+      path: `/v1/index/${index_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var reopen = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.ALL,
+      path: `/v1/index/${index_id}/reopen`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var ingest = function(index_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID5,
+      scope: SCOPES4.ALL,
+      path: `/v1/index/${index_id}/ingest`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/search/index.ts
+var CONFIG3 = config_exports5;
+
+// src/services/groups/index.ts
+var groups_exports2 = {};
+__export(groups_exports2, {
+  CONFIG: () => CONFIG4,
+  groups: () => groups_exports,
+  membership: () => membership_exports,
+  policies: () => policies_exports
+});
+
+// src/services/groups/service/groups.ts
+var groups_exports = {};
+__export(groups_exports, {
+  get: () => get13,
+  getMyGroups: () => getMyGroups
+});
+var getMyGroups = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      scope: SCOPES3.ALL,
+      path: `/v2/groups/my_groups`,
+      service: ID4
+    },
+    options,
+    sdkOptions
+  );
+};
+var get13 = function(group_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID4,
+      scope: SCOPES3.ALL,
+      path: `/v2/groups/${group_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/groups/service/policies.ts
+var policies_exports = {};
+__export(policies_exports, {
+  get: () => get14
+});
+var get14 = function(group_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      scope: SCOPES3.ALL,
+      path: `/v2/groups/${group_id}/policies`,
+      service: ID4
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/groups/service/membership.ts
+var membership_exports = {};
+__export(membership_exports, {
+  act: () => act
+});
+var act = function(group_id, options, sdkOptions) {
+  if (!options?.payload) throw new Error("payload is required.");
+  return serviceRequest(
+    {
+      service: ID4,
+      scope: SCOPES3.ALL,
+      path: `/v2/groups/${group_id}`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/groups/index.ts
+var CONFIG4 = config_exports4;
+
+// src/services/flows/index.ts
+var flows_exports2 = {};
+__export(flows_exports2, {
+  CONFIG: () => CONFIG5,
+  flows: () => flows_exports,
+  runs: () => runs_exports
+});
+
+// src/services/flows/service/flows.ts
+var flows_exports = {};
+__export(flows_exports, {
+  get: () => get15,
+  getAll: () => getAll8,
+  remove: () => remove7,
+  run: () => run
+});
+var getAll8 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID2,
+      scope: SCOPES2.VIEW_FLOWS,
+      path: `/flows`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get15 = function(flow_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID2,
+      scope: SCOPES2.VIEW_FLOWS,
+      path: `/flows/${flow_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove7 = function(flow_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      scope: SCOPES2.MANAGE_FLOWS,
+      service: ID2,
+      path: `/flows/${flow_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var run = function(flow_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID2,
+      scope: SCOPES2.VIEW_FLOWS,
+      path: `/flows/${flow_id}/run`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/flows/service/runs.ts
+var runs_exports = {};
+__export(runs_exports, {
+  cancel: () => cancel3,
+  getAll: () => getAll9,
+  getLog: () => getLog
+});
+var getAll9 = function(options = {}, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID2,
+      scope: SCOPES2.RUN_MANAGE,
+      path: `/runs`
+    },
+    options,
+    sdkOptions
+  );
+};
+var cancel3 = function(run_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID2,
+      scope: SCOPES2.RUN_MANAGE,
+      path: `/runs/${run_id}/cancel`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var getLog = function(run_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID2,
+      scope: SCOPES2.RUN_MANAGE,
+      path: `/runs/${run_id}/log`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/flows/index.ts
+var CONFIG5 = config_exports2;
+
+// src/services/globus-connect-server/index.ts
+var globus_connect_server_exports = {};
+__export(globus_connect_server_exports, {
+  collections: () => collections_exports,
+  endpoint: () => endpoint_exports3,
+  getRequiredScopes: () => getRequiredScopes,
+  https: () => https_exports,
+  roles: () => roles_exports,
+  storageGateways: () => storage_gateways_exports,
+  userCredentials: () => user_credentials_exports,
+  versioning: () => versioning_exports
+});
+
+// src/services/globus-connect-server/service/collections.ts
+var collections_exports = {};
+__export(collections_exports, {
+  create: () => create7,
+  get: () => get16,
+  getAll: () => getAll10,
+  patch: () => patch,
+  remove: () => remove8,
+  resetOwnerString: () => resetOwnerString,
+  update: () => update6,
+  updateOwnerString: () => updateOwnerString
+});
+var getAll10 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get16 = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove8 = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var create7 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update6 = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var patch = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`,
+      method: "PATCH" /* PATCH */
+    },
+    options,
+    sdkOptions
+  );
+};
+var updateOwnerString = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}/owner_string`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var resetOwnerString = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}/owner_string`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/globus-connect-server/service/endpoint.ts
+var endpoint_exports3 = {};
+__export(endpoint_exports3, {
+  get: () => get17,
+  patch: () => patch2,
+  resetOwnerString: () => resetOwnerString2,
+  update: () => update7,
+  updateOwner: () => updateOwner,
+  updateOwnerString: () => updateOwnerString2,
+  updateSubscriptionId: () => updateSubscriptionId
+});
+var get17 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint`
+    },
+    options,
+    sdkOptions
+  );
+};
+var update7 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var patch2 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint`,
+      method: "PATCH" /* PATCH */
+    },
+    options,
+    sdkOptions
+  );
+};
+var updateSubscriptionId = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint/subscription_id`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var updateOwner = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint/owner`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var updateOwnerString2 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint/owner_string`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var resetOwnerString2 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint/owner_string`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/globus-connect-server/service/https.ts
+var https_exports = {};
+__export(https_exports, {
+  get: () => get18,
+  remove: () => remove9,
+  update: () => update8
+});
+var get18 = function(configuration, path, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove9 = function(configuration, path, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update8 = function(configuration, path, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/globus-connect-server/service/roles.ts
+var roles_exports = {};
+__export(roles_exports, {
+  create: () => create8,
+  get: () => get19,
+  getAll: () => getAll11,
+  remove: () => remove10
+});
+var getAll11 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/roles`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get19 = function(configuration, role_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/roles/${role_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove10 = function(configuration, role_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/roles/${role_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var create8 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/roles`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/globus-connect-server/service/storage-gateways.ts
+var storage_gateways_exports = {};
+__export(storage_gateways_exports, {
+  create: () => create9,
+  get: () => get20,
+  getAll: () => getAll12,
+  patch: () => patch3,
+  remove: () => remove11,
+  update: () => update9
+});
+var getAll12 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get20 = function(configuration, storage_gateway_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways/${storage_gateway_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove11 = function(configuration, storage_gateway_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways/${storage_gateway_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var create9 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update9 = function(configuration, storage_gateway_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways/${storage_gateway_id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var patch3 = function(configuration, storage_gateway_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways/${storage_gateway_id}`,
+      method: "PATCH" /* PATCH */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/globus-connect-server/service/user-credentials.ts
+var user_credentials_exports = {};
+__export(user_credentials_exports, {
+  create: () => create10,
+  get: () => get21,
+  getAll: () => getAll13,
+  patch: () => patch4,
+  remove: () => remove12,
+  update: () => update10
+});
+var getAll13 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get21 = function(configuration, user_credential_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials/${user_credential_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove12 = function(configuration, user_credential_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials/${user_credential_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var create10 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update10 = function(configuration, user_credential_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials/${user_credential_id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var patch4 = function(configuration, user_credential_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials/${user_credential_id}`,
+      method: "PATCH" /* PATCH */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/globus-connect-server/service/versioning.ts
+var versioning_exports = {};
+__export(versioning_exports, {
+  info: () => info
+});
+var info = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/info`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/globus-connect-server/index.ts
+var SCOPES7 = {
+  HIGH_ASSURANCE: "urn:globus:auth:scope:<ENDPOINT_ID>:manage_collections",
+  NON_HIGH_ASSURANCE: "urn:globus:auth:scope:<ENDPOINT_ID>:manage_collections[*https://auth.globus.org/scopes/<MAPPED_COLLECTION_ID>/data_access]"
+};
+function getRequiredScopes(configuration) {
+  return SCOPES7.HIGH_ASSURANCE.replace("<ENDPOINT_ID>", configuration.endpoint_id);
+}
+
+// src/services/timer/index.ts
+var timer_exports = {};
+__export(timer_exports, {
+  CONFIG: () => CONFIG6,
+  create: () => create11
+});
+
+// src/services/timer/service/timer.ts
+var create11 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID3,
+      scope: "https://auth.globus.org/scopes/524230d7-ea86-4a52-8312-86065a9e0417/timer",
+      path: "/v2/timer",
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/timer/index.ts
+var CONFIG6 = config_exports3;
+
+// src/services/compute/index.ts
+var compute_exports = {};
+__export(compute_exports, {
+  CONFIG: () => CONFIG7,
+  endpoints: () => endpoints_exports
+});
+
+// src/services/compute/service/endpoints.ts
+var endpoints_exports = {};
+__export(endpoints_exports, {
+  get: () => get22,
+  getAll: () => getAll14,
+  getStatus: () => getStatus
+});
+var getAll14 = function(options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID6,
+      scope: SCOPES5.ALL,
+      path: "/v2/endpoints",
+      method: "GET" /* GET */
+    },
+    options,
+    sdkOptions
+  );
+};
+var get22 = function(endpoint_uuid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID6,
+      scope: SCOPES5.ALL,
+      path: `/v2/endpoints/${endpoint_uuid}`,
+      method: "GET" /* GET */
+    },
+    options,
+    sdkOptions
+  );
+};
+var getStatus = function(endpoint_uuid, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: ID6,
+      scope: SCOPES5.ALL,
+      path: `/v2/endpoints/${endpoint_uuid}/status`
+    },
+    options,
+    sdkOptions
+  );
+};
+
+// src/services/compute/index.ts
+var CONFIG7 = config_exports6;
+
+// src/apps/web.ts
+var web_exports = {};
+__export(web_exports, {
+  HOSTS: () => HOSTS8,
+  host: () => host,
+  url: () => url,
+  urlFor: () => urlFor
+});
+var HOSTS8 = {
+  integration: "app.integration.globuscs.info",
+  sandbox: "app.sandbox.globuscs.info",
+  test: "app.test.globuscs.info",
+  staging: "app.staging.globuscs.info",
+  preview: "app.preview.globus.org",
+  production: "app.globus.org"
+};
+function host(env2 = getEnvironment()) {
+  return HOSTS8[env2];
+}
+function url(path, sdkOptions) {
+  return new URL(path || "", `https://${host(sdkOptions?.environment)}`);
+}
+var WEBAPP_URLS = {
+  TASK: "/activity/%s/overview",
+  COLLECTION: "/file-manager/collections/%s/overview",
+  ENDPOINT: "/file-manager/collections/%s/overview"
+};
+function urlFor(identifier, segments, sdkOptions) {
+  const path = WEBAPP_URLS[identifier].replace(/%s/g, segments?.join("/") || "");
+  return url(path, sdkOptions);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  auth,
+  authorization,
+  compute,
+  errors,
+  flows,
+  gcs,
+  groups,
+  info,
+  logger,
+  search,
+  timer,
+  transfer,
+  webapp
+});
+//# sourceMappingURL=index.js.map