@scaleway/sdk-std 1.0.1

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

@@ -0,0 +1,43 @@
+import { isJSONObject } from "../../helpers/json.js";
+import { isRecordOfStringArray } from "./types.js";
+const buildDefaultMessage = (status, body) => {
+  const message = [`http error ${status}`];
+  if (typeof body === "string") {
+    message.push(body);
+  } else if (isJSONObject(body)) {
+    if (typeof body.resource === "string") {
+      message.push(`resource ${body.resource}`);
+    }
+    if (typeof body.message === "string") {
+      message.push(body.message);
+    }
+    if (body.fields && isRecordOfStringArray(body.fields)) {
+      message.push(
+        Object.entries(body.fields).map(([name, list]) => `${name} (${list.join(", ")})`).join(", ")
+      );
+    }
+  }
+  return message.join(": ");
+};
+class ScalewayError extends Error {
+  constructor(status, body, message = buildDefaultMessage(status, body)) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.message = message;
+    this.name = "ScalewayError";
+    this.rawMessage = typeof body === "object" && typeof body.message === "string" ? body.message : void 0;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /** The message originating from the payload. */
+  rawMessage;
+  static fromJSON(status, obj) {
+    return new ScalewayError(status, obj);
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+}
+export {
+  ScalewayError
+};

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/already-exists-error.cjs

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

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/already-exists-error.d.ts

@@ -0,0 +1,16 @@
+import type { JSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+/**
+ * AlreadyExists error is used when a resource already exists.
+ *
+ * @public
+ */
+export declare class AlreadyExistsError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    readonly resourceId: string;
+    readonly helpMessage: string;
+    constructor(status: number, body: JSONObject, resource: string, resourceId: string, helpMessage: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): AlreadyExistsError | null;
+}

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/already-exists-error.js

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

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/denied-authentication-error.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+const buildMessage = (method, reason) => {
+  let reasonDesc;
+  switch (reason) {
+    case "invalid_argument":
+      reasonDesc = `invalid ${method} format or empty value`;
+      break;
+    case "not_found":
+      reasonDesc = `${method} does not exist`;
+      break;
+    case "expired":
+      reasonDesc = `${method} is expired`;
+      break;
+    default:
+      reasonDesc = `unknown reason for ${method}`;
+  }
+  return `denied authentication: ${reasonDesc}`;
+};
+class DeniedAuthenticationError extends scwError.ScalewayError {
+  constructor(status, body, method, reason) {
+    super(status, body, buildMessage(method, reason));
+    this.status = status;
+    this.body = body;
+    this.method = method;
+    this.reason = reason;
+    this.name = "DeniedAuthenticationError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.method !== "string" || typeof obj.reason !== "string") {
+      return null;
+    }
+    return new DeniedAuthenticationError(status, obj, obj.method, obj.reason);
+  }
+}
+exports.DeniedAuthenticationError = DeniedAuthenticationError;

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/denied-authentication-error.d.ts

@@ -0,0 +1,15 @@
+import type { JSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+/**
+ * DeniedAuthentication error is used by the API Gateway auth service to deny a request.
+ *
+ * @public
+ */
+export declare class DeniedAuthenticationError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly method: string;
+    readonly reason: string;
+    constructor(status: number, body: JSONObject, method: string, reason: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): DeniedAuthenticationError | null;
+}

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/denied-authentication-error.js

