@scaleway/sdk-std 1.0.1

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const consoleLogger = require("./console-logger.cjs");
+let sdkLogger = new consoleLogger.ConsoleLogger("silent");
+const setLogger = (logger) => {
+  sdkLogger = logger;
+};
+const enableConsoleLogger = (logLevel = "warn", prefix = "scaleway-sdk-js:") => setLogger(new consoleLogger.ConsoleLogger(logLevel, prefix));
+const getLogger = () => sdkLogger;
+exports.enableConsoleLogger = enableConsoleLogger;
+exports.getLogger = getLogger;
+exports.setLogger = setLogger;

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

@@ -0,0 +1,25 @@
+import type { LogLevel } from './level-resolver.js';
+import type { Logger } from './logger';
+/**
+ * Sets a logger to be used within the SDK.
+ *
+ * @param logger - The Logger instance
+ *
+ * @public
+ */
+export declare const setLogger: (logger: Readonly<Logger>) => void;
+/**
+ * Sets the logger to console logger with given logLevel (log is disabled by default).
+ *
+ * @param logLevel - The Log level (default to 'warn')
+ * @param prefix - A Log message prefix (default to 'scaleway-sdk-js:')
+ *
+ * @public
+ */
+export declare const enableConsoleLogger: (logLevel?: LogLevel, prefix?: string) => void;
+/**
+ * Returns the active SDK logger.
+ *
+ * @internal
+ */
+export declare const getLogger: () => Readonly<Logger>;

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

