@scaleway/sdk 2.25.0 → 2.27.0

package/dist/index.js

@@ -1,81 +1,115 @@
-export { enableConsoleLogger, setLogger } from './internal/logger/index.js';
-export { createAdvancedClient, createClient } from './scw/client.js';
-export { withAdditionalInterceptors, withDefaultPageSize, withHTTPClient, withProfile, withUserAgent, withUserAgentSuffix } from './scw/client-ini-factory.js';
-import * as index from './scw/errors/standard/index.js';
-export { index as Errors };
-export { isJSONObject } from './helpers/json.js';
-export { createExponentialBackoffStrategy, tryAtIntervals, waitForResource } from './internal/async/interval-retrier.js';
-export { addAsyncHeaderInterceptor } from './internal/interceptors/helpers.js';
-export { API } from './scw/api.js';
-export { authenticateWithSessionToken } from './scw/auth.js';
-export { marshalMoney, marshalScwFile, marshalTimeSeries, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint } from './scw/custom-marshalling.js';
-export { resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalMapOfObject, urlParams, validatePathParam } from './helpers/marshalling.js';
-export { enrichForPagination } from './scw/fetch/resource-paginator.js';
-import * as index$1 from './api/account/index.js';
-export { index$1 as Account };
-import * as index$2 from './api/applesilicon/index.js';
-export { index$2 as AppleSilicon };
-import * as index$3 from './api/baremetal/index.js';
-export { index$3 as BareMetal };
-import * as index$4 from './api/billing/index.js';
-export { index$4 as Billing };
-import * as index$5 from './api/block/index.js';
-export { index$5 as Block };
-import * as index$6 from './api/cockpit/index.js';
-export { index$6 as Cockpit };
-import * as index$7 from './api/container/index.js';
-export { index$7 as Container };
-import * as index$8 from './api/dedibox/index.js';
-export { index$8 as Dedibox };
-import * as index$9 from './api/document_db/index.js';
-export { index$9 as DocumentDB };
-import * as index$a from './api/domain/index.js';
-export { index$a as Domain };
-import * as index$b from './api/flexibleip/index.js';
-export { index$b as FlexibleIP };
-import * as index$c from './api/function/index.js';
-export { index$c as Function };
-import * as index$d from './api/iam/index.js';
-export { index$d as IAM };
-import * as index$e from './api/instance/index.js';
-export { index$e as Instance };
-import * as index$f from './api/iot/index.js';
-export { index$f as IOT };
-import * as index$g from './api/ipam/index.js';
-export { index$g as IPAM };
-import * as index$h from './api/ipfs/index.js';
-export { index$h as IPFS };
-import * as index$i from './api/jobs/index.js';
-export { index$i as Jobs };
-import * as index$j from './api/k8s/index.js';
-export { index$j as K8S };
-import * as index$k from './api/lb/index.js';
-export { index$k as LB };
-import * as index$l from './api/llm_inference/index.js';
-export { index$l as LLMInference };
-import * as index$m from './api/marketplace/index.js';
-export { index$m as Marketplace };
-import * as index$n from './api/mnq/index.js';
-export { index$n as MNQ };
-import * as index$o from './api/rdb/index.js';
-export { index$o as RDB };
-import * as index$p from './api/redis/index.js';
-export { index$p as Redis };
-import * as index$q from './api/registry/index.js';
-export { index$q as Registry };
-import * as index$r from './api/secret/index.js';
-export { index$r as Secret };
-import * as index$s from './api/serverless_sqldb/index.js';
-export { index$s as ServerlessSQLDB };
-import * as index_gen from './api/std/index.gen.js';
-export { index_gen as Std };
-import * as index$t from './api/test/index.js';
-export { index$t as Test };
-import * as index$u from './api/tem/index.js';
-export { index$u as TransactionalEmail };
-import * as index$v from './api/vpc/index.js';
-export { index$v as VPC };
-import * as index$w from './api/vpcgw/index.js';
-export { index$w as VPCGW };
-import * as index$x from './api/webhosting/index.js';
-export { index$x as Webhosting };
+import { enableConsoleLogger, setLogger } from "./internal/logger/index.js";
+import { createAdvancedClient, createClient } from "./scw/client.js";
+import { withAdditionalInterceptors, withDefaultPageSize, withHTTPClient, withProfile, withUserAgent, withUserAgentSuffix } from "./scw/client-ini-factory.js";
+import * as index from "./scw/errors/standard/index.js";
+import { isJSONObject } from "./helpers/json.js";
+import { createExponentialBackoffStrategy, tryAtIntervals, waitForResource } from "./internal/async/interval-retrier.js";
+import { addAsyncHeaderInterceptor } from "./internal/interceptors/helpers.js";
+import { API } from "./scw/api.js";
+import { authenticateWithSessionToken } from "./scw/auth.js";
+import { marshalMoney, marshalScwFile, marshalTimeSeries, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint } from "./scw/custom-marshalling.js";
+import { resolveOneOf, unmarshalArrayOfObject, unmarshalDate, unmarshalMapOfObject, urlParams, validatePathParam } from "./helpers/marshalling.js";
+import { enrichForPagination } from "./scw/fetch/resource-paginator.js";
+import * as index$1 from "./api/account/index.js";
+import * as index$2 from "./api/applesilicon/index.js";
+import * as index$3 from "./api/baremetal/index.js";
+import * as index$4 from "./api/billing/index.js";
+import * as index$5 from "./api/block/index.js";
+import * as index$6 from "./api/cockpit/index.js";
+import * as index$7 from "./api/container/index.js";
+import * as index$8 from "./api/dedibox/index.js";
+import * as index$9 from "./api/document_db/index.js";
+import * as index$a from "./api/domain/index.js";
+import * as index$b from "./api/flexibleip/index.js";
+import * as index$c from "./api/function/index.js";
+import * as index$d from "./api/iam/index.js";
+import * as index$e from "./api/instance/index.js";
+import * as index$f from "./api/iot/index.js";
+import * as index$g from "./api/ipam/index.js";
+import * as index$h from "./api/ipfs/index.js";
+import * as index$i from "./api/jobs/index.js";
+import * as index$j from "./api/k8s/index.js";
+import * as index$k from "./api/lb/index.js";
+import * as index$l from "./api/llm_inference/index.js";
+import * as index$m from "./api/marketplace/index.js";
+import * as index$n from "./api/mnq/index.js";
+import * as index$o from "./api/rdb/index.js";
+import * as index$p from "./api/redis/index.js";
+import * as index$q from "./api/registry/index.js";
+import * as index$r from "./api/secret/index.js";
+import * as index$s from "./api/serverless_sqldb/index.js";
+import * as index_gen from "./api/std/index.gen.js";
+import * as index$t from "./api/test/index.js";
+import * as index$u from "./api/tem/index.js";
+import * as index$v from "./api/vpc/index.js";
+import * as index$w from "./api/vpcgw/index.js";
+import * as index$x from "./api/webhosting/index.js";
+export {
+  API,
+  index$1 as Account,
+  index$2 as AppleSilicon,
+  index$3 as BareMetal,
+  index$4 as Billing,
+  index$5 as Block,
+  index$6 as Cockpit,
+  index$7 as Container,
+  index$8 as Dedibox,
+  index$9 as DocumentDB,
+  index$a as Domain,
+  index as Errors,
+  index$b as FlexibleIP,
+  index$c as Function,
+  index$d as IAM,
+  index$f as IOT,
+  index$g as IPAM,
+  index$h as IPFS,
+  index$e as Instance,
+  index$i as Jobs,
+  index$j as K8S,
+  index$k as LB,
+  index$l as LLMInference,
+  index$n as MNQ,
+  index$m as Marketplace,
+  index$o as RDB,
+  index$p as Redis,
+  index$q as Registry,
+  index$r as Secret,
+  index$s as ServerlessSQLDB,
+  index_gen as Std,
+  index$t as Test,
+  index$u as TransactionalEmail,
+  index$v as VPC,
+  index$w as VPCGW,
+  index$x as Webhosting,
+  addAsyncHeaderInterceptor,
+  authenticateWithSessionToken,
+  createAdvancedClient,
+  createClient,
+  createExponentialBackoffStrategy,
+  enableConsoleLogger,
+  enrichForPagination,
+  isJSONObject,
+  marshalMoney,
+  marshalScwFile,
+  marshalTimeSeries,
+  resolveOneOf,
+  setLogger,
+  tryAtIntervals,
+  unmarshalArrayOfObject,
+  unmarshalDate,
+  unmarshalMapOfObject,
+  unmarshalMoney,
+  unmarshalScwFile,
+  unmarshalServiceInfo,
+  unmarshalTimeSeries,
+  unmarshalTimeSeriesPoint,
+  urlParams,
+  validatePathParam,
+  waitForResource,
+  withAdditionalInterceptors,
+  withDefaultPageSize,
+  withHTTPClient,
+  withProfile,
+  withUserAgent,
+  withUserAgentSuffix
+};

