@riocrypto/common-server 1.0.506

package/build/clients/kushki-client.d.ts

@@ -0,0 +1,14 @@
+import { BusinessUser } from "../types/business-user";
+import { Order } from "../types/order";
+import { User } from "../types/user";
+declare class KushkiClient {
+    private privateMerchantId;
+    private environment;
+    private baseUrl;
+    constructor(privateMerchantId: string, environment: "sandbox" | "production");
+    createPaymentLink(order: Order, user: User, token: string): Promise<any>;
+    createBankPaymentToken(order: Order, user: User | BusinessUser): Promise<any>;
+    createBankPayment(order: Order, user: User | BusinessUser, token: string): Promise<any>;
+}
+export declare const kushkiClient: KushkiClient;
+export {};

package/build/clients/kushki-client.js

@@ -0,0 +1,150 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kushkiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const user_type_1 = require("../types/user-type");
+class KushkiClient {
+    constructor(privateMerchantId, environment) {
+        this.privateMerchantId = privateMerchantId;
+        this.environment = environment;
+        this.baseUrl = `https://api${this.environment === "production" ? "." : "-uat."}kushkipagos.com`;
+    }
+    createPaymentLink(order, user, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = {
+                token,
+                amount: {
+                    currency: order.fiat,
+                    subtotalIva: 0,
+                    subtotalIva0: order.amountFiat,
+                    iva: 0,
+                    ice: 0,
+                },
+                contactDetails: {
+                    firstName: user.firstName,
+                    lastName: user.lastName,
+                    email: user.email,
+                    documentType: "CC",
+                    phoneNumber: user.phoneNumber,
+                },
+                orderDetails: {
+                    siteDomain: "riocrypto.com",
+                    shippingDetails: {
+                        name: `${user.firstName} ${user.lastName}`,
+                        phone: user.phoneNumber,
+                        address1: user.street1,
+                        address2: user.street2,
+                        city: user.city,
+                        region: user.state,
+                        country: user.country,
+                        zipcode: user.postalCode,
+                    },
+                    billingDetails: {
+                        name: `${user.firstName} ${user.lastName}`,
+                        phone: user.phoneNumber,
+                        address1: user.street1,
+                        address2: user.street2,
+                        city: user.city,
+                        region: user.state,
+                        country: user.country,
+                        zipcode: user.postalCode,
+                    },
+                    product: {
+                        id: order.id,
+                        title: order.crypto,
+                        price: order.amountFiat,
+                        sku: order.id,
+                        quantity: 1,
+                    },
+                },
+            };
+            const response = yield (0, axios_1.default)({
+                method: "post",
+                url: `${this.baseUrl}/card/v1/charges`,
+                headers: {
+                    "Content-Type": "application/json",
+                    "Private-Merchant-Id": this.privateMerchantId,
+                    "Accept-Encoding": "gzip,deflate,compress",
+                },
+                data: body,
+            });
+            const data = response.data;
+            return data;
+        });
+    }
+    createBankPaymentToken(order, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = {
+                amount: {
+                    subtotalIva: 0,
+                    subtotalIva0: order.amountFiat,
+                    iva: 0,
+                },
+                callbackUrl: "https://riocrypto.com",
+                userType: user.type === user_type_1.UserType.Business ? 1 : 0,
+                documentType: "CC",
+                documentNumber: "123456789",
+                paymentDescription: `Compra de ${order.crypto} en riocrypto.com`,
+                email: user.email,
+                currency: order.fiat,
+            };
+            const response = yield (0, axios_1.default)({
+                method: "post",
+                url: `${this.baseUrl}/transfer/v1/tokens`,
+                headers: {
+                    "Content-Type": "application/json",
+                    "Private-Merchant-Id": this.privateMerchantId,
+                    "Accept-Encoding": "gzip,deflate,compress",
+                },
+                data: body,
+            });
+            const data = response.data;
+            return data;
+        });
+    }
+    createBankPayment(order, user, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = {
+                token,
+                amount: {
+                    subtotalIva: 0,
+                    subtotalIva0: order.amountFiat,
+                    iva: 0,
+                },
+                contactDetails: {
+                    fullName: user.type === user_type_1.UserType.Business
+                        ? user.companyName
+                        : `${user.firstName} ${user.lastName}`,
+                    email: user.email,
+                    documentType: "CC",
+                    phoneNumber: user.phoneNumber,
+                },
+            };
+            const response = yield (0, axios_1.default)({
+                method: "post",
+                url: `${this.baseUrl}/transfer/v1/init`,
+                headers: {
+                    "Content-Type": "application/json",
+                    "Private-Merchant-Id": this.privateMerchantId,
+                    "Accept-Encoding": "gzip,deflate,compress",
+                },
+                data: body,
+            });
+            const data = response.data;
+            return data;
+        });
+    }
+}
+exports.kushkiClient = new KushkiClient(process.env.KUSHKI_PRIVATE_MERCHANT_ID, process.env.KUSHKI_ENV);

