@scaleway/sdk-std 1.0.1

package/node_modules/@scaleway/sdk-client/dist/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./internal/logger/index.cjs");
+const client = require("./scw/client.cjs");
+const constants = require("./scw/constants.cjs");
+const clientIniFactory = require("./scw/client-ini-factory.cjs");
+const customTypes = require("./scw/custom-types.cjs");
+const index$1 = require("./scw/errors/standard/index.cjs");
+const json = require("./helpers/json.cjs");
+const intervalRetrier = require("./internal/async/interval-retrier.cjs");
+const helpers = require("./internal/interceptors/helpers.cjs");
+const api = require("./scw/api.cjs");
+const auth = require("./scw/auth.cjs");
+const customMarshalling = require("./scw/custom-marshalling.cjs");
+const marshalling = require("./helpers/marshalling.cjs");
+const resourcePaginator = require("./scw/fetch/resource-paginator.cjs");
+exports.enableConsoleLogger = index.enableConsoleLogger;
+exports.setLogger = index.setLogger;
+exports.createAdvancedClient = client.createAdvancedClient;
+exports.createClient = client.createClient;
+exports.AUTH_HEADER_KEY = constants.AUTH_HEADER_KEY;
+exports.SESSION_HEADER_KEY = constants.SESSION_HEADER_KEY;
+exports.withAdditionalInterceptors = clientIniFactory.withAdditionalInterceptors;
+exports.withDefaultPageSize = clientIniFactory.withDefaultPageSize;
+exports.withHTTPClient = clientIniFactory.withHTTPClient;
+exports.withProfile = clientIniFactory.withProfile;
+exports.withUserAgent = clientIniFactory.withUserAgent;
+exports.withUserAgentSuffix = clientIniFactory.withUserAgentSuffix;
+exports.Decimal = customTypes.Decimal;
+exports.Errors = index$1;
+exports.isJSONObject = json.isJSONObject;
+exports.createExponentialBackoffStrategy = intervalRetrier.createExponentialBackoffStrategy;
+exports.tryAtIntervals = intervalRetrier.tryAtIntervals;
+exports.waitForResource = intervalRetrier.waitForResource;
+exports.addAsyncHeaderInterceptor = helpers.addAsyncHeaderInterceptor;
+exports.API = api.API;
+exports.authenticateWithSessionToken = auth.authenticateWithSessionToken;
+exports.marshalBlobToScwFile = customMarshalling.marshalBlobToScwFile;
+exports.marshalDecimal = customMarshalling.marshalDecimal;
+exports.marshalMoney = customMarshalling.marshalMoney;
+exports.marshalScwFile = customMarshalling.marshalScwFile;
+exports.marshalTimeSeries = customMarshalling.marshalTimeSeries;
+exports.unmarshalAnyRes = customMarshalling.unmarshalAnyRes;
+exports.unmarshalDecimal = customMarshalling.unmarshalDecimal;
+exports.unmarshalMoney = customMarshalling.unmarshalMoney;
+exports.unmarshalScwFile = customMarshalling.unmarshalScwFile;
+exports.unmarshalServiceInfo = customMarshalling.unmarshalServiceInfo;
+exports.unmarshalTimeSeries = customMarshalling.unmarshalTimeSeries;
+exports.unmarshalTimeSeriesPoint = customMarshalling.unmarshalTimeSeriesPoint;
+exports.resolveOneOf = marshalling.resolveOneOf;
+exports.unmarshalArrayOfObject = marshalling.unmarshalArrayOfObject;
+exports.unmarshalDate = marshalling.unmarshalDate;
+exports.unmarshalMapOfObject = marshalling.unmarshalMapOfObject;
+exports.urlParams = marshalling.urlParams;
+exports.validatePathParam = marshalling.validatePathParam;
+exports.enrichForPagination = resourcePaginator.enrichForPagination;

package/node_modules/@scaleway/sdk-client/dist/index.d.ts

@@ -0,0 +1,16 @@
+export type { WaitForOptions, WaitForStopCondition, } from './internal/async/interval-retrier.js';
+export type { NetworkInterceptors, RequestInterceptor, ResponseInterceptor, ResponseErrorInterceptor, } from './internal/interceptors/types';
+export { enableConsoleLogger, setLogger } from './internal/logger/index.js';
+export type { Logger } from './internal/logger/logger';
+export { createClient, createAdvancedClient } from './scw/client.js';
+export { AUTH_HEADER_KEY, SESSION_HEADER_KEY } from './scw/constants.js';
+export type { Client } from './scw/client.js';
+export type { Profile } from './scw/client-ini-profile.js';
+export type { Settings } from './scw/client-settings.js';
+export { withAdditionalInterceptors, withDefaultPageSize, withHTTPClient, withProfile, withUserAgent, withUserAgentSuffix, } from './scw/client-ini-factory.js';
+export type { ClientConfig } from './scw/client-ini-factory.js';
+export { Decimal } from './scw/custom-types.js';
+export type { Money, ScwFile, TimeSeries } from './scw/custom-types.js';
+export * as Errors from './scw/errors/standard/index.js';
+export type { Region, Zone } from './scw/locality';
+export * from './internals';

