@scaleway/sdk 2.71.0 → 2.72.0

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/resource-not-found-error.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+class ResourceNotFoundError extends scwError.ScalewayError {
+  constructor(status, body, resource, resourceId) {
+    super(
+      status,
+      body,
+      `resource ${resource} with ID ${resourceId} is not found`
+    );
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.name = "ResourceNotFoundError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== "string" || typeof obj.resource_id !== "string") {
+      return null;
+    }
+    return new ResourceNotFoundError(status, obj, obj.resource, obj.resource_id);
+  }
+}
+exports.ResourceNotFoundError = ResourceNotFoundError;

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/resource-not-found-error.js

@@ -0,0 +1,24 @@
+import { ScalewayError } from "../scw-error.js";
+class ResourceNotFoundError extends ScalewayError {
+  constructor(status, body, resource, resourceId) {
+    super(
+      status,
+      body,
+      `resource ${resource} with ID ${resourceId} is not found`
+    );
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.name = "ResourceNotFoundError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== "string" || typeof obj.resource_id !== "string") {
+      return null;
+    }
+    return new ResourceNotFoundError(status, obj, obj.resource, obj.resource_id);
+  }
+}
+export {
+  ResourceNotFoundError
+};

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/too-many-requests-error.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const json = require("../../../helpers/json.cjs");
+const scwError = require("../scw-error.cjs");
+const buildMessage = (helpMessage, limit, resetSeconds, resetAt) => {
+  const details = [];
+  if (limit) {
+    if (limit.windowSeconds) {
+      details.push(`quota is ${limit.quota} for ${limit.windowSeconds}s`);
+    } else {
+      details.push(`quota is ${limit.quota}`);
+    }
+  }
+  if (resetSeconds) {
+    details.push(`resets in ${resetSeconds}s`);
+  } else if (resetAt) {
+    details.push(`resets at ${resetAt.toISOString()}`);
+  }
+  let output = `too many requests`;
+  if (details.length > 0) {
+    output += ` (${details.join(", ")})`;
+  }
+  if (helpMessage.length > 0) {
+    output += `: ${helpMessage}`;
+  }
+  return output;
+};
+class TooManyRequestsError extends scwError.ScalewayError {
+  constructor(status, body, helpMessage, limit, resetSeconds, resetAt) {
+    super(status, body, buildMessage(helpMessage, limit, resetSeconds, resetAt));
+    this.status = status;
+    this.body = body;
+    this.helpMessage = helpMessage;
+    this.limit = limit;
+    this.resetSeconds = resetSeconds;
+    this.resetAt = resetAt;
+    this.name = "TooManyRequestsError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.help_message !== "string") return null;
+    let limit;
+    if (json.isJSONObject(obj.limit) && typeof obj.limit.quota === "number") {
+      limit = {
+        quota: obj.limit.quota,
+        windowSeconds: typeof obj.limit.window_seconds === "number" ? obj.limit.window_seconds : void 0
+      };
+    }
+    return new TooManyRequestsError(
+      status,
+      obj,
+      obj.help_message,
+      limit,
+      typeof obj.reset_seconds === "number" ? obj.reset_seconds : void 0,
+      typeof obj.reset_at === "string" ? new Date(obj.reset_at) : void 0
+    );
+  }
+}
+exports.TooManyRequestsError = TooManyRequestsError;

package/{dist → node_modules/@scaleway/sdk-client/dist}/scw/errors/standard/too-many-requests-error.d.ts

@@ -5,10 +5,10 @@ import { ScalewayError } from '../scw-error.js';
  *
  * @public
  */