@@ -0,0 +1,37 @@
+import { ScalewayError } from "../scw-error.js";
+const buildMessage = (method, reason) => {
+  let reasonDesc;
+  switch (reason) {
+    case "invalid_argument":
+      reasonDesc = `invalid ${method} format or empty value`;
+      break;
+    case "not_found":
+      reasonDesc = `${method} does not exist`;
+      break;
+    case "expired":
+      reasonDesc = `${method} is expired`;
+      break;
+    default:
+      reasonDesc = `unknown reason for ${method}`;
+  }
+  return `denied authentication: ${reasonDesc}`;
+};
+class DeniedAuthenticationError extends ScalewayError {
+  constructor(status, body, method, reason) {
+    super(status, body, buildMessage(method, reason));
+    this.status = status;
+    this.body = body;
+    this.method = method;
+    this.reason = reason;
+    this.name = "DeniedAuthenticationError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.method !== "string" || typeof obj.reason !== "string") {
+      return null;
+    }
+    return new DeniedAuthenticationError(status, obj, obj.method, obj.reason);
+  }
+}
+export {
+  DeniedAuthenticationError
+};

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+const alreadyExistsError = require("./already-exists-error.cjs");
+const deniedAuthenticationError = require("./denied-authentication-error.cjs");
+const invalidArgumentsError = require("./invalid-arguments-error.cjs");
+const outOfStockError = require("./out-of-stock-error.cjs");
+const permissionsDeniedError = require("./permissions-denied-error.cjs");
+const preconditionFailedError = require("./precondition-failed-error.cjs");
+const quotasExceededError = require("./quotas-exceeded-error.cjs");
+const resourceExpiredError = require("./resource-expired-error.cjs");
+const resourceLockedError = require("./resource-locked-error.cjs");
+const resourceNotFoundError = require("./resource-not-found-error.cjs");
+const tooManyRequestsError = require("./too-many-requests-error.cjs");
+const transientStateError = require("./transient-state-error.cjs");
+exports.ScalewayError = scwError.ScalewayError;
+exports.AlreadyExistsError = alreadyExistsError.AlreadyExistsError;
+exports.DeniedAuthenticationError = deniedAuthenticationError.DeniedAuthenticationError;
+exports.InvalidArgumentsError = invalidArgumentsError.InvalidArgumentsError;
+exports.OutOfStockError = outOfStockError.OutOfStockError;
+exports.PermissionsDeniedError = permissionsDeniedError.PermissionsDeniedError;
+exports.PreconditionFailedError = preconditionFailedError.PreconditionFailedError;
+exports.QuotasExceededError = quotasExceededError.QuotasExceededError;
+exports.ResourceExpiredError = resourceExpiredError.ResourceExpiredError;
+exports.ResourceLockedError = resourceLockedError.ResourceLockedError;
+exports.ResourceNotFoundError = resourceNotFoundError.ResourceNotFoundError;
+exports.TooManyRequestsError = tooManyRequestsError.TooManyRequestsError;
+exports.TransientStateError = transientStateError.TransientStateError;

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

@@ -0,0 +1,17 @@
+export { ScalewayError } from '../scw-error.js';
+export { AlreadyExistsError } from './already-exists-error.js';
+export { DeniedAuthenticationError } from './denied-authentication-error.js';
+export { InvalidArgumentsError } from './invalid-arguments-error.js';
+export type { InvalidArgumentsErrorDetails } from './invalid-arguments-error.js';
+export { OutOfStockError } from './out-of-stock-error.js';
+export { PermissionsDeniedError } from './permissions-denied-error.js';
+export type { PermissionsDeniedErrorDetails } from './permissions-denied-error.js';
+export { PreconditionFailedError } from './precondition-failed-error.js';
+export { QuotasExceededError } from './quotas-exceeded-error.js';
+export type { QuotasExceededErrorDetails, QuotasExceededErrorScope, } from './quotas-exceeded-error.js';
+export { ResourceExpiredError } from './resource-expired-error.js';
+export { ResourceLockedError } from './resource-locked-error.js';
+export { ResourceNotFoundError } from './resource-not-found-error.js';
+export { TooManyRequestsError } from './too-many-requests-error.js';
+export type { TooManyRequestsQuotaPolicy } from './too-many-requests-error.js';
+export { TransientStateError } from './transient-state-error.js';

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