package/node_modules/@scaleway/sdk-client/dist/index.js

@@ -0,0 +1,56 @@
+import { enableConsoleLogger, setLogger } from "./internal/logger/index.js";
+import { createAdvancedClient, createClient } from "./scw/client.js";
+import { AUTH_HEADER_KEY, SESSION_HEADER_KEY } from "./scw/constants.js";
+import { withAdditionalInterceptors, withDefaultPageSize, withHTTPClient, withProfile, withUserAgent, withUserAgentSuffix } from "./scw/client-ini-factory.js";
+import { Decimal } from "./scw/custom-types.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 { marshalBlobToScwFile, marshalDecimal, marshalMoney, marshalScwFile, marshalTimeSeries, unmarshalAnyRes, unmarshalDecimal, 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";
+export {
+  API,
+  AUTH_HEADER_KEY,
+  Decimal,
+  index as Errors,
+  SESSION_HEADER_KEY,
+  addAsyncHeaderInterceptor,
+  authenticateWithSessionToken,
+  createAdvancedClient,
+  createClient,
+  createExponentialBackoffStrategy,
+  enableConsoleLogger,
+  enrichForPagination,
+  isJSONObject,
+  marshalBlobToScwFile,
+  marshalDecimal,
+  marshalMoney,
+  marshalScwFile,
+  marshalTimeSeries,
+  resolveOneOf,
+  setLogger,
+  tryAtIntervals,
+  unmarshalAnyRes,
+  unmarshalArrayOfObject,
+  unmarshalDate,
+  unmarshalDecimal,
+  unmarshalMapOfObject,
+  unmarshalMoney,
+  unmarshalScwFile,
+  unmarshalServiceInfo,
+  unmarshalTimeSeries,
+  unmarshalTimeSeriesPoint,
+  urlParams,
+  validatePathParam,
+  waitForResource,
+  withAdditionalInterceptors,
+  withDefaultPageSize,
+  withHTTPClient,
+  withProfile,
+  withUserAgent,
+  withUserAgentSuffix
+};

package/node_modules/@scaleway/sdk-client/dist/internal/async/interval-retrier.cjs

@@ -0,0 +1,53 @@
+"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/node_modules/@scaleway/sdk-client/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 interface 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/node_modules/@scaleway/sdk-client/dist/internal/async/interval-retrier.js

@@ -0,0 +1,53 @@
+import { sleep } from "./sleep.js";
+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(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
+);
+export {
+  createExponentialBackoffStrategy,
+  tryAtIntervals,
+  waitForResource
+};

package/node_modules/@scaleway/sdk-client/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/node_modules/@scaleway/sdk-client/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/node_modules/@scaleway/sdk-client/dist/internal/async/sleep.js

@@ -0,0 +1,6 @@
+const sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+export {
+  sleep
+};

package/node_modules/@scaleway/sdk-client/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/node_modules/@scaleway/sdk-client/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/node_modules/@scaleway/sdk-client/dist/internal/interceptors/composer.js

@@ -0,0 +1,25 @@
+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;
+};
+export {
+  composeRequestInterceptors,
+  composeResponseErrorInterceptors,
+  composeResponseInterceptors
+};

package/node_modules/@scaleway/sdk-client/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;

package/node_modules/@scaleway/sdk-client/dist/internal/interceptors/helpers.d.ts

@@ -0,0 +1,21 @@
+import type { RequestInterceptor } from './types';
+/**
+ * Adds an header to a request through an interceptor.
+ *
+ * @param key - The header key
+ * @param value - The header value
+ * @returns The Request interceptor
+ *
+ * @internal
+ */
+export declare const addHeaderInterceptor: (key: string, value?: string) => RequestInterceptor;
+/**
+ * Adds asynchronously an header to a request through an interceptor.
+ *
+ * @param key - The header key
+ * @param value - The header value as a Promise
+ * @returns The Request interceptor
+ *
+ * @internal
+ */
+export declare const addAsyncHeaderInterceptor: (key: string, getter: () => Promise<string | undefined>) => RequestInterceptor;

package/node_modules/@scaleway/sdk-client/dist/internal/interceptors/helpers.js

@@ -0,0 +1,12 @@
+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);
+export {
+  addAsyncHeaderInterceptor,
+  addHeaderInterceptor
+};