package/dist/internal/async/interval-retrier.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sleep = require("./sleep.cjs");
+const DEFAULT_TIMEOUT_SECONDS = 300;
+const DEFAULT_MIN_DELAY_SECONDS = 1;
+const DEFAULT_MAX_DELAY_SECONDS = 30;
+function* createExponentialBackoffStrategy(minDelay, maxDelay) {
+  if (minDelay < 1 || maxDelay < 1 || minDelay > maxDelay) {
+    throw new Error(
+      "Waiter: minDelay must be >= 1 and maxDelay must be >= minDelay"
+    );
+  }
+  let attempt = 1;
+  const ceiling = Math.log(maxDelay / minDelay) / Math.log(2) + 1;
+  const randomInRange = (min, max) => min + Math.random() * (max - min);
+  while (true) {
+    if (attempt > ceiling) {
+      yield maxDelay;
+    } else {
+      yield randomInRange(minDelay, minDelay * 2 ** (attempt - 1));
+    }
+    attempt += 1;
+  }
+}
+const tryAtIntervals = async (retry, strategy, timeout = DEFAULT_TIMEOUT_SECONDS) => {
+  const timeoutTimestamp = Date.now() + timeout * 1e3;
+  let retryCount = 0;
+  while (Date.now() <= timeoutTimestamp) {
+    const delay = strategy.next(retryCount += 1).value * 1e3;
+    if (timeoutTimestamp <= Date.now() + delay)
+      break;
+    await sleep.sleep(delay);
+    const { value, done } = await retry();
+    if (done)
+      return value;
+  }
+  throw new Error(`Timeout after ${timeout}s`);
+};
+const waitForResource = (stop, fetcher, request, options, strategy = createExponentialBackoffStrategy(
+  options?.minDelay ?? DEFAULT_MIN_DELAY_SECONDS,
+  options?.maxDelay ?? DEFAULT_MAX_DELAY_SECONDS
+)) => tryAtIntervals(
+  async () => {
+    const value = await fetcher(request);
+    return {
+      done: await stop(value),
+      value
+    };
+  },
+  strategy,
+  options?.timeout
+);
+exports.createExponentialBackoffStrategy = createExponentialBackoffStrategy;
+exports.tryAtIntervals = tryAtIntervals;
+exports.waitForResource = waitForResource;