@@ -0,0 +1,12 @@
+import { ConsoleLogger } from "./console-logger.js";
+let sdkLogger = new ConsoleLogger("silent");
+const setLogger = (logger) => {
+  sdkLogger = logger;
+};
+const enableConsoleLogger = (logLevel = "warn", prefix = "scaleway-sdk-js:") => setLogger(new ConsoleLogger(logLevel, prefix));
+const getLogger = () => sdkLogger;
+export {
+  enableConsoleLogger,
+  getLogger,
+  setLogger
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var LevelResolver = /* @__PURE__ */ ((LevelResolver2) => {
+  LevelResolver2[LevelResolver2["silent"] = 0] = "silent";
+  LevelResolver2[LevelResolver2["error"] = 1] = "error";
+  LevelResolver2[LevelResolver2["warn"] = 2] = "warn";
+  LevelResolver2[LevelResolver2["info"] = 3] = "info";
+  LevelResolver2[LevelResolver2["debug"] = 4] = "debug";
+  return LevelResolver2;
+})(LevelResolver || {});
+const shouldLog = (currentLevel, level) => LevelResolver[level] <= currentLevel;
+exports.LevelResolver = LevelResolver;
+exports.shouldLog = shouldLog;

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

@@ -0,0 +1,9 @@
+export declare enum LevelResolver {
+    silent = 0,
+    error = 1,
+    warn = 2,
+    info = 3,
+    debug = 4
+}
+export type LogLevel = keyof typeof LevelResolver;
+export declare const shouldLog: (currentLevel: LevelResolver, level: LogLevel) => boolean;

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

@@ -0,0 +1,13 @@
+var LevelResolver = /* @__PURE__ */ ((LevelResolver2) => {
+  LevelResolver2[LevelResolver2["silent"] = 0] = "silent";
+  LevelResolver2[LevelResolver2["error"] = 1] = "error";
+  LevelResolver2[LevelResolver2["warn"] = 2] = "warn";
+  LevelResolver2[LevelResolver2["info"] = 3] = "info";
+  LevelResolver2[LevelResolver2["debug"] = 4] = "debug";
+  return LevelResolver2;
+})(LevelResolver || {});
+const shouldLog = (currentLevel, level) => LevelResolver[level] <= currentLevel;
+export {
+  LevelResolver,
+  shouldLog
+};

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

@@ -0,0 +1,13 @@
+import type { LogLevel } from './level-resolver.js';
+/**
+ * Logger.
+ *
+ * @public
+ */
+export interface Logger {
+    readonly logLevel: LogLevel;
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}

package/node_modules/@scaleway/sdk-client/dist/internal/validations/string-validation.cjs

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isAccessKeyRegex = /^SCW[A-Z0-9]{17}$/i;
+const isRegionRegex = /^[a-z]{2}-[a-z]{3}$/i;
+const isUUIDRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
+const isZoneRegex = /^[a-z]{2}-[a-z]{3}-[1-9]$/i;
+const isUUID = (str) => isUUIDRegex.test(str);
+const isAccessKey = (str) => isAccessKeyRegex.test(str);
+const isSecretKey = (str) => isUUID(str);
+const isOrganizationId = (str) => isUUID(str);
+const isProjectId = (str) => isUUID(str);
+const isRegion = (str) => isRegionRegex.test(str);
+const isZone = (str) => isZoneRegex.test(str);
+const isURL = (str) => {
+  let url;
+  try {
+    url = new URL(str);
+  } catch {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+};
+exports.isAccessKey = isAccessKey;
+exports.isOrganizationId = isOrganizationId;
+exports.isProjectId = isProjectId;
+exports.isRegion = isRegion;
+exports.isSecretKey = isSecretKey;
+exports.isURL = isURL;
+exports.isUUID = isUUID;
+exports.isZone = isZone;

package/node_modules/@scaleway/sdk-client/dist/internal/validations/string-validation.d.ts

@@ -0,0 +1,18 @@
+/** Returns true if the given string has a valid UUID format. */
+export declare const isUUID: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway access key format. */
+export declare const isAccessKey: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway secret key format. */
+export declare const isSecretKey: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway organization ID format. */
+export declare const isOrganizationId: (str: string) => boolean;
+/** Returns true if the given string has a valid Scaleway project ID format. */
+export declare const isProjectId: (str: string) => boolean;
+/** Returns true if the given string has a valid region format. */
+export declare const isRegion: (str: string) => boolean;
+/** Returns true if the given string has a valid zone format. */
+export declare const isZone: (str: string) => boolean;
+/** Returns true if the given string has a valid URL format and starts by `http(s):`. */
+export declare const isURL: (str: string) => boolean;
+/** Returns true if the given string has an email format. */
+export declare const isEmail: (str: string) => boolean;

package/node_modules/@scaleway/sdk-client/dist/internal/validations/string-validation.js

@@ -0,0 +1,30 @@
+const isAccessKeyRegex = /^SCW[A-Z0-9]{17}$/i;
+const isRegionRegex = /^[a-z]{2}-[a-z]{3}$/i;
+const isUUIDRegex = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
+const isZoneRegex = /^[a-z]{2}-[a-z]{3}-[1-9]$/i;
+const isUUID = (str) => isUUIDRegex.test(str);
+const isAccessKey = (str) => isAccessKeyRegex.test(str);
+const isSecretKey = (str) => isUUID(str);
+const isOrganizationId = (str) => isUUID(str);
+const isProjectId = (str) => isUUID(str);
+const isRegion = (str) => isRegionRegex.test(str);
+const isZone = (str) => isZoneRegex.test(str);
+const isURL = (str) => {
+  let url;
+  try {
+    url = new URL(str);
+  } catch {
+    return false;
+  }
+  return url.protocol === "http:" || url.protocol === "https:";
+};
+export {
+  isAccessKey,
+  isOrganizationId,
+  isProjectId,
+  isRegion,
+  isSecretKey,
+  isURL,
+  isUUID,
+  isZone
+};

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

@@ -0,0 +1,10 @@
+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 type { DefaultValues } from './scw/client-settings.js';
+export { marshalBlobToScwFile, marshalDecimal, marshalMoney, marshalScwFile, marshalTimeSeries, unmarshalAnyRes, unmarshalDecimal, unmarshalMoney, unmarshalScwFile, unmarshalServiceInfo, unmarshalTimeSeries, unmarshalTimeSeriesPoint, } from './scw/custom-marshalling.js';
+export type { ServiceInfo } from './scw/custom-types.js';
+export { resolveOneOf, unmarshalDate, unmarshalArrayOfObject, unmarshalMapOfObject, urlParams, validatePathParam, } from './helpers/marshalling.js';
+export { enrichForPagination } from './scw/fetch/resource-paginator.js';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const version = "1.2.1";
+const pkg = {
+  version
+};
+exports.default = pkg;
+exports.version = version;

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

@@ -0,0 +1,8 @@
+const version = "1.2.1";
+const pkg = {
+  version
+};
+export {
+  pkg as default,
+  version
+};

package/node_modules/@scaleway/sdk-client/dist/scw/api.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class API {
+  constructor(client) {
+    this.client = client;
+  }
+}
+exports.API = API;

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

@@ -0,0 +1,10 @@
+import type { Client } from './client.js';
+/**
+ * Abstract class to instantiate API from a {@link Client}.
+ *
+ * @internal
+ */
+export declare abstract class API {
+    protected client: Client;
+    constructor(client: Client);
+}

package/node_modules/@scaleway/sdk-client/dist/scw/api.js

@@ -0,0 +1,8 @@
+class API {
+  constructor(client) {
+    this.client = client;
+  }
+}
+export {
+  API
+};

package/node_modules/@scaleway/sdk-client/dist/scw/auth.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const helpers = require("../internal/interceptors/helpers.cjs");
+const clientIniProfile = require("./client-ini-profile.cjs");
+const constants = require("./constants.cjs");
+const authenticateWithSessionToken = (getToken) => helpers.addAsyncHeaderInterceptor(constants.SESSION_HEADER_KEY, getToken);
+const authenticateWithSecrets = (secrets) => {
+  clientIniProfile.assertValidAuthenticationSecrets(secrets);
+  return helpers.addHeaderInterceptor(constants.AUTH_HEADER_KEY, secrets.secretKey);
+};
+const obfuscateToken = (key) => `${key.substring(0, 5)}xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`;
+const obfuscateUUID = (key) => `${key.substring(0, 8)}-xxxx-xxxx-xxxx-xxxxxxxxxxxx`;
+const obfuscateAuthHeadersEntry = ([
+  name,
+  value
+]) => {
+  if (name === constants.SESSION_HEADER_KEY) return [name, obfuscateToken(value)];
+  if (name === constants.AUTH_HEADER_KEY) return [name, obfuscateUUID(value)];
+  return [name, value];
+};
+exports.authenticateWithSecrets = authenticateWithSecrets;
+exports.authenticateWithSessionToken = authenticateWithSessionToken;
+exports.obfuscateAuthHeadersEntry = obfuscateAuthHeadersEntry;
+exports.obfuscateToken = obfuscateToken;
+exports.obfuscateUUID = obfuscateUUID;

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

@@ -0,0 +1,70 @@
+import type { RequestInterceptor } from '../internal/interceptors/types';
+import type { AuthenticationSecrets } from './client-ini-profile.js';
+interface TokenAccessor {
+    (): Promise<string | undefined>;
+}
+interface AddSessionHeader {
+    request: Request;
+    getAsyncToken: () => Promise<string | undefined>;
+}
+/**
+ * Add an JWT Session Header to a request through an interceptor.
+ *
+ * @param request - The request to modify
+ * @param getJwt - The session value
+ * @returns The Request interceptor
+ *
+ */
+export declare const addSessionHeader: ({ request, getAsyncToken, }: AddSessionHeader) => Promise<Request>;
+/**
+ * Authenticates with a session token.
+ *
+ * @param getToken - The token accessor
+ * @returns The request interceptor
+ *
+ * @deprecated Please use addAsyncHeaderInterceptor instead.
+ *
+ * @internal
+ */
+export declare const authenticateWithSessionToken: (getToken: TokenAccessor) => RequestInterceptor;
+/**
+ * Authenticates with a secrets.
+ *
+ * @param getToken - The secrets
+ * @returns The request interceptor
+ *
+ * @throws Error
+ * Thrown if the secrets are invalid.
+ *
+ * @internal
+ */
+export declare const authenticateWithSecrets: (secrets: AuthenticationSecrets) => RequestInterceptor;
+/**
+ * Obfuscates a token.
+ *
+ * @param key - The token
+ * @returns The obfuscated token
+ *
+ * @internal
+ */
+export declare const obfuscateToken: (key: string) => string;
+/**
+ * Obfuscates an UUID.
+ *
+ * @param key - The UUID
+ * @returns The obfuscated UUID
+ *
+ * @internal
+ */
+export declare const obfuscateUUID: (key: string) => string;
+type HeaderEntry = [string, string];
+/**
+ * Obfuscates headers entry.
+ *
+ * @param array - The header entry
+ * @returns The obfuscated entry
+ *
+ * @internal
+ */
+export declare const obfuscateAuthHeadersEntry: ([name, value,]: HeaderEntry) => HeaderEntry;
+export {};

package/node_modules/@scaleway/sdk-client/dist/scw/auth.js

@@ -0,0 +1,25 @@
+import { addAsyncHeaderInterceptor, addHeaderInterceptor } from "../internal/interceptors/helpers.js";
+import { assertValidAuthenticationSecrets } from "./client-ini-profile.js";
+import { SESSION_HEADER_KEY, AUTH_HEADER_KEY } from "./constants.js";
+const authenticateWithSessionToken = (getToken) => addAsyncHeaderInterceptor(SESSION_HEADER_KEY, getToken);
+const authenticateWithSecrets = (secrets) => {
+  assertValidAuthenticationSecrets(secrets);
+  return addHeaderInterceptor(AUTH_HEADER_KEY, secrets.secretKey);
+};
+const obfuscateToken = (key) => `${key.substring(0, 5)}xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx`;
+const obfuscateUUID = (key) => `${key.substring(0, 8)}-xxxx-xxxx-xxxx-xxxxxxxxxxxx`;
+const obfuscateAuthHeadersEntry = ([
+  name,
+  value
+]) => {
+  if (name === SESSION_HEADER_KEY) return [name, obfuscateToken(value)];
+  if (name === AUTH_HEADER_KEY) return [name, obfuscateUUID(value)];
+  return [name, value];
+};
+export {
+  authenticateWithSecrets,
+  authenticateWithSessionToken,
+  obfuscateAuthHeadersEntry,
+  obfuscateToken,
+  obfuscateUUID
+};

package/node_modules/@scaleway/sdk-client/dist/scw/client-ini-factory.cjs

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const auth = require("./auth.cjs");
+const clientIniProfile = require("./client-ini-profile.cjs");
+const withProfile = (profile) => (settings) => {
+  const newSettings = { ...settings };
+  if (profile.apiURL) {
+    newSettings.apiURL = profile.apiURL;
+  }
+  if (profile.defaultOrganizationId) {
+    newSettings.defaultOrganizationId = profile.defaultOrganizationId;
+  }
+  if (profile.defaultProjectId) {
+    newSettings.defaultProjectId = profile.defaultProjectId;
+  }
+  if (profile.defaultRegion) {
+    newSettings.defaultRegion = profile.defaultRegion;
+  }
+  if (profile.defaultZone) {
+    newSettings.defaultZone = profile.defaultZone;
+  }
+  if (clientIniProfile.hasAuthenticationSecrets(profile)) {
+    newSettings.interceptors = [
+      {
+        request: auth.authenticateWithSecrets(profile)
+      },
+      ...newSettings.interceptors
+    ];
+  }
+  return newSettings;
+};
+const withHTTPClient = (httpClient) => (settings) => ({ ...settings, httpClient });
+const withDefaultPageSize = (defaultPageSize) => (settings) => ({ ...settings, defaultPageSize });
+const withUserAgent = (userAgent) => (settings) => ({ ...settings, userAgent });
+const withUserAgentSuffix = (userAgent) => (settings) => ({
+  ...settings,
+  userAgent: settings.userAgent ? `${settings.userAgent} ${userAgent}` : userAgent
+});
+const withAdditionalInterceptors = (interceptors) => (settings) => ({
+  ...settings,
+  interceptors: settings.interceptors.concat(interceptors)
+});
+const withLegacyInterceptors = () => (settings) => {
+  if (!settings.requestInterceptors && !settings.responseInterceptors) {
+    return settings;
+  }
+  const allInterceptors = settings.interceptors.concat(
+    (settings.requestInterceptors ?? []).map((obj) => ({
+      request: obj
+    })),
+    (settings.responseInterceptors ?? []).map((obj) => ({
+      response: obj
+    }))
+  );
+  return {
+    ...settings,
+    interceptors: allInterceptors
+  };
+};
+exports.withAdditionalInterceptors = withAdditionalInterceptors;
+exports.withDefaultPageSize = withDefaultPageSize;
+exports.withHTTPClient = withHTTPClient;
+exports.withLegacyInterceptors = withLegacyInterceptors;
+exports.withProfile = withProfile;
+exports.withUserAgent = withUserAgent;
+exports.withUserAgentSuffix = withUserAgentSuffix;

package/node_modules/@scaleway/sdk-client/dist/scw/client-ini-factory.d.ts

@@ -0,0 +1,111 @@
+import type { NetworkInterceptors } from '../index.js';
+import type { Profile } from './client-ini-profile.js';
+import type { Settings } from './client-settings.js';
+/**
+ * A factory to build {@link Settings}.
+ *
+ * @public
+ */
+export type ClientConfig = (obj: Settings) => Settings;
+/**
+ * Instantiates the SDK from a configuration {@link Profile}.
+ *
+ * @param profile - The profile
+ * @returns A factory {@link ClientConfig}
+ *
+ * @remarks This method should be used in conjunction with the initializer `createAdvancedClient`.
+ *
+ * @public
+ */
+export declare const withProfile: (profile: Readonly<Profile>) => (settings: Readonly<Settings>) => Settings;
+/**
+ * Instantiates the SDK with a different HTTP client.
+ *
+ * @param httpClient - A fetch compatible HTTP client
+ * @returns A factory {@link ClientConfig}
+ *
+ * @remarks This method should be used in conjunction with the initializer `createAdvancedClient`.
+ *
+ * @public
+ */
+export declare const withHTTPClient: (httpClient: typeof fetch) => (settings: Readonly<Settings>) => Settings;
+/**
+ * Instantiates the SDK with a default page size.
+ *
+ * @param defaultPageSize - The default page size
+ * @returns A factory {@link ClientConfig}
+ *
+ * @remarks This method should be used in conjunction with the initializer `createAdvancedClient`.
+ *
+ * @public
+ */
+export declare const withDefaultPageSize: (defaultPageSize: number) => ClientConfig;
+/**
+ * Instantiates the SDK with a different default user agent.
+ *
+ * @param userAgent - The default user agent
+ * @returns A factory {@link ClientConfig}
+ *
+ * @remarks This method should be used in conjunction with the initializer `createAdvancedClient`.
+ *
+ * @public
+ */
+export declare const withUserAgent: (userAgent: string) => (settings: Readonly<Settings>) => Settings;
+/**
+ * Instantiates the SDK with an additional user agent.
+ *
+ * @param userAgent - The suffix to append to default user agent
+ * @returns A factory {@link ClientConfig}
+ *
+ * @remarks This method should be used in conjunction with the initializer `createAdvancedClient`.
+ *
+ * @public
+ */
+export declare const withUserAgentSuffix: (userAgent: string) => (settings: Readonly<Settings>) => Settings;
+/**
+ * Instantiates the SDK with additional interceptors.
+ *
+ * @param interceptors - The additional {@link NetworkInterceptors} interceptors
+ * @returns A factory {@link ClientConfig}
+ *
+ * @remarks
+ * It doesn't override the existing interceptors, but instead push more to the list.
+ * This method should be used in conjunction with the initializer `createAdvancedClient`.
+ *
+ * @example
+ * ```
+ * withAdditionalInterceptors([
+ *   {
+ *     request: ({ request }) => {
+ *       console.log(`Do something with ${JSON.stringify(request)}`)
+ *       return request
+ *     },
+ *     response: ({ response }) => {
+ *       console.log(`Do something with ${JSON.stringify(response)}`)
+ *       return response
+ *     },
+ *     responseError: async ({
+ *       request,
+ *       error,
+ *     }: {
+ *       request: Request
+ *       error: unknown
+ *     }) => {
+ *       console.log(
+ *         `Do something with ${JSON.stringify(request)} and ${JSON.stringify(
+ *           error,
+ *         )}`,
+ *       )
+ *       throw error // or return Promise.resolve(someData)
+ *     },
+ *   },
+ * ])
+ * ```
+ *
+ * @public
+ */
+export declare const withAdditionalInterceptors: (interceptors: NetworkInterceptors[]) => (settings: Readonly<Settings>) => Settings;
+/**
+ * Instantiates the SDK with legacy interceptors.
+ */
+export declare const withLegacyInterceptors: () => (settings: Readonly<Settings>) => Settings;

package/node_modules/@scaleway/sdk-client/dist/scw/client-ini-factory.js

@@ -0,0 +1,66 @@
+import { authenticateWithSecrets } from "./auth.js";
+import { hasAuthenticationSecrets } from "./client-ini-profile.js";
+const withProfile = (profile) => (settings) => {
+  const newSettings = { ...settings };
+  if (profile.apiURL) {
+    newSettings.apiURL = profile.apiURL;
+  }
+  if (profile.defaultOrganizationId) {
+    newSettings.defaultOrganizationId = profile.defaultOrganizationId;
+  }
+  if (profile.defaultProjectId) {
+    newSettings.defaultProjectId = profile.defaultProjectId;
+  }
+  if (profile.defaultRegion) {
+    newSettings.defaultRegion = profile.defaultRegion;
+  }
+  if (profile.defaultZone) {
+    newSettings.defaultZone = profile.defaultZone;
+  }
+  if (hasAuthenticationSecrets(profile)) {
+    newSettings.interceptors = [
+      {
+        request: authenticateWithSecrets(profile)
+      },
+      ...newSettings.interceptors
+    ];
+  }
+  return newSettings;
+};
+const withHTTPClient = (httpClient) => (settings) => ({ ...settings, httpClient });
+const withDefaultPageSize = (defaultPageSize) => (settings) => ({ ...settings, defaultPageSize });
+const withUserAgent = (userAgent) => (settings) => ({ ...settings, userAgent });
+const withUserAgentSuffix = (userAgent) => (settings) => ({
+  ...settings,
+  userAgent: settings.userAgent ? `${settings.userAgent} ${userAgent}` : userAgent
+});
+const withAdditionalInterceptors = (interceptors) => (settings) => ({
+  ...settings,
+  interceptors: settings.interceptors.concat(interceptors)
+});
+const withLegacyInterceptors = () => (settings) => {
+  if (!settings.requestInterceptors && !settings.responseInterceptors) {
+    return settings;
+  }
+  const allInterceptors = settings.interceptors.concat(
+    (settings.requestInterceptors ?? []).map((obj) => ({
+      request: obj
+    })),
+    (settings.responseInterceptors ?? []).map((obj) => ({
+      response: obj
+    }))
+  );
+  return {
+    ...settings,
+    interceptors: allInterceptors
+  };
+};
+export {
+  withAdditionalInterceptors,
+  withDefaultPageSize,
+  withHTTPClient,
+  withLegacyInterceptors,
+  withProfile,
+  withUserAgent,
+  withUserAgentSuffix
+};

package/node_modules/@scaleway/sdk-client/dist/scw/client-ini-profile.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const stringValidation = require("../internal/validations/string-validation.cjs");
+const hasAuthenticationSecrets = (obj) => typeof obj.accessKey === "string" && obj.accessKey !== "" && typeof obj.secretKey === "string" && obj.secretKey !== "";
+function assertValidAuthenticationSecrets(obj) {
+  if (!(obj.accessKey && obj.secretKey)) {
+    throw new Error(
+      `Invalid secrets, accessKey & secretKey must be defined. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`
+    );
+  }
+  if (!stringValidation.isAccessKey(obj.accessKey)) {
+    throw new Error(
+      `Invalid access key format '${obj.accessKey}', expected SCWXXXXXXXXXXXXXXXXX format. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`
+    );
+  }
+  if (!stringValidation.isSecretKey(obj.secretKey)) {
+    throw new Error(
+      `Invalid secret key format '${obj.secretKey}', expected a UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. See https://www.scaleway.com/en/docs/identity-and-access-management/iam/how-to/create-api-keys/`
+    );
+  }
+}
+exports.assertValidAuthenticationSecrets = assertValidAuthenticationSecrets;
+exports.hasAuthenticationSecrets = hasAuthenticationSecrets;