package/node_modules/@scaleway/sdk-client/dist/internal/interceptors/types.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Defines the interceptor for a `Request`.
+ * This allows you to intercept requests before starting.
+ *
+ * @example
+ * Adds a custom header to a request:
+ * ```
+ * const addCustomHeaderInterceptor
+ *   ({ key, value }: { key: string; value: string }): RequestInterceptor =>
+ *   ({ request }) => {
+ *     const clone = request.clone()
+ *     clone.headers.set(key, value)
+ *
+ *     return clone
+ * }
+ * ```
+ *
+ * @public
+ */
+export interface RequestInterceptor {
+    ({ request }: {
+        request: Readonly<Request>;
+    }): Request | Promise<Request>;
+}
+/**
+ * Defines the interceptor for a `Response`.
+ * This allows you to intercept responses before unmarshalling.
+ *
+ * @example
+ * Adds a delay before sending the response:
+ * ```
+ * const addDelayInterceptor: ResponseInterceptor = ({ response }) =>
+ *   new Promise(resolve => {
+ *     setTimeout(() => resolve(response), 1000)
+ *   })
+ * ```
+ *
+ * @public
+ */
+export interface ResponseInterceptor {
+    ({ response }: {
+        response: Readonly<Response>;
+    }): Response | Promise<Response>;
+}
+/**
+ * Defines the interceptor for a `Response` error.
+ * This allows you to intercept a response error before exiting the whole process.
+ * You can either rethrow an error, and resolve with a different response.
+ *
+ * @remarks
+ * You must return either:
+ * 1. An error (`throw error` or `Promise.reject(error)`)
+ * 2. Data (directly, or via a Promise)
+ *
+ * @example
+ * Reports error to tracking service:
+ * ```
+ * const reportErrorToTrackingService: ResponseErrorInterceptor = async ({
+ *   request,
+ *   error,
+ * }: {
+ *   request: Request
+ *   error: unknown
+ * }) => {
+ *   await sendErrorToErrorService(request, error)
+ *   throw error
+ * }
+ * ```
+ *
+ * @public
+ */
+export interface ResponseErrorInterceptor {
+    ({ request, error }: {
+        request: Request;
+        error: unknown;
+    }): unknown;
+}
+/**
+ * Defines the network interceptors.
+ * Please check the documentation of {@link RequestInterceptor},
+ * {@link ResponseInterceptor} and {@link ResponseErrorInterceptor} for examples.
+ *
+ * @public
+ */
+export interface NetworkInterceptors {
+    request?: RequestInterceptor;
+    response?: ResponseInterceptor;
+    responseError?: ResponseErrorInterceptor;
+}

package/node_modules/@scaleway/sdk-client/dist/internal/logger/console-logger.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const levelResolver = require("./level-resolver.cjs");
+class ConsoleLogger {
+  constructor(logLevel, prefix = "", output = console) {
+    this.logLevel = logLevel;
+    this.prefix = prefix;
+    this.output = output;
+    this.level = levelResolver.LevelResolver[this.logLevel];
+  }
+  level;
+  makeMethod(method) {
+    return (message) => {
+      if (levelResolver.shouldLog(this.level, method)) {
+        this.output[method](this.prefix ? `${this.prefix} ${message}` : message);
+      }
+    };
+  }
+  debug = this.makeMethod("debug");
+  error = this.makeMethod("error");
+  info = this.makeMethod("info");
+  warn = this.makeMethod("warn");
+}
+exports.ConsoleLogger = ConsoleLogger;

package/node_modules/@scaleway/sdk-client/dist/internal/logger/console-logger.d.ts

@@ -0,0 +1,23 @@
+import type { LogLevel } from './level-resolver.js';
+import type { Logger } from './logger';
+/**
+ * A Logger using console output.
+ *
+ * @param logLevel - The logger level name
+ * @param prefix - An optional logger message prefix
+ * @param output - The output to print logs, using by default the global console object
+ *
+ * @internal
+ */
+export declare class ConsoleLogger implements Logger {
+    readonly logLevel: LogLevel;
+    private readonly prefix;
+    private output;
+    private level;
+    constructor(logLevel: LogLevel, prefix?: string, output?: typeof console);
+    private makeMethod;
+    debug: (message: string) => void;
+    error: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+}

package/node_modules/@scaleway/sdk-client/dist/internal/logger/console-logger.js

@@ -0,0 +1,24 @@
+import { LevelResolver, shouldLog } from "./level-resolver.js";
+class ConsoleLogger {
+  constructor(logLevel, prefix = "", output = console) {
+    this.logLevel = logLevel;
+    this.prefix = prefix;
+    this.output = output;
+    this.level = LevelResolver[this.logLevel];
+  }
+  level;
+  makeMethod(method) {
+    return (message) => {
+      if (shouldLog(this.level, method)) {
+        this.output[method](this.prefix ? `${this.prefix} ${message}` : message);
+      }
+    };
+  }
+  debug = this.makeMethod("debug");
+  error = this.makeMethod("error");
+  info = this.makeMethod("info");
+  warn = this.makeMethod("warn");
+}
+export {
+  ConsoleLogger
+};