-export type TooManyRequestsQuotaPolicy = {
+export interface TooManyRequestsQuotaPolicy {
     quota: number;
     windowSeconds?: number;
-};
+}
 /**
  * TooManyRequestsError error happens when fetching too many times a resource.
  *

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/too-many-requests-error.js

@@ -0,0 +1,58 @@
+import { isJSONObject } from "../../../helpers/json.js";
+import { ScalewayError } from "../scw-error.js";
+const buildMessage = (helpMessage, limit, resetSeconds, resetAt) => {
+  const details = [];
+  if (limit) {
+    if (limit.windowSeconds) {
+      details.push(`quota is ${limit.quota} for ${limit.windowSeconds}s`);
+    } else {
+      details.push(`quota is ${limit.quota}`);
+    }
+  }
+  if (resetSeconds) {
+    details.push(`resets in ${resetSeconds}s`);
+  } else if (resetAt) {
+    details.push(`resets at ${resetAt.toISOString()}`);
+  }
+  let output = `too many requests`;
+  if (details.length > 0) {
+    output += ` (${details.join(", ")})`;
+  }
+  if (helpMessage.length > 0) {
+    output += `: ${helpMessage}`;
+  }
+  return output;
+};
+class TooManyRequestsError extends ScalewayError {
+  constructor(status, body, helpMessage, limit, resetSeconds, resetAt) {
+    super(status, body, buildMessage(helpMessage, limit, resetSeconds, resetAt));
+    this.status = status;
+    this.body = body;
+    this.helpMessage = helpMessage;
+    this.limit = limit;
+    this.resetSeconds = resetSeconds;
+    this.resetAt = resetAt;
+    this.name = "TooManyRequestsError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.help_message !== "string") return null;
+    let limit;
+    if (isJSONObject(obj.limit) && typeof obj.limit.quota === "number") {
+      limit = {
+        quota: obj.limit.quota,
+        windowSeconds: typeof obj.limit.window_seconds === "number" ? obj.limit.window_seconds : void 0
+      };
+    }
+    return new TooManyRequestsError(
+      status,
+      obj,
+      obj.help_message,
+      limit,
+      typeof obj.reset_seconds === "number" ? obj.reset_seconds : void 0,
+      typeof obj.reset_at === "string" ? new Date(obj.reset_at) : void 0
+    );
+  }
+}
+export {
+  TooManyRequestsError
+};

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/transient-state-error.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+class TransientStateError extends scwError.ScalewayError {
+  constructor(status, body, resource, resourceId, currentState) {
+    super(
+      status,
+      body,
+      `resource ${resource} with ID ${resourceId} is in a transient state: ${currentState}`
+    );
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.currentState = currentState;
+    this.name = "TransientStateError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== "string" || typeof obj.resource_id !== "string" || typeof obj.current_state !== "string") {
+      return null;
+    }
+    return new TransientStateError(
+      status,
+      obj,
+      obj.resource,
+      obj.resource_id,
+      obj.current_state
+    );
+  }
+}
+exports.TransientStateError = TransientStateError;

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/transient-state-error.js

@@ -0,0 +1,31 @@
+import { ScalewayError } from "../scw-error.js";
+class TransientStateError extends ScalewayError {
+  constructor(status, body, resource, resourceId, currentState) {
+    super(
+      status,
+      body,
+      `resource ${resource} with ID ${resourceId} is in a transient state: ${currentState}`
+    );
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.resourceId = resourceId;
+    this.currentState = currentState;
+    this.name = "TransientStateError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== "string" || typeof obj.resource_id !== "string" || typeof obj.current_state !== "string") {
+      return null;
+    }
+    return new TransientStateError(
+      status,
+      obj,
+      obj.resource,
+      obj.resource_id,
+      obj.current_state
+    );
+  }
+}
+export {
+  TransientStateError
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const json = require("../../helpers/json.cjs");
+const isRecordOfStringArray = (obj) => {
+  if (!json.isJSONObject(obj)) {
+    return false;
+  }
+  for (const elt of Object.values(obj)) {
+    if (!Array.isArray(elt) || Object.values(elt).find((x) => typeof x !== "string") !== void 0) {
+      return false;
+    }
+  }
+  return true;
+};
+exports.isRecordOfStringArray = isRecordOfStringArray;

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

@@ -0,0 +1,15 @@
+import { isJSONObject } from "../../helpers/json.js";
+const isRecordOfStringArray = (obj) => {
+  if (!isJSONObject(obj)) {
+    return false;
+  }
+  for (const elt of Object.values(obj)) {
+    if (!Array.isArray(elt) || Object.values(elt).find((x) => typeof x !== "string") !== void 0) {
+      return false;
+    }
+  }
+  return true;
+};
+export {
+  isRecordOfStringArray
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/build-fetcher.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isBrowser = require("../../helpers/is-browser.cjs");
+const composer = require("../../internal/interceptors/composer.cjs");
+const auth = require("../auth.cjs");
+const httpInterceptors = require("./http-interceptors.cjs");
+const responseParser = require("./response-parser.cjs");
+const buildRequest = (request, settings) => {
+  let { path } = request;
+  if (request.urlParams instanceof URLSearchParams) {
+    path = path.concat(`?${request.urlParams.toString()}`);
+  }
+  return new Request(`${settings.apiURL}${path}`, {
+    body: request.body,
+    headers: {
+      Accept: "application/json",
+      .../* istanbul ignore next */
+      !isBrowser.isBrowser() ? { "User-Agent": settings.userAgent } : {},
+      ...request.headers
+    },
+    method: request.method
+  });
+};
+const asIs = (response) => response;
+const buildFetcher = (settings, httpClient) => {
+  let requestNumber = 0;
+  const prepareRequest = (requestId) => composer.composeRequestInterceptors([
+    ...settings.interceptors.map((obj) => obj.request).filter((obj) => obj),
+    httpInterceptors.logRequest(requestId, httpInterceptors.obfuscateInterceptor(auth.obfuscateAuthHeadersEntry))
+  ]);
+  const prepareResponse = (requestId) => composer.composeResponseInterceptors([
+    ...settings.interceptors.map((obj) => obj.response).filter((obj) => obj),
+    httpInterceptors.logResponse(requestId)
+  ]);
+  const prepareResponseErrors = () => composer.composeResponseErrorInterceptors(
+    settings.interceptors.map((obj) => obj.responseError).filter((obj) => obj)
+  );
+  return async (request, unwrapper = asIs) => {
+    const requestId = `${requestNumber += 1}`;
+    const reqInterceptors = prepareRequest(requestId);
+    const finalRequest = await reqInterceptors(buildRequest(request, settings));
+    try {
+      const response = await httpClient(finalRequest);
+      const resInterceptors = prepareResponse(requestId);
+      const finalResponse = await resInterceptors(response);
+      const resUnmarshaller = responseParser.responseParser(
+        unwrapper,
+        request.responseType ?? "json"
+      );
+      const unmarshaledResponse = await resUnmarshaller(finalResponse);
+      return unmarshaledResponse;
+    } catch (err) {
+      const resErrorInterceptors = prepareResponseErrors();
+      const handledError = await resErrorInterceptors(finalRequest, err);
+      return unwrapper(handledError);
+    }
+  };
+};
+exports.buildFetcher = buildFetcher;
+exports.buildRequest = buildRequest;

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/build-fetcher.js