package/build/clients/rio-client.d.ts

@@ -0,0 +1,82 @@
+import { AxiosInstance, AxiosStatic } from "axios";
+import { Admin } from "../types/admin";
+import { Auth } from "../types/auth";
+import { AuthUpdate } from "../types/auth-update";
+import { BankPayout } from "../types/bank-payout";
+import { BusinessUser } from "../types/business-user";
+import { BusinessUserInput } from "../types/business-user-input";
+import { BusinessUserUpdate } from "../types/business-user-update";
+import { CheckedAddress } from "../types/checked-address";
+import { Country } from "../types/country";
+import { Fiat } from "../types/fiat";
+import { Order } from "../types/order";
+import { OrderInput } from "../types/order-input";
+import { Partner } from "../types/partner";
+import { PaymentMethod } from "../types/payment-method";
+import { PayoutMethod } from "../types/payout-method";
+import { RioSettings } from "../types/rio-settings";
+import { RioSettingsUpdate } from "../types/rio-settings-update";
+import { SecurityQuestion } from "../types/security-question";
+import { User } from "../types/user";
+import { UserInput } from "../types/user-input";
+import { UserUpdate } from "../types/user-update";
+export declare class RioClient {
+    private axios;
+    constructor(axios: AxiosStatic | AxiosInstance);
+    getOrders(): Promise<Order[]>;
+    getUsers(): Promise<User[]>;
+    getBusinessUsers(): Promise<BusinessUser[]>;
+    signin(email: string, password: string): Promise<any>;
+    updateUser(update: UserUpdate, userId?: string): Promise<User>;
+    updateBusinessUser(update: BusinessUserUpdate, businessUserId?: string): Promise<BusinessUser>;
+    updateAdminUserPassword({ password, newPassword, }: {
+        password: string;
+        newPassword: string;
+    }): Promise<Admin>;
+    getAdminUser(): Promise<any>;
+    signoutAdmin(): Promise<void>;
+    getRioSettings(): Promise<RioSettings>;
+    createRioSettings(rioSettings: {
+        platformFee: number;
+    }): Promise<void>;
+    updateRioSettings(update: RioSettingsUpdate): Promise<void>;
+    confirmBankPayment(orderId: string): Promise<any>;
+    getUser(): Promise<User>;
+    getBusinessUser(): Promise<BusinessUser>;
+    createUser(user: UserInput): Promise<void>;
+    createBusinessUser(businessUser: BusinessUserInput): Promise<BusinessUser>;
+    createBrokerCustomer(businessUser: BusinessUserInput): Promise<BusinessUser>;
+    sendPhoneAuthCode(phoneNumber: string): Promise<void>;
+    authExists(phoneNumber: string): Promise<boolean>;
+    uploadCOI(businessUserId: string, formData: FormData): Promise<BusinessUser>;
+    uploadKYCReport(businessUserId: string, formData: FormData): Promise<BusinessUser>;
+    getSecurityQuestion(): Promise<SecurityQuestion>;
+    signout(): Promise<void>;
+    verifyPhoneCode(phoneNumber: string, code: string): Promise<void>;
+    createAuth(password: string): Promise<void>;
+    createOrder(order: OrderInput): Promise<Order>;
+    getOrder(id: string): Promise<Order>;
+    initBankPayout(oid: string, accountNumber: string): Promise<BankPayout>;
+    getBankPayout(orderId: string): Promise<BankPayout>;
+    checkAddress(address: string, crypto: Crypto): Promise<CheckedAddress>;
+    getSupportedPaymentMethods(fiat: Fiat, country: Country): Promise<PaymentMethod[]>;
+    getBrokerCustomers(): Promise<BusinessUser[]>;
+    getSupportedPayoutMethods(fiat: Fiat, country: Country): Promise<PayoutMethod[]>;
+    getPartnerLayout(partnerId: string): Promise<Partner>;
+    createClipCardPayment(orderId: string): Promise<{
+        paymentId: string;
+        paymentRequestUrl: string;
+    }>;
+    createConektaPayment(orderId: string): Promise<{
+        checkoutRequestId: string;
+    }>;
+    createKushkiPayment(orderId: string, token: string): Promise<{
+        paymentId: string;
+    }>;
+    createKushkiBankPayment(orderId: string): Promise<any>;
+    createSPEIPayment(orderId: string): Promise<any>;
+    createSPIDPayment(orderId: string): Promise<any>;
+    createSWIFTPayment(orderId: string): Promise<any>;
+    createInterbankPayment(orderId: string): Promise<any>;
+    updateAuth(update: AuthUpdate, id?: string): Promise<Auth>;
+}