package/dist/internal/async/interval-retrier.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Function to retry logic between each interval.
+ *
+ * @returns The result and if it's done
+ *
+ * @throws An exception might be thrown by the logic being run
+ *
+ * @internal
+ */
+type Retry<T> = () => Promise<IteratorResult<T, T>>;
+/**
+ * Generated interval strategy iterator.
+ *
+ * @internal
+ */
+type IntervalStrategy = Generator<number, number, number>;
+/**
+ * Creates a fixed interval strategy.
+ * It returns the same interval value whatever the retry count.
+ *
+ * @param interval - The time interval (in seconds) to wait between each run
+ * @returns A fixed interval generator
+ *
+ * @internal
+ */
+export declare function createFixedIntervalStrategy(interval: number): IntervalStrategy;
+/**
+ * Creates a fibonacci interval strategy.
+ *
+ * @param base - The base interval (in seconds) that will be multiplicated with the fibonacci number
+ * @param factor - The factor so the fibonacci suite will go slower or faster
+ * @returns A fibonnacci generator
+ *
+ * @internal
+ */
+export declare function createFibonacciIntervalStrategy(base?: number, factor?: number): IntervalStrategy;
+/**
+ * Creates an exponential backoff interval strategy.
+ *
+ * @param minDelay - The minimum delay before the next try in seconds
+ * @param maxDelay - The maximum delay before the next try in seconds
+ * @returns An exponential backoff generator
+ *
+ * @internal
+ */
+export declare function createExponentialBackoffStrategy(minDelay: number, maxDelay: number): IntervalStrategy;
+/**
+ * Tries a specific logic several times until it succeeds, timeouts, or throws an exception.
+ *
+ * @param retry - The function to retry logic between each interval
+ * @param strategy - A generated interval strategy iterator
+ * @param timeout - The maximum time elapsed before timeout error
+ *
+ * @throws An timeout exception or error thrown by the logic being run
+ *
+ * @internal
+ */
+export declare const tryAtIntervals: <T>(retry: Retry<T>, strategy: IntervalStrategy, timeout?: number) => Promise<T>;
+/**
+ * Represents the condition to stop waiting for a resource.
+ *
+ * @public
+ */
+export type WaitForStopCondition<T> = (obj: T) => Promise<boolean>;
+/**
+ * The options to wait until a resource is ready.
+ *
+ * @public
+ */
+export type WaitForOptions<T> = {
+    /**
+     * Timeout in seconds.
+     *
+     * @defaultValue 300 seconds (5 minutes).
+     */
+    timeout?: number;
+    /**
+     * The minimum delay before the next try in seconds.
+     *
+     * @defaultValue 1 second.
+     */
+    minDelay?: number;
+    /**
+     * The maximum delay before the next try in seconds.
+     *
+     * @defaultValue 30 seconds.
+     */
+    maxDelay?: number;
+    /**
+     * The condition to stop trying.
+     *
+     * @defaultValue Waits for non-transient value.
+     */
+    stop?: WaitForStopCondition<T>;
+};
+type ResourceFetcher<T, R> = (request: R) => Promise<T>;
+/**
+ * Fetches resource several times until an expected condition is reached, timeouts, or throws an exception.
+ *
+ * @param stop - The condition to stop waiting
+ * @param fetcher - The method to retrieve resource
+ * @param request - The resource request options
+ * @param options - The retry strategy options
+ * @param strategy - An optional custom strategy
+ *
+ * @returns A promise of resource
+ *
+ * @public
+ */
+export declare const waitForResource: <R, T>(stop: WaitForStopCondition<T>, fetcher: ResourceFetcher<T, R>, request: R, options?: WaitForOptions<T>, strategy?: IntervalStrategy) => Promise<Awaited<T>>;
+export {};