@@ -0,0 +1,28 @@
+import { ScalewayError } from "../scw-error.js";
+import { AlreadyExistsError } from "./already-exists-error.js";
+import { DeniedAuthenticationError } from "./denied-authentication-error.js";
+import { InvalidArgumentsError } from "./invalid-arguments-error.js";
+import { OutOfStockError } from "./out-of-stock-error.js";
+import { PermissionsDeniedError } from "./permissions-denied-error.js";
+import { PreconditionFailedError } from "./precondition-failed-error.js";
+import { QuotasExceededError } from "./quotas-exceeded-error.js";
+import { ResourceExpiredError } from "./resource-expired-error.js";
+import { ResourceLockedError } from "./resource-locked-error.js";
+import { ResourceNotFoundError } from "./resource-not-found-error.js";
+import { TooManyRequestsError } from "./too-many-requests-error.js";
+import { TransientStateError } from "./transient-state-error.js";
+export {
+  AlreadyExistsError,
+  DeniedAuthenticationError,
+  InvalidArgumentsError,
+  OutOfStockError,
+  PermissionsDeniedError,
+  PreconditionFailedError,
+  QuotasExceededError,
+  ResourceExpiredError,
+  ResourceLockedError,
+  ResourceNotFoundError,
+  ScalewayError,
+  TooManyRequestsError,
+  TransientStateError
+};

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/invalid-arguments-error.cjs

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const json = require("../../../helpers/json.cjs");
+const scwError = require("../scw-error.cjs");
+const buildMessage = (list) => {
+  const invalidArgs = list.reduce((acc, details) => {
+    let readableReason = "";
+    switch (details.reason) {
+      case "required":
+        readableReason = `is required`;
+        break;
+      case "format":
+        readableReason = `is wrongly formatted`;
+        break;
+      case "constraint":
+        readableReason = `does not respect constraint`;
+        break;
+      default:
+        readableReason = `is invalid for unexpected reason`;
+        break;
+    }
+    if (details.helpMessage && details.helpMessage.length > 0) {
+      readableReason = readableReason.concat(`, `, details.helpMessage);
+    }
+    acc.push(`${details.argumentName} ${readableReason}`);
+    return acc;
+  }, []);
+  return `invalid argument(s): ${invalidArgs.join("; ")}`;
+};
+class InvalidArgumentsError extends scwError.ScalewayError {
+  constructor(status, body, details) {
+    super(status, body, buildMessage(details));
+    this.status = status;
+    this.body = body;
+    this.details = details;
+    this.name = "InvalidArgumentsError";
+  }
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details)) return null;
+    return new InvalidArgumentsError(
+      status,
+      obj,
+      obj.details.reduce(
+        (list, detail) => json.isJSONObject(detail) && typeof detail.argument_name === "string" && typeof detail.reason === "string" ? list.concat({
+          argumentName: detail.argument_name,
+          helpMessage: typeof detail.help_message === "string" ? detail.help_message : void 0,
+          reason: detail.reason
+        }) : list,
+        []
+      )
+    );
+  }
+}
+exports.InvalidArgumentsError = InvalidArgumentsError;

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/invalid-arguments-error.d.ts

@@ -0,0 +1,24 @@
+import type { JSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+/**
+ * Details of an {@link InvalidArgumentsError} error.
+ *
+ * @public
+ */
+export interface InvalidArgumentsErrorDetails {
+    readonly argumentName: string;
+    readonly reason: string;
+    readonly helpMessage?: string;
+}
+/**
+ * InvalidArguments error happens when one or many fields are invalid in the request message.
+ *
+ * @public
+ */
+export declare class InvalidArgumentsError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly details: InvalidArgumentsErrorDetails[];
+    constructor(status: number, body: JSONObject, details: InvalidArgumentsErrorDetails[]);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): InvalidArgumentsError | null;
+}

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/invalid-arguments-error.js