package/build/clients/rio-client.js

@@ -0,0 +1,315 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RioClient = void 0;
+class RioClient {
+    constructor(axios) {
+        this.axios = axios;
+    }
+    getOrders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get(`/api/orders`);
+            return data;
+        });
+    }
+    getUsers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get(`/api/users`);
+            return data;
+        });
+    }
+    getBusinessUsers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get(`/api/business/users`);
+            return data;
+        });
+    }
+    signin(email, password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/admin/signin`, {
+                email,
+                password,
+            });
+            return data;
+        });
+    }
+    updateUser(update, userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.patch(`/api/users/${userId}`, update);
+            return data;
+        });
+    }
+    updateBusinessUser(update, businessUserId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.patch(`/api/business/users/${businessUserId}`, update);
+            return data;
+        });
+    }
+    updateAdminUserPassword({ password, newPassword, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.patch(`/api/admin`, {
+                password,
+                newPassword,
+            });
+            return data;
+        });
+    }
+    getAdminUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get(`/api/admin`);
+            return data;
+        });
+    }
+    signoutAdmin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post("/api/admin/signout", {});
+        });
+    }
+    getRioSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get(`/api/settings`);
+            return data;
+        });
+    }
+    createRioSettings(rioSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post(`/api/settings`, rioSettings);
+        });
+    }
+    updateRioSettings(update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.patch(`/api/settings`, update);
+            return data;
+        });
+    }
+    confirmBankPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/bank/confirm`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    getUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get("/api/users/current");
+            return data;
+        });
+    }
+    getBusinessUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get("/api/business/users/current");
+            return data;
+        });
+    }
+    createUser(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post("/api/users/current-auth", user);
+        });
+    }
+    createBusinessUser(businessUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post("/api/business/users/current-auth", businessUser);
+            return response.data;
+        });
+    }
+    createBrokerCustomer(businessUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post("/api/business/users/broker-customers/current-auth", businessUser);
+            return response.data;
+        });
+    }
+    sendPhoneAuthCode(phoneNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post("/api/auth/sendCode", {
+                phoneNumber,
+            });
+        });
+    }
+    authExists(phoneNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post("/api/auth/exists", {
+                phoneNumber,
+            });
+            return response.data.exists;
+        });
+    }
+    uploadCOI(businessUserId, formData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.patch(`/api/business/users/${businessUserId}/coi`, formData);
+            return data;
+        });
+    }
+    uploadKYCReport(businessUserId, formData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.patch(`/api/business/users/${businessUserId}/kyc-report`, formData);
+            return data;
+        });
+    }
+    getSecurityQuestion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get("/api/auth/security-question", {});
+            return response.data.question;
+        });
+    }
+    signout() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post("/api/auth/signout", {});
+        });
+    }
+    verifyPhoneCode(phoneNumber, code) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post("/api/auth/verifycode", {
+                phoneNumber,
+                code,
+            });
+        });
+    }
+    createAuth(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post("/api/auth", {
+                password,
+            });
+        });
+    }
+    createOrder(order) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post("/api/orders", order);
+            return response.data;
+        });
+    }
+    getOrder(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`/api/orders/${id}`);
+            return response.data;
+        });
+    }
+    initBankPayout(oid, accountNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(`/api/payouts/bank`, {
+                orderId: oid,
+                accountNumber,
+            });
+            return response.data;
+        });
+    }
+    getBankPayout(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`/api/payouts/bank?orderId=${orderId}`);
+            return response.data;
+        });
+    }
+    checkAddress(address, crypto) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.post(`/api/kyt/address`, {
+                address,
+                crypto,
+            });
+            return response.data;
+        });
+    }
+    getSupportedPaymentMethods(fiat, country) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`/api/payment-methods/supported?fiat=${fiat}&country=${country}`);
+            return response.data;
+        });
+    }
+    getBrokerCustomers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`/api/business/users/broker-customers`);
+            return response.data;
+        });
+    }
+    getSupportedPayoutMethods(fiat, country) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.axios.get(`/api/payout-methods/supported?fiat=${fiat}&country=${country}`);
+            return response.data;
+        });
+    }
+    getPartnerLayout(partnerId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.get(`/api/partners/${partnerId}/layout`);
+            return data;
+        });
+    }
+    createClipCardPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/card/clip`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    createConektaPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/card/conekta`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    createKushkiPayment(orderId, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/card/kushki`, {
+                orderId,
+                token,
+            });
+            return data;
+        });
+    }
+    createKushkiBankPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/bank/kushki`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    createSPEIPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/bank/spei`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    createSPIDPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/bank/spid`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    createSWIFTPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/bank/swift`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    createInterbankPayment(orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.post(`/api/payments/bank/interbank`, {
+                orderId,
+            });
+            return data;
+        });
+    }
+    updateAuth(update, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data } = yield this.axios.patch(`/api/auth/${id}`, update);
+            return data;
+        });
+    }
+}
+exports.RioClient = RioClient;

package/build/clients/slack-client.d.ts

@@ -0,0 +1,7 @@
+declare class SlackClient {
+    private webhookUrl;
+    constructor(webhookUrl: string);
+    sendMessage(message: string): Promise<void>;
+}
+export declare const slackClient: SlackClient;
+export {};

package/build/clients/slack-client.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slackClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class SlackClient {
+    constructor(webhookUrl) {
+        this.webhookUrl = webhookUrl;
+    }
+    sendMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield axios_1.default.post(this.webhookUrl, {
+                    text: message,
+                });
+            }
+            catch (error) {
+                console.log(error);
+            }
+        });
+    }
+}
+exports.slackClient = new SlackClient(process.env.SLACK_WEBHOOK_URL);

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressCheckFailed = void 0;
+const custom_error_1 = require("./custom-error");
+class AddressCheckFailed extends custom_error_1.CustomError {
+    constructor() {
+        super("Address check failed");
+        this.statusCode = 400;
+        Object.setPrototypeOf(this, AddressCheckFailed.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Address check failed" }];
+    }
+}
+exports.AddressCheckFailed = AddressCheckFailed;

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminAlreadyExistsError = void 0;
+const custom_error_1 = require("./custom-error");
+class AdminAlreadyExistsError extends custom_error_1.CustomError {
+    constructor() {
+        super("Admin with provided email already exists");
+        this.statusCode = 409;
+        Object.setPrototypeOf(this, AdminAlreadyExistsError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Admin with provided email already exists" }];
+    }
+}
+exports.AdminAlreadyExistsError = AdminAlreadyExistsError;

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminNotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class AdminNotFoundError extends custom_error_1.CustomError {
+    constructor() {
+        super("Admin not found");
+        this.statusCode = 404;
+        Object.setPrototypeOf(this, AdminNotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: "Admin not found" }];
+    }
+}
+exports.AdminNotFoundError = AdminNotFoundError;