@@ -0,0 +1,60 @@
+import { isBrowser } from "../../helpers/is-browser.js";
+import { composeRequestInterceptors, composeResponseInterceptors, composeResponseErrorInterceptors } from "../../internal/interceptors/composer.js";
+import { obfuscateAuthHeadersEntry } from "../auth.js";
+import { logRequest, logResponse, obfuscateInterceptor } from "./http-interceptors.js";
+import { responseParser } from "./response-parser.js";
+const buildRequest = (request, settings) => {
+  let { path } = request;
+  if (request.urlParams instanceof URLSearchParams) {
+    path = path.concat(`?${request.urlParams.toString()}`);
+  }
+  return new Request(`${settings.apiURL}${path}`, {
+    body: request.body,
+    headers: {
+      Accept: "application/json",
+      .../* istanbul ignore next */
+      !isBrowser() ? { "User-Agent": settings.userAgent } : {},
+      ...request.headers
+    },
+    method: request.method
+  });
+};
+const asIs = (response) => response;
+const buildFetcher = (settings, httpClient) => {
+  let requestNumber = 0;
+  const prepareRequest = (requestId) => composeRequestInterceptors([
+    ...settings.interceptors.map((obj) => obj.request).filter((obj) => obj),
+    logRequest(requestId, obfuscateInterceptor(obfuscateAuthHeadersEntry))
+  ]);
+  const prepareResponse = (requestId) => composeResponseInterceptors([
+    ...settings.interceptors.map((obj) => obj.response).filter((obj) => obj),
+    logResponse(requestId)
+  ]);
+  const prepareResponseErrors = () => composeResponseErrorInterceptors(
+    settings.interceptors.map((obj) => obj.responseError).filter((obj) => obj)
+  );
+  return async (request, unwrapper = asIs) => {
+    const requestId = `${requestNumber += 1}`;
+    const reqInterceptors = prepareRequest(requestId);
+    const finalRequest = await reqInterceptors(buildRequest(request, settings));
+    try {
+      const response = await httpClient(finalRequest);
+      const resInterceptors = prepareResponse(requestId);
+      const finalResponse = await resInterceptors(response);
+      const resUnmarshaller = responseParser(
+        unwrapper,
+        request.responseType ?? "json"
+      );
+      const unmarshaledResponse = await resUnmarshaller(finalResponse);
+      return unmarshaledResponse;
+    } catch (err) {
+      const resErrorInterceptors = prepareResponseErrors();
+      const handledError = await resErrorInterceptors(finalRequest, err);
+      return unwrapper(handledError);
+    }
+  };
+};
+export {
+  buildFetcher,
+  buildRequest
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-dumper.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const toPascalCase = (str) => str.replace(
+  /\w+/g,
+  (word) => `${word[0].toUpperCase()}${word.slice(1).toLowerCase()}`
+);
+const serializeHeadersEntry = ([name, value]) => `${toPascalCase(name)}: ${value}`;
+const serializeHeaders = (headers) => Array.from(headers.entries(), serializeHeadersEntry);
+const dumpRequest = async (request) => [
+  `${request.method.toUpperCase()}: ${request.url}`,
+  ...serializeHeaders(request.headers),
+  await request.clone().text()
+].join("\r\n");
+const dumpResponse = async (response) => [
+  `HTTP ${response.status} ${response.ok ? "OK" : "NOK"}`,
+  ...serializeHeaders(response.headers),
+  await response.clone().text()
+].join("\r\n");
+exports.dumpRequest = dumpRequest;
+exports.dumpResponse = dumpResponse;

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-dumper.js

@@ -0,0 +1,20 @@
+const toPascalCase = (str) => str.replace(
+  /\w+/g,
+  (word) => `${word[0].toUpperCase()}${word.slice(1).toLowerCase()}`
+);
+const serializeHeadersEntry = ([name, value]) => `${toPascalCase(name)}: ${value}`;
+const serializeHeaders = (headers) => Array.from(headers.entries(), serializeHeadersEntry);
+const dumpRequest = async (request) => [
+  `${request.method.toUpperCase()}: ${request.url}`,
+  ...serializeHeaders(request.headers),
+  await request.clone().text()
+].join("\r\n");
+const dumpResponse = async (response) => [
+  `HTTP ${response.status} ${response.ok ? "OK" : "NOK"}`,
+  ...serializeHeaders(response.headers),
+  await response.clone().text()
+].join("\r\n");
+export {
+  dumpRequest,
+  dumpResponse
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-interceptors.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../internal/logger/index.cjs");
+const levelResolver = require("../../internal/logger/level-resolver.cjs");
+const httpDumper = require("./http-dumper.cjs");
+class ObfuscatedRequest extends Request {
+  constructor(request, obfuscate) {
+    super(request);
+    this.request = request;
+    this.obfuscate = obfuscate;
+  }
+  get headers() {
+    return new Headers(Array.from(this.request.headers, this.obfuscate));
+  }
+  clone() {
+    return new ObfuscatedRequest(this.request, this.obfuscate);
+  }
+}
+const obfuscateInterceptor = (obfuscate) => ({ request }) => new ObfuscatedRequest(request, obfuscate);
+const identity = ({ request }) => request;
+const logRequest = (identifier, obfuscate = identity) => async ({ request }) => {
+  if (levelResolver.shouldLog(levelResolver.LevelResolver[index.getLogger().logLevel], "debug")) {
+    index.getLogger().debug(
+      `--------------- Scaleway SDK REQUEST ${identifier} ---------------
+${await httpDumper.dumpRequest(await obfuscate({ request }))}
+---------------------------------------------------------`
+    );
+  }
+  return request;
+};
+const logResponse = (identifier) => async ({ response }) => {
+  if (levelResolver.shouldLog(levelResolver.LevelResolver[index.getLogger().logLevel], "debug")) {
+    index.getLogger().debug(
+      `--------------- Scaleway SDK RESPONSE ${identifier} ---------------
+${await httpDumper.dumpResponse(response)}
+---------------------------------------------------------`
+    );
+  }
+  return response;
+};
+exports.logRequest = logRequest;
+exports.logResponse = logResponse;
+exports.obfuscateInterceptor = obfuscateInterceptor;

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/http-interceptors.js

@@ -0,0 +1,43 @@
+import { getLogger } from "../../internal/logger/index.js";
+import { shouldLog, LevelResolver } from "../../internal/logger/level-resolver.js";
+import { dumpRequest, dumpResponse } from "./http-dumper.js";
+class ObfuscatedRequest extends Request {
+  constructor(request, obfuscate) {
+    super(request);
+    this.request = request;
+    this.obfuscate = obfuscate;
+  }
+  get headers() {
+    return new Headers(Array.from(this.request.headers, this.obfuscate));
+  }
+  clone() {
+    return new ObfuscatedRequest(this.request, this.obfuscate);
+  }
+}
+const obfuscateInterceptor = (obfuscate) => ({ request }) => new ObfuscatedRequest(request, obfuscate);
+const identity = ({ request }) => request;
+const logRequest = (identifier, obfuscate = identity) => async ({ request }) => {
+  if (shouldLog(LevelResolver[getLogger().logLevel], "debug")) {
+    getLogger().debug(
+      `--------------- Scaleway SDK REQUEST ${identifier} ---------------
+${await dumpRequest(await obfuscate({ request }))}
+---------------------------------------------------------`
+    );
+  }
+  return request;
+};
+const logResponse = (identifier) => async ({ response }) => {
+  if (shouldLog(LevelResolver[getLogger().logLevel], "debug")) {
+    getLogger().debug(
+      `--------------- Scaleway SDK RESPONSE ${identifier} ---------------
+${await dumpResponse(response)}
+---------------------------------------------------------`
+    );
+  }
+  return response;
+};
+export {
+  logRequest,
+  logResponse,
+  obfuscateInterceptor
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/resource-paginator.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const extract = (key) => (result) => result[key];
+function* pages(key, fetcher, request, firstPage) {
+  if (!Array.isArray(firstPage[key])) {
+    throw new Error(`Property ${key} is not a list in paginated result`);
+  }
+  const getList = extract(key);
+  let page = request.page || 1;
+  if (page === 1) {
+    yield Promise.resolve(getList(firstPage));
+    page += 1;
+  }
+  const { length } = firstPage[key];
+  if (!length) return;
+  const { totalCount } = firstPage;
+  while (page <= Math.floor((totalCount + length - 1) / length)) {
+    yield fetcher({ ...request, page }).then(getList);
+    page += 1;
+  }
+}
+async function* fetchPaginated(key, fetcher, request, initial = fetcher(request)) {
+  yield* pages(key, fetcher, request, await initial);
+}
+const fetchAll = async (key, fetcher, request, initial = fetcher(request)) => (await Promise.all(Array.from(pages(key, fetcher, request, await initial)))).flat();
+const enrichForPagination = (key, fetcher, request) => {
+  const firstPage = fetcher(request);
+  return Object.assign(firstPage, {
+    all: () => fetchAll(key, fetcher, request, firstPage),
+    [Symbol.asyncIterator]: () => fetchPaginated(key, fetcher, request, firstPage)
+  });
+};
+exports.enrichForPagination = enrichForPagination;
+exports.extract = extract;
+exports.fetchAll = fetchAll;
+exports.fetchPaginated = fetchPaginated;

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/resource-paginator.js

@@ -0,0 +1,36 @@
+const extract = (key) => (result) => result[key];
+function* pages(key, fetcher, request, firstPage) {
+  if (!Array.isArray(firstPage[key])) {
+    throw new Error(`Property ${key} is not a list in paginated result`);
+  }
+  const getList = extract(key);
+  let page = request.page || 1;
+  if (page === 1) {
+    yield Promise.resolve(getList(firstPage));
+    page += 1;
+  }
+  const { length } = firstPage[key];
+  if (!length) return;
+  const { totalCount } = firstPage;
+  while (page <= Math.floor((totalCount + length - 1) / length)) {
+    yield fetcher({ ...request, page }).then(getList);
+    page += 1;
+  }
+}
+async function* fetchPaginated(key, fetcher, request, initial = fetcher(request)) {
+  yield* pages(key, fetcher, request, await initial);
+}
+const fetchAll = async (key, fetcher, request, initial = fetcher(request)) => (await Promise.all(Array.from(pages(key, fetcher, request, await initial)))).flat();
+const enrichForPagination = (key, fetcher, request) => {
+  const firstPage = fetcher(request);
+  return Object.assign(firstPage, {
+    all: () => fetchAll(key, fetcher, request, firstPage),
+    [Symbol.asyncIterator]: () => fetchPaginated(key, fetcher, request, firstPage)
+  });
+};
+export {
+  enrichForPagination,
+  extract,
+  fetchAll,
+  fetchPaginated
+};

package/node_modules/@scaleway/sdk-client/dist/scw/fetch/response-parser.cjs

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isResponse = require("../../helpers/is-response.cjs");
+const json = require("../../helpers/json.cjs");
+const errorParser = require("../errors/error-parser.cjs");
+const scwError = require("../errors/scw-error.cjs");
+const X_TOTAL_COUNT_HEADER_KEY = "x-total-count";
+const TOTAL_COUNT_RES_KEY = "total_count";
+const fixLegacyTotalCount = (obj, headers) => {
+  const headerVal = headers.get(X_TOTAL_COUNT_HEADER_KEY);
+  if (!headerVal) {
+    return obj;
+  }
+  const totalCount = parseInt(headerVal, 10);
+  if (Number.isNaN(totalCount)) {
+    return obj;
+  }
+  if (json.isJSONObject(obj) && !(TOTAL_COUNT_RES_KEY in obj)) {
+    return Object.assign(obj, { [TOTAL_COUNT_RES_KEY]: totalCount });
+  }
+  return obj;
+};
+const responseParser = (unmarshaller, responseType) => async (response) => {
+  if (!isResponse.isResponse(response)) {
+    throw new TypeError("Invalid response object");
+  }
+  if (response.ok) {
+    if (response.status === 204) return unmarshaller(void 0);
+    const contentType = response.headers.get("Content-Type");
+    try {
+      if (responseType === "json" && contentType === "application/json") {
+        return unmarshaller(
+          fixLegacyTotalCount(await response.json(), response.headers)
+        );
+      }
+      if (responseType === "blob") {
+        return unmarshaller(await response.blob());
+      }
+      return unmarshaller(await response.text());
+    } catch (err) {
+      throw new scwError.ScalewayError(
+        response.status,
+        `could not parse '${contentType ?? ""}' response${err instanceof Error ? `: ${err.message}` : ""}`
+      );
+    }
+  }
+  const error = await response.clone().json().catch(() => response.text());
+  if (json.isJSONObject(error)) throw errorParser.parseScalewayError(response.status, error);
+  throw new scwError.ScalewayError(
+    response.status,
+    typeof error === "string" ? error : "cannot read error response body"
+  );
+};
+exports.fixLegacyTotalCount = fixLegacyTotalCount;
+exports.responseParser = responseParser;