@@ -0,0 +1,54 @@
+import { isJSONObject } from "../../../helpers/json.js";
+import { ScalewayError } from "../scw-error.js";
+const buildMessage = (list) => {
+  const invalidArgs = list.reduce((acc, details) => {
+    let readableReason = "";
+    switch (details.reason) {
+      case "required":
+        readableReason = `is required`;
+        break;
+      case "format":
+        readableReason = `is wrongly formatted`;
+        break;
+      case "constraint":
+        readableReason = `does not respect constraint`;
+        break;
+      default:
+        readableReason = `is invalid for unexpected reason`;
+        break;
+    }
+    if (details.helpMessage && details.helpMessage.length > 0) {
+      readableReason = readableReason.concat(`, `, details.helpMessage);
+    }
+    acc.push(`${details.argumentName} ${readableReason}`);
+    return acc;
+  }, []);
+  return `invalid argument(s): ${invalidArgs.join("; ")}`;
+};
+class InvalidArgumentsError extends ScalewayError {
+  constructor(status, body, details) {
+    super(status, body, buildMessage(details));
+    this.status = status;
+    this.body = body;
+    this.details = details;
+    this.name = "InvalidArgumentsError";
+  }
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details)) return null;
+    return new InvalidArgumentsError(
+      status,
+      obj,
+      obj.details.reduce(
+        (list, detail) => isJSONObject(detail) && typeof detail.argument_name === "string" && typeof detail.reason === "string" ? list.concat({
+          argumentName: detail.argument_name,
+          helpMessage: typeof detail.help_message === "string" ? detail.help_message : void 0,
+          reason: detail.reason
+        }) : list,
+        []
+      )
+    );
+  }
+}
+export {
+  InvalidArgumentsError
+};

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/out-of-stock-error.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+class OutOfStockError extends scwError.ScalewayError {
+  constructor(status, body, resource) {
+    super(status, body, `resource ${resource} is out of stock`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.name = "OutOfStockError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== "string") return null;
+    return new OutOfStockError(status, obj, obj.resource);
+  }
+}
+exports.OutOfStockError = OutOfStockError;

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/out-of-stock-error.d.ts

@@ -0,0 +1,14 @@
+import type { JSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+/**
+ * OutOfStock error happens when stocks are empty for the resource.
+ *
+ * @public
+ */
+export declare class OutOfStockError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly resource: string;
+    constructor(status: number, body: JSONObject, resource: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): OutOfStockError | null;
+}

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/out-of-stock-error.js

@@ -0,0 +1,17 @@
+import { ScalewayError } from "../scw-error.js";
+class OutOfStockError extends ScalewayError {
+  constructor(status, body, resource) {
+    super(status, body, `resource ${resource} is out of stock`);
+    this.status = status;
+    this.body = body;
+    this.resource = resource;
+    this.name = "OutOfStockError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.resource !== "string") return null;
+    return new OutOfStockError(status, obj, obj.resource);
+  }
+}
+export {
+  OutOfStockError
+};

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/permissions-denied-error.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const json = require("../../../helpers/json.cjs");
+const scwError = require("../scw-error.cjs");
+const buildMessage = (list) => `insufficient permissions: ${list.map(({ action, resource }) => `${action} ${resource}`).join("; ")}`;
+class PermissionsDeniedError extends scwError.ScalewayError {
+  constructor(status, body, list) {
+    super(status, body, buildMessage(list));
+    this.status = status;
+    this.body = body;
+    this.list = list;
+    this.name = "PermissionsDeniedError";
+  }
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details)) return null;
+    return new PermissionsDeniedError(
+      status,
+      obj,
+      obj.details.reduce(
+        (list, detail) => json.isJSONObject(detail) && typeof detail.resource === "string" && typeof detail.action === "string" ? list.concat({
+          action: detail.action,
+          resource: detail.resource
+        }) : list,
+        []
+      )
+    );
+  }
+}
+exports.PermissionsDeniedError = PermissionsDeniedError;

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/permissions-denied-error.d.ts

@@ -0,0 +1,23 @@
+import type { JSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+/**
+ * Details of an {@link PermissionsDeniedError} error.
+ *
+ * @public
+ */
+export interface PermissionsDeniedErrorDetails {
+    readonly resource: string;
+    readonly action: string;
+}
+/**
+ * PermissionsDenied error happens when one or many permissions are not accorded to the user making the request.
+ *
+ * @public
+ */
+export declare class PermissionsDeniedError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly list: PermissionsDeniedErrorDetails[];
+    constructor(status: number, body: JSONObject, list: PermissionsDeniedErrorDetails[]);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): ScalewayError | null;
+}

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/permissions-denied-error.js

