@globus/sdk 3.9.0 → 4.0.0-rc.1

package/dist/cjs/services/globus-connect-server/client.js

@@ -0,0 +1,910 @@
+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/services/globus-connect-server/client.ts
+var client_exports = {};
+__export(client_exports, {
+  getClient: () => getClient
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/services/shared.ts
+var import_cross_fetch = __toESM(require("cross-fetch"));
+
+// 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 getClientInfo() {
+  return toString(INFOS);
+}
+function getClientInfoRequestHeaders() {
+  if (!isEnabled()) {
+    return {};
+  }
+  return {
+    [CLIENT_INFO_HEADER]: getClientInfo()
+  };
+}
+
+// src/services/transfer/config.ts
+var ID = "TRANSFER";
+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 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"
+};
+
+// src/services/timer/config.ts
+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 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"
+};
+
+// src/services/search/config.ts
+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"
+};
+
+// src/services/compute/config.ts
+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"
+};
+
+// 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 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 EnvironmentConfigurationError = class extends Error {
+  name = "EnvironmentConfigurationError";
+  constructor(variable, value) {
+    super();
+    this.message = `Invalid configuration value provided for ${variable} (${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/logger.ts
+var LOG_LEVELS = ["debug", "info", "warn", "error"];
+var logger;
+var level = LOG_LEVELS.indexOf("error");
+function log(severity, ...args) {
+  if (!logger) return;
+  if (LOG_LEVELS.indexOf(severity) < level) {
+    return;
+  }
+  const handler = logger[severity] ?? logger.log;
+  handler(...args);
+}
+
+// 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 host = getServiceHost(service, environment);
+  return env(`GLOBUS_SDK_SERVICE_URL_${service}`, host ? `https://${host}` : 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 url;
+  if (typeof serviceOrConfiguration === "object") {
+    url = new URL(path, serviceOrConfiguration.host);
+  } else {
+    url = getServiceURL(serviceOrConfiguration, path, sdkOptions?.environment);
+  }
+  if (options && options.search) {
+    url.search = stringifyParameters(options.search);
+  }
+  return url.toString();
+}
+
+// src/services/auth/index.ts
+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;
+}
+
+// src/services/shared.ts
+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 token;
+  if (config.resource_server && manager) {
+    token = manager.tokens.getByResourceServer(config.resource_server);
+    if (token) {
+      headers["Authorization"] = `Bearer ${token.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
+    );
+    token = manager.tokens.getByResourceServer(resourceServer);
+    if (token) {
+      headers["Authorization"] = `Bearer ${token.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 url = 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 || !token || !isRefreshToken(token)) {
+    return handler(url, init);
+  }
+  const initialResponse = await handler(url, 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(token);
+    if (!newToken) {
+      return initialResponse;
+    }
+    return handler(url, {
+      ...init,
+      headers: {
+        ...init.headers,
+        Authorization: `Bearer ${newToken.access_token}`
+      }
+    });
+  }
+  return initialResponse;
+}
+
+// src/services/globus-connect-server/service/endpoint.ts
+var get = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint`
+    },
+    options,
+    sdkOptions
+  );
+};
+var update = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var patch = 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 updateOwnerString = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/endpoint/owner_string`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var resetOwnerString = 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 get2 = function(configuration, path, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove = function(configuration, path, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update2 = 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 getAll = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/roles`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get3 = function(configuration, role_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/roles/${role_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove2 = function(configuration, role_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/roles/${role_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var create = 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 getAll2 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get4 = function(configuration, storage_gateway_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways/${storage_gateway_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove3 = 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 create2 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/storage_gateways`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update3 = 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 patch2 = 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 getAll3 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get5 = function(configuration, user_credential_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials/${user_credential_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove4 = 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 create3 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/user_credentials`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update4 = 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 patch3 = 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 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 SCOPES2 = {
+  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 SCOPES2.HIGH_ASSURANCE.replace("<ENDPOINT_ID>", configuration.endpoint_id);
+}
+
+// src/services/globus-connect-server/service/collections.ts
+var getAll4 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections`
+    },
+    options,
+    sdkOptions
+  );
+};
+var get6 = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`
+    },
+    options,
+    sdkOptions
+  );
+};
+var remove5 = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`,
+      method: "DELETE" /* DELETE */
+    },
+    options,
+    sdkOptions
+  );
+};
+var create4 = function(configuration, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections`,
+      method: "POST" /* POST */
+    },
+    options,
+    sdkOptions
+  );
+};
+var update5 = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`,
+      method: "PUT" /* PUT */
+    },
+    options,
+    sdkOptions
+  );
+};
+var patch4 = function(configuration, collection_id, options, sdkOptions) {
+  return serviceRequest(
+    {
+      service: configuration,
+      scope: getRequiredScopes(configuration),
+      path: `/api/collections/${collection_id}`,
+      method: "PATCH" /* PATCH */
+    },
+    options,
+    sdkOptions
+  );
+};
+var updateOwnerString2 = 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 resetOwnerString2 = 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/client.ts
+function bind(method, ...bound) {
+  return function(...args) {
+    return method(...bound, ...args);
+  };
+}
+function getClient(configuration) {
+  return {
+    configuration,
+    endpoint: {
+      get: bind(get, configuration),
+      update: bind(update, configuration),
+      patch: bind(patch, configuration),
+      updateSubscriptionId: bind(updateSubscriptionId, configuration),
+      updateOwner: bind(updateOwner, configuration),
+      updateOwnerString: bind(updateOwnerString, configuration),
+      resetOwnerString: bind(resetOwnerString, configuration)
+    },
+    versioning: {
+      info: bind(info, configuration)
+    },
+    collections: {
+      get: bind(get6, configuration),
+      getAll: bind(getAll4, configuration),
+      create: bind(create4, configuration),
+      remove: bind(remove5, configuration),
+      update: bind(update5, configuration),
+      patch: bind(patch4, configuration),
+      updateOwnerString: bind(updateOwnerString2, configuration),
+      resetOwnerString: bind(resetOwnerString2, configuration)
+    },
+    userCredentials: {
+      get: bind(get5, configuration),
+      getAll: bind(getAll3, configuration),
+      create: bind(create3, configuration),
+      remove: bind(remove4, configuration),
+      update: bind(update4, configuration),
+      patch: bind(patch3, configuration)
+    },
+    storageGateways: {
+      get: bind(get4, configuration),
+      getAll: bind(getAll2, configuration),
+      create: bind(create2, configuration),
+      remove: bind(remove3, configuration),
+      update: bind(update3, configuration),
+      patch: bind(patch2, configuration)
+    },
+    roles: {
+      get: bind(get3, configuration),
+      getAll: bind(getAll, configuration),
+      create: bind(create, configuration),
+      remove: bind(remove2, configuration)
+    },
+    https: {
+      get: bind(get2, configuration),
+      remove: bind(remove, configuration),
+      update: bind(update2, configuration)
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getClient
+});
+//# sourceMappingURL=client.js.map