@riocrypto/common 1.0.776 → 1.0.777

package/build/errors/active-sell-order-error.d.ts

@@ -2,8 +2,10 @@ import { CustomError } from "./custom-error";
 export declare class ActiveSellOrderError extends CustomError {
     private activeOrderId;
     statusCode: number;
+    internalCode: number;
     constructor(activeOrderId: string);
     serializeErrors(): {
+        code: number;
         message: string;
         activeOrderId: string;
     }[];

package/build/errors/active-sell-order-error.js

@@ -7,11 +7,13 @@ class ActiveSellOrderError extends custom_error_1.CustomError {
         super("There is an active sell order for this user. Cannot create another one");
         this.activeOrderId = activeOrderId;
         this.statusCode = 409;
+        this.internalCode = 1;
         Object.setPrototypeOf(this, ActiveSellOrderError.prototype);
     }
     serializeErrors() {
         return [
             {
+                code: this.internalCode,
                 message: "There is an active sell order for this user. Cannot create another one",
                 activeOrderId: this.activeOrderId,
             },

package/build/errors/address-check-failed-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class AddressCheckFailed extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/address-check-failed-error.js

@@ -6,10 +6,11 @@ class AddressCheckFailed extends custom_error_1.CustomError {
     constructor() {
         super("Address check failed");
         this.statusCode = 400;
+        this.internalCode = 2;
         Object.setPrototypeOf(this, AddressCheckFailed.prototype);
     }
     serializeErrors() {
-        return [{ message: "Address check failed" }];
+        return [{ code: this.internalCode, message: "Address check failed" }];
     }
 }
 exports.AddressCheckFailed = AddressCheckFailed;

package/build/errors/admin-already-exists-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class AdminAlreadyExistsError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/admin-already-exists-error.js

@@ -6,10 +6,16 @@ class AdminAlreadyExistsError extends custom_error_1.CustomError {
     constructor() {
         super("Admin with provided email already exists");
         this.statusCode = 409;
+        this.internalCode = 3;
         Object.setPrototypeOf(this, AdminAlreadyExistsError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Admin with provided email already exists" }];
+        return [
+            {
+                code: this.internalCode,
+                message: "Admin with provided email already exists",
+            },
+        ];
     }
 }
 exports.AdminAlreadyExistsError = AdminAlreadyExistsError;

package/build/errors/admin-not-found-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class AdminNotFoundError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/admin-not-found-error.js

@@ -6,10 +6,11 @@ class AdminNotFoundError extends custom_error_1.CustomError {
     constructor() {
         super("Admin not found");
         this.statusCode = 404;
+        this.internalCode = 4;
         Object.setPrototypeOf(this, AdminNotFoundError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Admin not found" }];
+        return [{ code: this.internalCode, message: "Admin not found" }];
     }
 }
 exports.AdminNotFoundError = AdminNotFoundError;

package/build/errors/admin-only-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class AdminOnlyError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/admin-only-error.js

@@ -6,10 +6,16 @@ class AdminOnlyError extends custom_error_1.CustomError {
     constructor() {
         super("This endpoint can only be called by admins");
         this.statusCode = 401;
+        this.internalCode = 5;
         Object.setPrototypeOf(this, AdminOnlyError.prototype);
     }
     serializeErrors() {
-        return [{ message: "This endpoint can only be called by admins" }];
+        return [
+            {
+                code: this.internalCode,
+                message: "This endpoint can only be called by admins",
+            },
+        ];
     }
 }
 exports.AdminOnlyError = AdminOnlyError;

package/build/errors/api-key-not-found-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class APIKeyNotFoundError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/api-key-not-found-error.js

@@ -6,10 +6,11 @@ class APIKeyNotFoundError extends custom_error_1.CustomError {
     constructor() {
         super("API key not found");
         this.statusCode = 404;
+        this.internalCode = 6;
         Object.setPrototypeOf(this, APIKeyNotFoundError.prototype);
     }
     serializeErrors() {
-        return [{ message: "API key not found" }];
+        return [{ code: this.internalCode, message: "API key not found" }];
     }
 }
 exports.APIKeyNotFoundError = APIKeyNotFoundError;

package/build/errors/auth-already-exists-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class AuthAlreadyExistsError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/auth-already-exists-error.js

@@ -6,10 +6,16 @@ class AuthAlreadyExistsError extends custom_error_1.CustomError {
     constructor() {
         super("Auth with provided phone number already exists");
         this.statusCode = 409;
+        this.internalCode = 7;
         Object.setPrototypeOf(this, AuthAlreadyExistsError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Auth with provided phone number already exists" }];
+        return [
+            {
+                code: this.internalCode,
+                message: "Auth with provided phone number already exists",
+            },
+        ];
     }
 }
 exports.AuthAlreadyExistsError = AuthAlreadyExistsError;

package/build/errors/auth-not-found-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class AuthNotFoundError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/auth-not-found-error.js

@@ -6,10 +6,11 @@ class AuthNotFoundError extends custom_error_1.CustomError {
     constructor() {
         super("Auth not found");
         this.statusCode = 404;
+        this.internalCode = 8;
         Object.setPrototypeOf(this, AuthNotFoundError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Auth not found" }];
+        return [{ code: this.internalCode, message: "Auth not found" }];
     }
 }
 exports.AuthNotFoundError = AuthNotFoundError;

package/build/errors/authorization-failed-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class AuthorizationFailedError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/authorization-failed-error.js

@@ -6,10 +6,11 @@ class AuthorizationFailedError extends custom_error_1.CustomError {
     constructor() {
         super("Wyre authorization codes failed validation");
         this.statusCode = 400;
+        this.internalCode = 9;
         Object.setPrototypeOf(this, AuthorizationFailedError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Authorization failed" }];
+        return [{ code: this.internalCode, message: "Authorization failed" }];
     }
 }
 exports.AuthorizationFailedError = AuthorizationFailedError;

package/build/errors/custom-error.d.ts

@@ -2,6 +2,7 @@ export declare abstract class CustomError extends Error {
     abstract statusCode: number;
     constructor(message: string);
     abstract serializeErrors(): {
+        code: number;
         message: string;
         field?: string;
     }[];

package/build/errors/database-connection-error.d.ts

@@ -1,9 +1,11 @@
 import { CustomError } from "./custom-error";
 export declare class DatabaseConnectionError extends CustomError {
     statusCode: number;
+    internalCode: number;
     reason: string;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/database-connection-error.js

@@ -6,11 +6,12 @@ class DatabaseConnectionError extends custom_error_1.CustomError {
     constructor() {
         super("Error connecting to database");
         this.statusCode = 500;
+        this.internalCode = 10;
         this.reason = "Error connecting to database";
         Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
     }
     serializeErrors() {
-        return [{ message: this.reason }];
+        return [{ code: this.internalCode, message: this.reason }];
     }
 }
 exports.DatabaseConnectionError = DatabaseConnectionError;

package/build/errors/insufficient-liquidity-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class InsufficientLiquidityError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/insufficient-liquidity-error.js

@@ -6,11 +6,13 @@ class InsufficientLiquidityError extends custom_error_1.CustomError {
     constructor() {
         super("Insufficient liquidity to process order");
         this.statusCode = 400;
+        this.internalCode = 11;
         Object.setPrototypeOf(this, InsufficientLiquidityError.prototype);
     }
     serializeErrors() {
         return [
             {
+                code: this.internalCode,
                 message: "Insufficient liquidity to process order, please try again later",
             },
         ];

package/build/errors/invalid-order-size-error.d.ts

@@ -4,8 +4,10 @@ export declare class InvalidOrderSizeError extends CustomError {
     private minAmount;
     private minAmountFiat;
     statusCode: number;
+    internalCode: number;
     constructor(minAmount: number, minAmountFiat: Fiat);
     serializeErrors(): {
+        code: number;
         message: string;
         minAmount: number;
         minAmountFiat: Fiat;

package/build/errors/invalid-order-size-error.js

@@ -8,11 +8,13 @@ class InvalidOrderSizeError extends custom_error_1.CustomError {
         this.minAmount = minAmount;
         this.minAmountFiat = minAmountFiat;
         this.statusCode = 400;
+        this.internalCode = 12;
         Object.setPrototypeOf(this, InvalidOrderSizeError.prototype);
     }
     serializeErrors() {
         return [
             {
+                code: this.internalCode,
                 message: "Invalid order size",
                 minAmount: this.minAmount,
                 minAmountFiat: this.minAmountFiat,

package/build/errors/message-failed-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class MessageFailedError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/message-failed-error.js

@@ -6,10 +6,13 @@ class MessageFailedError extends custom_error_1.CustomError {
     constructor() {
         super("Failed to send verification code");
         this.statusCode = 500;
+        this.internalCode = 13;
         Object.setPrototypeOf(this, MessageFailedError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Failed to send verification code" }];
+        return [
+            { code: this.internalCode, message: "Failed to send verification code" },
+        ];
     }
 }
 exports.MessageFailedError = MessageFailedError;

package/build/errors/missing-cpf-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class MissingCPFError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/missing-cpf-error.js

@@ -6,10 +6,11 @@ class MissingCPFError extends custom_error_1.CustomError {
     constructor() {
         super("User is missing CPF");
         this.statusCode = 401;
+        this.internalCode = 14;
         Object.setPrototypeOf(this, MissingCPFError.prototype);
     }
     serializeErrors() {
-        return [{ message: "User is missing CPF" }];
+        return [{ code: this.internalCode, message: "User is missing CPF" }];
     }
 }
 exports.MissingCPFError = MissingCPFError;

package/build/errors/missing-kyc-approval-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class MissingKYCApprovalError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/missing-kyc-approval-error.js

@@ -6,11 +6,15 @@ class MissingKYCApprovalError extends custom_error_1.CustomError {
     constructor() {
         super("KYC status is not approved for this user");
         this.statusCode = 401;
+        this.internalCode = 15;
         Object.setPrototypeOf(this, MissingKYCApprovalError.prototype);
     }
     serializeErrors() {
         return [
-            { message: "KYC status is not approved is not approved for this user" },
+            {
+                code: this.internalCode,
+                message: "KYC status is not approved is not approved for this user",
+            },
         ];
     }
 }

package/build/errors/missing-password-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class MissingPasswordError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/missing-password-error.js

@@ -6,10 +6,11 @@ class MissingPasswordError extends custom_error_1.CustomError {
     constructor() {
         super("Password is not registered");
         this.statusCode = 401;
+        this.internalCode = 16;
         Object.setPrototypeOf(this, MissingPasswordError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Password is not registered" }];
+        return [{ code: this.internalCode, message: "Password is not registered" }];
     }
 }
 exports.MissingPasswordError = MissingPasswordError;

package/build/errors/missing-security-question-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class MissingSecurityQuestionError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/missing-security-question-error.js

@@ -6,10 +6,16 @@ class MissingSecurityQuestionError extends custom_error_1.CustomError {
     constructor() {
         super("Security question is not registered");
         this.statusCode = 401;
+        this.internalCode = 17;
         Object.setPrototypeOf(this, MissingSecurityQuestionError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Security question is not registered" }];
+        return [
+            {
+                code: this.internalCode,
+                message: "Security question is not registered",
+            },
+        ];
     }
 }
 exports.MissingSecurityQuestionError = MissingSecurityQuestionError;

package/build/errors/missing-user-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class MissingUserError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/missing-user-error.js

@@ -6,10 +6,13 @@ class MissingUserError extends custom_error_1.CustomError {
     constructor() {
         super("Auth is not registered to a user");
         this.statusCode = 401;
+        this.internalCode = 18;
         Object.setPrototypeOf(this, MissingUserError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Auth is not registered to a user" }];
+        return [
+            { code: this.internalCode, message: "Auth is not registered to a user" },
+        ];
     }
 }
 exports.MissingUserError = MissingUserError;

package/build/errors/not-authorized-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class NotAuthorizedError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/not-authorized-error.js

@@ -6,10 +6,11 @@ class NotAuthorizedError extends custom_error_1.CustomError {
     constructor() {
         super("Not authorized");
         this.statusCode = 401;
+        this.internalCode = 19;
         Object.setPrototypeOf(this, NotAuthorizedError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Not authorized" }];
+        return [{ code: this.internalCode, message: "Not authorized" }];
     }
 }
 exports.NotAuthorizedError = NotAuthorizedError;

package/build/errors/not-broker-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class NotBrokerError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/not-broker-error.js

@@ -6,11 +6,15 @@ class NotBrokerError extends custom_error_1.CustomError {
     constructor() {
         super("To call this endpoint as a user, you must be a broker");
         this.statusCode = 401;
+        this.internalCode = 20;
         Object.setPrototypeOf(this, NotBrokerError.prototype);
     }
     serializeErrors() {
         return [
-            { message: "To do this operation as a user, you must be a broker" },
+            {
+                code: this.internalCode,
+                message: "To do this operation as a user, you must be a broker",
+            },
         ];
     }
 }

package/build/errors/not-found-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class NotFoundError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/not-found-error.js

@@ -6,10 +6,11 @@ class NotFoundError extends custom_error_1.CustomError {
     constructor() {
         super("Route not found");
         this.statusCode = 404;
+        this.internalCode = 21;
         Object.setPrototypeOf(this, NotFoundError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Not found" }];
+        return [{ code: this.internalCode, message: "Not found" }];
     }
 }
 exports.NotFoundError = NotFoundError;

package/build/errors/partner-already-exists-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class PartnerAlreadyExistsError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/partner-already-exists-error.js

@@ -6,10 +6,11 @@ class PartnerAlreadyExistsError extends custom_error_1.CustomError {
     constructor() {
         super("Partner already exists");
         this.statusCode = 409;
+        this.internalCode = 22;
         Object.setPrototypeOf(this, PartnerAlreadyExistsError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Partner already exists" }];
+        return [{ code: this.internalCode, message: "Partner already exists" }];
     }
 }
 exports.PartnerAlreadyExistsError = PartnerAlreadyExistsError;

package/build/errors/partner-auth-already-exists-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class PartnerAuthAlreadyExistsError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/partner-auth-already-exists-error.js

@@ -6,10 +6,16 @@ class PartnerAuthAlreadyExistsError extends custom_error_1.CustomError {
     constructor() {
         super("Partner auth with provided email already exists");
         this.statusCode = 409;
+        this.internalCode = 23;
         Object.setPrototypeOf(this, PartnerAuthAlreadyExistsError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Partner auth with provided email already exists" }];
+        return [
+            {
+                code: this.internalCode,
+                message: "Partner auth with provided email already exists",
+            },
+        ];
     }
 }
 exports.PartnerAuthAlreadyExistsError = PartnerAuthAlreadyExistsError;

package/build/errors/partner-auth-not-found-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class PartnerAuthNotFoundError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/partner-auth-not-found-error.js

@@ -6,10 +6,11 @@ class PartnerAuthNotFoundError extends custom_error_1.CustomError {
     constructor() {
         super("Partner auth not found");
         this.statusCode = 404;
+        this.internalCode = 24;
         Object.setPrototypeOf(this, PartnerAuthNotFoundError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Partner auth not found" }];
+        return [{ code: this.internalCode, message: "Partner auth not found" }];
     }
 }
 exports.PartnerAuthNotFoundError = PartnerAuthNotFoundError;

package/build/errors/partner-not-found-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class PartnerNotFoundError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/partner-not-found-error.js

@@ -6,10 +6,11 @@ class PartnerNotFoundError extends custom_error_1.CustomError {
     constructor() {
         super("Partner not found");
         this.statusCode = 404;
+        this.internalCode = 25;
         Object.setPrototypeOf(this, PartnerNotFoundError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Partner not found" }];
+        return [{ code: this.internalCode, message: "Partner not found" }];
     }
 }
 exports.PartnerNotFoundError = PartnerNotFoundError;

package/build/errors/password-already-used-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class PasswordAlreadyUsedError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/password-already-used-error.js

@@ -6,10 +6,11 @@ class PasswordAlreadyUsedError extends custom_error_1.CustomError {
     constructor() {
         super("Password already used");
         this.statusCode = 400;
+        this.internalCode = 26;
         Object.setPrototypeOf(this, PasswordAlreadyUsedError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Password already used" }];
+        return [{ code: this.internalCode, message: "Password already used" }];
     }
 }
 exports.PasswordAlreadyUsedError = PasswordAlreadyUsedError;

package/build/errors/request-validation-error.d.ts

@@ -3,8 +3,10 @@ import { ValidationError } from "express-validator";
 export declare class RequestValidationError extends CustomError {
     errors: ValidationError[];
     statusCode: number;
+    internalCode: number;
     constructor(errors: ValidationError[]);
     serializeErrors(): {
+        code: number;
         message: any;
         field: string;
     }[];

package/build/errors/request-validation-error.js

@@ -7,11 +7,12 @@ class RequestValidationError extends custom_error_1.CustomError {
         super("Invalid request parameters");
         this.errors = errors;
         this.statusCode = 400;
+        this.internalCode = 27;
         Object.setPrototypeOf(this, RequestValidationError.prototype);
     }
     serializeErrors() {
         return this.errors.map((err) => {
-            return { message: err.msg, field: err.param };
+            return { code: this.internalCode, message: err.msg, field: err.param };
         });
     }
 }

package/build/errors/rio-settings-already-exists-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class RioSettingsAlreadyExistsError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/rio-settings-already-exists-error.js

@@ -6,10 +6,13 @@ class RioSettingsAlreadyExistsError extends custom_error_1.CustomError {
     constructor() {
         super("Rio settings already exists");
         this.statusCode = 409;
+        this.internalCode = 28;
         Object.setPrototypeOf(this, RioSettingsAlreadyExistsError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Rio settings already exists" }];
+        return [
+            { code: this.internalCode, message: "Rio settings already exists" },
+        ];
     }
 }
 exports.RioSettingsAlreadyExistsError = RioSettingsAlreadyExistsError;

package/build/errors/rio-settings-not-found-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class RioSettingsNotFoundError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/rio-settings-not-found-error.js

@@ -6,10 +6,13 @@ class RioSettingsNotFoundError extends custom_error_1.CustomError {
     constructor() {
         super("Rio settings not found");
         this.statusCode = 404;
+        this.internalCode = 29;
         Object.setPrototypeOf(this, RioSettingsNotFoundError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Missing internal Rio settings" }];
+        return [
+            { code: this.internalCode, message: "Missing internal Rio settings" },
+        ];
     }
 }
 exports.RioSettingsNotFoundError = RioSettingsNotFoundError;

package/build/errors/user-already-exists-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class UserAlreadyExistsError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/user-already-exists-error.js

@@ -6,10 +6,11 @@ class UserAlreadyExistsError extends custom_error_1.CustomError {
     constructor() {
         super("User already exists");
         this.statusCode = 409;
+        this.internalCode = 30;
         Object.setPrototypeOf(this, UserAlreadyExistsError.prototype);
     }
     serializeErrors() {
-        return [{ message: "User already exists" }];
+        return [{ code: this.internalCode, message: "User already exists" }];
     }
 }
 exports.UserAlreadyExistsError = UserAlreadyExistsError;

package/build/errors/verification-failed-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class VerificationFailedError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/verification-failed-error.js

@@ -6,10 +6,11 @@ class VerificationFailedError extends custom_error_1.CustomError {
     constructor() {
         super("SMS verification failed");
         this.statusCode = 401;
+        this.internalCode = 31;
         Object.setPrototypeOf(this, VerificationFailedError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Verification failed" }];
+        return [{ code: this.internalCode, message: "Verification failed" }];
     }
 }
 exports.VerificationFailedError = VerificationFailedError;

package/build/errors/wrong-order-state-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class WrongOrderStateError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/wrong-order-state-error.js

@@ -6,11 +6,15 @@ class WrongOrderStateError extends custom_error_1.CustomError {
     constructor() {
         super("Order is not in the correct state to call this method");
         this.statusCode = 400;
+        this.internalCode = 32;
         Object.setPrototypeOf(this, WrongOrderStateError.prototype);
     }
     serializeErrors() {
         return [
-            { message: "Order is not in the correct state to call this method" },
+            {
+                code: this.internalCode,
+                message: "Order is not in the correct state to call this method",
+            },
         ];
     }
 }

package/build/errors/wrong-password-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class WrongPasswordError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/wrong-password-error.js

@@ -6,10 +6,11 @@ class WrongPasswordError extends custom_error_1.CustomError {
     constructor() {
         super("Wrong password");
         this.statusCode = 401;
+        this.internalCode = 33;
         Object.setPrototypeOf(this, WrongPasswordError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Wrong password" }];
+        return [{ code: this.internalCode, message: "Wrong password" }];
     }
 }
 exports.WrongPasswordError = WrongPasswordError;

package/build/errors/wrong-processor-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class WrongProcessorError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/wrong-processor-error.js

@@ -6,10 +6,16 @@ class WrongProcessorError extends custom_error_1.CustomError {
     constructor() {
         super("Order not assigned to this processor");
         this.statusCode = 400;
+        this.internalCode = 34;
         Object.setPrototypeOf(this, WrongProcessorError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Order not assigned to this processor" }];
+        return [
+            {
+                code: this.internalCode,
+                message: "Order not assigned to this processor",
+            },
+        ];
     }
 }
 exports.WrongProcessorError = WrongProcessorError;

package/build/errors/wrong-security-answer-error.d.ts

@@ -1,8 +1,10 @@
 import { CustomError } from "./custom-error";
 export declare class WrongSecurityAnswerError extends CustomError {
     statusCode: number;
+    internalCode: number;
     constructor();
     serializeErrors(): {
+        code: number;
         message: string;
     }[];
 }

package/build/errors/wrong-security-answer-error.js

@@ -6,10 +6,11 @@ class WrongSecurityAnswerError extends custom_error_1.CustomError {
     constructor() {
         super("Wrong security answer");
         this.statusCode = 401;
+        this.internalCode = 35;
         Object.setPrototypeOf(this, WrongSecurityAnswerError.prototype);
     }
     serializeErrors() {
-        return [{ message: "Wrong security answer" }];
+        return [{ code: this.internalCode, message: "Wrong security answer" }];
     }
 }
 exports.WrongSecurityAnswerError = WrongSecurityAnswerError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common",
-  "version": "1.0.776",
+  "version": "1.0.777",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",