package/dist/internal/async/interval-retrier.js

@@ -1,26 +1,16 @@
-import { sleep } from './sleep.js';
-
+import { sleep } from "./sleep.js";
 const DEFAULT_TIMEOUT_SECONDS = 300;
 const DEFAULT_MIN_DELAY_SECONDS = 1;
 const DEFAULT_MAX_DELAY_SECONDS = 30;
-
-/**
- * Creates an exponential backoff interval strategy.
- *
- * @param minDelay - The minimum delay before the next try in seconds
- * @param maxDelay - The maximum delay before the next try in seconds
- * @returns An exponential backoff generator
- *
- * @internal
- */
 function* createExponentialBackoffStrategy(minDelay, maxDelay) {
   if (minDelay < 1 || maxDelay < 1 || minDelay > maxDelay) {
-    throw new Error('Waiter: minDelay must be >= 1 and maxDelay must be >= minDelay');
+    throw new Error(
+      "Waiter: minDelay must be >= 1 and maxDelay must be >= minDelay"
+    );
   }
   let attempt = 1;
   const ceiling = Math.log(maxDelay / minDelay) / Math.log(2) + 1;
   const randomInRange = (min, max) => min + Math.random() * (max - min);
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
   while (true) {
     if (attempt > ceiling) {
       yield maxDelay;
@@ -30,68 +20,36 @@ function* createExponentialBackoffStrategy(minDelay, maxDelay) {
     attempt += 1;
   }
 }
-
-/**
- * Tries a specific logic several times until it succeeds, timeouts, or throws an exception.
- *
- * @param retry - The function to retry logic between each interval
- * @param strategy - A generated interval strategy iterator
- * @param timeout - The maximum time elapsed before timeout error
- *
- * @throws An timeout exception or error thrown by the logic being run
- *
- * @internal
- */
 const tryAtIntervals = async (retry, strategy, timeout = DEFAULT_TIMEOUT_SECONDS) => {
-  const timeoutTimestamp = Date.now() + timeout * 1000;
+  const timeoutTimestamp = Date.now() + timeout * 1e3;
   let retryCount = 0;
   while (Date.now() <= timeoutTimestamp) {
-    const delay = strategy.next(retryCount += 1).value * 1000;
-    // Break if timeout has been reached
-    if (timeoutTimestamp <= Date.now() + delay) break;
-    // Wait before the next retry
+    const delay = strategy.next(retryCount += 1).value * 1e3;
+    if (timeoutTimestamp <= Date.now() + delay)
+      break;
     await sleep(delay);
-    // Retry
-    const {
-      value,
-      done
-    } = await retry();
-    if (done) return value;
+    const { value, done } = await retry();
+    if (done)
+      return value;
   }
   throw new Error(`Timeout after ${timeout}s`);
 };
-
-/**
- * Represents the condition to stop waiting for a resource.
- *
- * @public
- */
-
-/**
- * The options to wait until a resource is ready.
- *
- * @public
- */
-
-/**
- * Fetches resource several times until an expected condition is reached, timeouts, or throws an exception.
- *
- * @param stop - The condition to stop waiting
- * @param fetcher - The method to retrieve resource
- * @param request - The resource request options
- * @param options - The retry strategy options
- * @param strategy - An optional custom strategy
- *
- * @returns A promise of resource
- *
- * @public
- */
-const waitForResource = (stop, fetcher, request, options, strategy = createExponentialBackoffStrategy(options?.minDelay ?? DEFAULT_MIN_DELAY_SECONDS, options?.maxDelay ?? DEFAULT_MAX_DELAY_SECONDS)) => tryAtIntervals(async () => {
-  const value = await fetcher(request);
-  return {
-    done: await stop(value),
-    value
-  };
-}, strategy, options?.timeout);
-
-export { createExponentialBackoffStrategy, tryAtIntervals, waitForResource };
+const waitForResource = (stop, fetcher, request, options, strategy = createExponentialBackoffStrategy(
+  options?.minDelay ?? DEFAULT_MIN_DELAY_SECONDS,
+  options?.maxDelay ?? DEFAULT_MAX_DELAY_SECONDS
+)) => tryAtIntervals(
+  async () => {
+    const value = await fetcher(request);
+    return {
+      done: await stop(value),
+      value
+    };
+  },
+  strategy,
+  options?.timeout
+);
+export {
+  createExponentialBackoffStrategy,
+  tryAtIntervals,
+  waitForResource
+};

package/dist/internal/async/sleep.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+exports.sleep = sleep;

package/dist/internal/async/sleep.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sleep for a specified number of time.
+ *
+ * @param ms - The number of milliseconds
+ * @returns The sleep promise
+ *
+ * @internal
+ */
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/internal/async/sleep.js

@@ -1,13 +1,6 @@
-/**
- * Sleep for a specified number of time.
- *
- * @param ms - The number of milliseconds
- * @returns The sleep promise
- *
- * @internal
- */
-const sleep = ms => new Promise(resolve => {
+const sleep = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
 });
-
-export { sleep };
+export {
+  sleep
+};

package/dist/internal/interceptors/composer.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const composeRequestInterceptors = (interceptors) => async (request) => interceptors.reduce(
+  async (asyncResult, interceptor) => interceptor({ request: await asyncResult }),
+  Promise.resolve(request)
+);
+const composeResponseInterceptors = (interceptors) => async (response) => interceptors.reduce(
+  async (asyncResult, interceptor) => interceptor({ response: await asyncResult }),
+  Promise.resolve(response)
+);
+const composeResponseErrorInterceptors = (interceptors) => async (request, error) => {
+  let prevError = error;
+  for (const interceptor of interceptors) {
+    try {
+      const res = await interceptor({ request, error: prevError });
+      return res;
+    } catch (err) {
+      prevError = err;
+    }
+  }
+  throw prevError;
+};
+exports.composeRequestInterceptors = composeRequestInterceptors;
+exports.composeResponseErrorInterceptors = composeResponseErrorInterceptors;
+exports.composeResponseInterceptors = composeResponseInterceptors;

package/dist/internal/interceptors/composer.d.ts

@@ -0,0 +1,25 @@
+import type { RequestInterceptor, ResponseErrorInterceptor, ResponseInterceptor } from './types';
+/**
+ * Composes request interceptors.
+ *
+ * @param interceptors - A list of request interceptors
+ * @returns An async composed interceptor
+ *
+ * @internal
+ */
+export declare const composeRequestInterceptors: (interceptors: RequestInterceptor[]) => (request: Request) => Promise<Request>;
+/**
+ * Composes response interceptors.
+ *
+ * @param interceptors - A list of response interceptors
+ * @returns An async composed interceptor
+ *
+ * @internal
+ */
+export declare const composeResponseInterceptors: (interceptors: ResponseInterceptor[]) => (response: Response) => Promise<Response>;
+/**
+ * Compose response error interceptors.
+ *
+ * @internal
+ */
+export declare const composeResponseErrorInterceptors: (interceptors: ResponseErrorInterceptor[]) => (request: Request, error: unknown) => Promise<unknown>;

package/dist/internal/interceptors/composer.js

@@ -1,40 +1,16 @@
-/**
- * Composes request interceptors.
- *
- * @param interceptors - A list of request interceptors
- * @returns An async composed interceptor
- *
- * @internal
- */
-const composeRequestInterceptors = interceptors => async request => interceptors.reduce(async (asyncResult, interceptor) => interceptor({
-  request: await asyncResult
-}), Promise.resolve(request));
-
-/**
- * Composes response interceptors.
- *
- * @param interceptors - A list of response interceptors
- * @returns An async composed interceptor
- *
- * @internal
- */
-const composeResponseInterceptors = interceptors => async response => interceptors.reduce(async (asyncResult, interceptor) => interceptor({
-  response: await asyncResult
-}), Promise.resolve(response));
-
-/**
- * Compose response error interceptors.
- *
- * @internal
- */
-const composeResponseErrorInterceptors = interceptors => async (request, error) => {
+const composeRequestInterceptors = (interceptors) => async (request) => interceptors.reduce(
+  async (asyncResult, interceptor) => interceptor({ request: await asyncResult }),
+  Promise.resolve(request)
+);
+const composeResponseInterceptors = (interceptors) => async (response) => interceptors.reduce(
+  async (asyncResult, interceptor) => interceptor({ response: await asyncResult }),
+  Promise.resolve(response)
+);
+const composeResponseErrorInterceptors = (interceptors) => async (request, error) => {
   let prevError = error;
   for (const interceptor of interceptors) {
     try {
-      const res = await interceptor({
-        request,
-        error: prevError
-      });
+      const res = await interceptor({ request, error: prevError });
       return res;
     } catch (err) {
       prevError = err;
@@ -42,5 +18,8 @@ const composeResponseErrorInterceptors = interceptors => async (request, error)
   }
   throw prevError;
 };
-
-export { composeRequestInterceptors, composeResponseErrorInterceptors, composeResponseInterceptors };
+export {
+  composeRequestInterceptors,
+  composeResponseErrorInterceptors,
+  composeResponseInterceptors
+};

package/dist/internal/interceptors/helpers.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const addHeaderInterceptor = (key, value) => ({ request }) => {
+  const clone = request.clone();
+  if (value !== void 0) {
+    clone.headers.append(key, value);
+  }
+  return clone;
+};
+const addAsyncHeaderInterceptor = (key, getter) => async (request) => addHeaderInterceptor(key, await getter())(request);
+exports.addAsyncHeaderInterceptor = addAsyncHeaderInterceptor;
+exports.addHeaderInterceptor = addHeaderInterceptor;