@@ -0,0 +1,29 @@
+import { isJSONObject } from "../../../helpers/json.js";
+import { ScalewayError } from "../scw-error.js";
+const buildMessage = (list) => `insufficient permissions: ${list.map(({ action, resource }) => `${action} ${resource}`).join("; ")}`;
+class PermissionsDeniedError extends ScalewayError {
+  constructor(status, body, list) {
+    super(status, body, buildMessage(list));
+    this.status = status;
+    this.body = body;
+    this.list = list;
+    this.name = "PermissionsDeniedError";
+  }
+  static fromJSON(status, obj) {
+    if (!Array.isArray(obj.details)) return null;
+    return new PermissionsDeniedError(
+      status,
+      obj,
+      obj.details.reduce(
+        (list, detail) => isJSONObject(detail) && typeof detail.resource === "string" && typeof detail.action === "string" ? list.concat({
+          action: detail.action,
+          resource: detail.resource
+        }) : list,
+        []
+      )
+    );
+  }
+}
+export {
+  PermissionsDeniedError
+};

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/precondition-failed-error.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const scwError = require("../scw-error.cjs");
+const buildMessage = (precondition, helpMessage) => {
+  let message = `precondition failed: ${precondition}`;
+  if (typeof helpMessage === "string" && helpMessage.length > 0) {
+    message = message.concat(", ", helpMessage);
+  }
+  return message;
+};
+class PreconditionFailedError extends scwError.ScalewayError {
+  constructor(status, body, precondition, helpMessage) {
+    super(status, body, buildMessage(precondition, helpMessage));
+    this.status = status;
+    this.body = body;
+    this.precondition = precondition;
+    this.helpMessage = helpMessage;
+    this.name = "PreconditionFailedError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.precondition !== "string" || typeof obj.help_message !== "string") {
+      return null;
+    }
+    return new PreconditionFailedError(
+      status,
+      obj,
+      obj.precondition,
+      obj.help_message
+    );
+  }
+}
+exports.PreconditionFailedError = PreconditionFailedError;

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/precondition-failed-error.d.ts

@@ -0,0 +1,15 @@
+import type { JSONObject } from '../../../helpers/json.js';
+import { ScalewayError } from '../scw-error.js';
+/**
+ * PreconditionFailed error is used when a precondition is not respected.
+ *
+ * @public
+ */
+export declare class PreconditionFailedError extends ScalewayError {
+    readonly status: number;
+    readonly body: JSONObject;
+    readonly precondition: string;
+    readonly helpMessage: string;
+    constructor(status: number, body: JSONObject, precondition: string, helpMessage: string);
+    static fromJSON(status: number, obj: Readonly<JSONObject>): PreconditionFailedError | null;
+}

package/node_modules/@scaleway/sdk-client/dist/scw/errors/standard/precondition-failed-error.js

@@ -0,0 +1,32 @@
+import { ScalewayError } from "../scw-error.js";
+const buildMessage = (precondition, helpMessage) => {
+  let message = `precondition failed: ${precondition}`;
+  if (typeof helpMessage === "string" && helpMessage.length > 0) {
+    message = message.concat(", ", helpMessage);
+  }
+  return message;
+};
+class PreconditionFailedError extends ScalewayError {
+  constructor(status, body, precondition, helpMessage) {
+    super(status, body, buildMessage(precondition, helpMessage));
+    this.status = status;
+    this.body = body;
+    this.precondition = precondition;
+    this.helpMessage = helpMessage;
+    this.name = "PreconditionFailedError";
+  }
+  static fromJSON(status, obj) {
+    if (typeof obj.precondition !== "string" || typeof obj.help_message !== "string") {
+      return null;
+    }
+    return new PreconditionFailedError(
+      status,
+      obj,
+      obj.precondition,
+      obj.help_message
+    );
+  }
+}
+export {
+  PreconditionFailedError
+};