@riocrypto/common 1.0.504 → 1.0.507

package/build/models/bank-payout.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBankPayout = void 0;
-const buildBankPayout = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.BankPayout) {
-        return mongoose.model("BankPayout");
-    }
-    const BankPayoutSchema = new mongoose.Schema({
-        orderId: {
-            type: String,
-            required: true,
-        },
-        originBank: {
-            type: String,
-            required: true,
-        },
-        accountNumber: {
-            type: String,
-            required: true,
-        },
-        status: {
-            type: String,
-            required: true,
-        },
-        destinationBank: {
-            type: String,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id.valueOf();
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    BankPayoutSchema.statics.build = (attrs) => {
-        return new BankPayout(attrs);
-    };
-    const BankPayout = mongoose.model("BankPayout", BankPayoutSchema);
-    return BankPayout;
-};
-exports.buildBankPayout = buildBankPayout;

package/build/models/business-user.d.ts

@@ -1,57 +0,0 @@
-import { Country } from "../types/country";
-import { KYCStatus } from "../types/kyc-status";
-import { Language } from "../types/language";
-import { PlatformFeeRange } from "../types/platform-fee-range";
-import { USState } from "../types/us-state";
-import { UserAttribute } from "../types/user-attribute";
-import { UserType } from "../types/user-type";
-import { Mongoose, Model, Document } from "mongoose";
-interface BusinessUserAttrs {
-    authId?: string;
-    type: UserType;
-    companyName: string;
-    legalRepresentative: string;
-    phoneNumber: string;
-    email: string;
-    street1: string;
-    street2?: string;
-    city: string;
-    state: USState | string;
-    postalCode: string;
-    country: Country;
-    kycStatus: KYCStatus;
-    COIFile?: string;
-    KYCReportFile?: string;
-    cpf?: string;
-    language?: Language;
-    attributes?: UserAttribute[];
-    brokerId?: string;
-    platformFeeRanges?: PlatformFeeRange[];
-}
-interface BusinessUserModel extends Model<BusinessUserDoc> {
-    build(attrs: BusinessUserAttrs): BusinessUserDoc;
-}
-interface BusinessUserDoc extends Document {
-    authId?: string;
-    type: UserType;
-    companyName: string;
-    legalRepresentative: string;
-    phoneNumber: string;
-    email: string;
-    street1: string;
-    street2?: string;
-    city: string;
-    state: USState | string;
-    postalCode: string;
-    country: Country;
-    kycStatus: KYCStatus;
-    COIFile?: string;
-    KYCReportFile?: string;
-    cpf?: string;
-    language?: Language;
-    attributes?: UserAttribute[];
-    brokerId?: string;
-    platformFeeRanges?: PlatformFeeRange[];
-}
-declare const buildBusinessUser: (mongoose: Mongoose) => BusinessUserModel;
-export { buildBusinessUser, BusinessUserDoc };

package/build/models/business-user.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildBusinessUser = void 0;
-const buildBusinessUser = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.BusinessUser) {
-        return mongoose.model("BusinessUser");
-    }
-    const BusinessUserSchema = new mongoose.Schema({
-        authId: {
-            type: String,
-        },
-        type: {
-            type: String,
-            required: true,
-        },
-        companyName: {
-            type: String,
-            required: true,
-        },
-        legalRepresentative: {
-            type: String,
-            required: true,
-        },
-        phoneNumber: {
-            type: String,
-            required: true,
-        },
-        email: {
-            type: String,
-            required: true,
-        },
-        street1: {
-            type: String,
-            required: true,
-        },
-        street2: {
-            type: String,
-        },
-        city: {
-            type: String,
-            required: true,
-        },
-        state: {
-            type: String,
-            required: true,
-        },
-        postalCode: {
-            type: String,
-            required: true,
-        },
-        country: {
-            type: String,
-            required: true,
-        },
-        language: {
-            type: String,
-        },
-        cpf: {
-            type: String,
-        },
-        attributes: [
-            {
-                type: String,
-            },
-        ],
-        kycStatus: {
-            type: String,
-            required: true,
-        },
-        COIFile: {
-            type: String,
-        },
-        KYCReportFile: {
-            type: String,
-        },
-        brokerId: {
-            type: String,
-        },
-        platformFeeRanges: [
-            {
-                min: {
-                    type: Number,
-                    required: true,
-                },
-                max: {
-                    type: Number,
-                    required: true,
-                },
-                fee: {
-                    type: Number,
-                    required: true,
-                },
-            },
-        ],
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id.valueOf();
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    BusinessUserSchema.statics.build = (attrs) => {
-        return new BusinessUser(attrs);
-    };
-    const BusinessUser = mongoose.model("BusinessUser", BusinessUserSchema);
-    return BusinessUser;
-};
-exports.buildBusinessUser = buildBusinessUser;

package/build/models/ccxt-order.d.ts

@@ -1,16 +0,0 @@
-import mongoose from "mongoose";
-interface CCXTOrderAttrs {
-    orderId: string;
-    ccxtId: string;
-    status: string;
-}
-interface CCXTOrderDoc extends mongoose.Document {
-    orderId: string;
-    status: string;
-    ccxtId: string;
-}
-interface CCXTOrderModel extends mongoose.Model<CCXTOrderDoc> {
-    build(attrs: CCXTOrderAttrs): CCXTOrderDoc;
-}
-declare const buildCCXTOrder: (mongoose: typeof mongoose) => CCXTOrderModel;
-export { buildCCXTOrder, CCXTOrderDoc };

package/build/models/ccxt-order.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildCCXTOrder = void 0;
-const buildCCXTOrder = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.CCXTOrder) {
-        return mongoose.model("CCXTOrder");
-    }
-    const CCXTOrderSchema = new mongoose.Schema({
-        orderId: {
-            type: String,
-            required: true,
-        },
-        ccxtId: {
-            type: String,
-            required: true,
-        },
-        status: {
-            type: String,
-            required: true,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id;
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    CCXTOrderSchema.statics.build = (attrs) => {
-        return new CCXTOrder(attrs);
-    };
-    const CCXTOrder = mongoose.model("CCXTOrder", CCXTOrderSchema);
-    return CCXTOrder;
-};
-exports.buildCCXTOrder = buildCCXTOrder;

package/build/models/checked-address.d.ts

@@ -1,17 +0,0 @@
-import mongoose from "mongoose";
-import { AddressCheckResult } from "../types/address-check-result";
-interface CheckedAddressAttrs {
-    address: string;
-    result: AddressCheckResult;
-    lastChecked: Date;
-}
-interface CheckedAddressDoc extends mongoose.Document {
-    address: string;
-    result: AddressCheckResult;
-    lastChecked: Date;
-}
-interface CheckedAddressModel extends mongoose.Model<CheckedAddressDoc> {
-    build(attrs: CheckedAddressAttrs): CheckedAddressDoc;
-}
-declare const buildCheckedAddress: (mongoose: typeof mongoose) => CheckedAddressModel;
-export { buildCheckedAddress, CheckedAddressDoc };

package/build/models/checked-address.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildCheckedAddress = void 0;
-const buildCheckedAddress = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.CheckedAddress) {
-        return mongoose.model("CheckedAddress");
-    }
-    const CheckedAddressSchema = new mongoose.Schema({
-        address: {
-            type: String,
-            required: true,
-        },
-        result: {
-            type: String,
-            required: true,
-        },
-        lastChecked: {
-            type: mongoose.Schema.Types.Date,
-            required: true,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id;
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    CheckedAddressSchema.statics.build = (attrs) => {
-        return new CheckedAddress(attrs);
-    };
-    const CheckedAddress = mongoose.model("CheckedAddress", CheckedAddressSchema);
-    return CheckedAddress;
-};
-exports.buildCheckedAddress = buildCheckedAddress;

package/build/models/kushki-payment.d.ts

@@ -1,16 +0,0 @@
-import mongoose from "mongoose";
-interface KushkiPaymentAttrs {
-    orderId: string;
-    kushkiTransactionReference: string;
-    status: string;
-}
-interface KushkiPaymentDoc extends mongoose.Document {
-    orderId: string;
-    status: string;
-    kushkiTransactionReference: string;
-}
-interface KushkiPaymentModel extends mongoose.Model<KushkiPaymentDoc> {
-    build(attrs: KushkiPaymentAttrs): KushkiPaymentDoc;
-}
-declare const buildKushkiPayment: (mongoose: typeof mongoose) => KushkiPaymentModel;
-export { buildKushkiPayment, KushkiPaymentDoc };

package/build/models/kushki-payment.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildKushkiPayment = void 0;
-const buildKushkiPayment = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.KushkiPayment) {
-        return mongoose.model("KushkiPayment");
-    }
-    const KushkiPaymentSchema = new mongoose.Schema({
-        orderId: {
-            type: String,
-            required: true,
-        },
-        kushkiTransactionReference: {
-            type: String,
-            required: true,
-        },
-        status: {
-            type: String,
-            required: true,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id;
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    KushkiPaymentSchema.statics.build = (attrs) => {
-        return new KushkiPayment(attrs);
-    };
-    const KushkiPayment = mongoose.model("KushkiPayment", KushkiPaymentSchema);
-    return KushkiPayment;
-};
-exports.buildKushkiPayment = buildKushkiPayment;

package/build/models/kyc.d.ts

@@ -1,20 +0,0 @@
-import mongoose from "mongoose";
-interface KYCAttrs {
-    userId: string;
-    provider: string;
-    providerId: string;
-    result: string;
-    lastChecked: Date;
-}
-interface KYCDoc extends mongoose.Document {
-    userId: string;
-    provider: string;
-    providerId: string;
-    result: string;
-    lastChecked: Date;
-}
-interface KYCModel extends mongoose.Model<KYCDoc> {
-    build(attrs: KYCAttrs): KYCDoc;
-}
-declare const buildKYC: (mongoose: typeof mongoose) => KYCModel;
-export { buildKYC, KYCDoc };

package/build/models/kyc.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildKYC = void 0;
-const buildKYC = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.KYC) {
-        return mongoose.model("KYC");
-    }
-    const KYCSchema = new mongoose.Schema({
-        userId: {
-            type: String,
-            required: true,
-        },
-        provider: {
-            type: String,
-            required: true,
-        },
-        providerId: {
-            type: String,
-            required: true,
-        },
-        result: {
-            type: String,
-            required: true,
-        },
-        lastChecked: {
-            type: mongoose.Schema.Types.Date,
-            required: true,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id;
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    KYCSchema.statics.build = (attrs) => {
-        return new KYC(attrs);
-    };
-    const KYC = mongoose.model("KYC", KYCSchema);
-    return KYC;
-};
-exports.buildKYC = buildKYC;

package/build/models/order.d.ts

@@ -1,67 +0,0 @@
-import { Country } from "../types/country";
-import { Fees } from "../types/fees";
-import { Fiat } from "../types/fiat";
-import { LiquidityProvider } from "../types/liquidity-provider";
-import { OrderStatus } from "../types/order-status";
-import { PaymentMethod } from "../types/payment-method";
-import { PayoutMethod } from "../types/payout-method";
-import { Processor } from "../types/processor";
-import { Side } from "../types/side";
-import { USState } from "../types/us-state";
-import { Crypto } from "../types/crypto";
-import { Mongoose, Model, Document } from "mongoose";
-interface OrderAttrs {
-    userId: string;
-    crypto: Crypto;
-    side: Side;
-    fiat: Fiat;
-    paymentMethod?: PaymentMethod;
-    payoutMethod?: PayoutMethod;
-    createdAt: Date;
-    status: OrderStatus;
-    cryptoAddress: string;
-    country: Country;
-    state: USState | string;
-    amountFiat?: number;
-    amountCrypto?: number;
-    liquidityProvider?: LiquidityProvider;
-    processor?: Processor;
-    fees?: Fees;
-    price?: number;
-    partnerId?: string;
-    depositAddress?: string;
-    depositTxId?: string;
-    withdrawalTxId?: string;
-    addressVerified?: boolean;
-    brokerCustomerId?: string;
-}
-interface OrderDoc extends Document {
-    userId: string;
-    status: OrderStatus;
-    crypto: Crypto;
-    side: Side;
-    fiat: Fiat;
-    paymentMethod?: PaymentMethod;
-    payoutMethod?: PayoutMethod;
-    createdAt: Date;
-    country: Country;
-    state: USState | string;
-    cryptoAddress: string;
-    amountFiat?: number;
-    amountCrypto?: number;
-    liquidityProvider?: LiquidityProvider;
-    processor?: Processor;
-    fees?: Fees;
-    price?: number;
-    partnerId?: string;
-    depositAddress?: string;
-    depositTxId?: string;
-    withdrawalTxId?: string;
-    addressVerified?: boolean;
-    brokerCustomerId?: string;
-}
-interface OrderModel extends Model<OrderDoc> {
-    build(attrs: OrderAttrs): OrderDoc;
-}
-declare const buildOrder: (mongoose: Mongoose) => OrderModel;
-export { buildOrder, OrderDoc };

package/build/models/order.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOrder = void 0;
-const buildOrder = (mongoose) => {
-    // if model is already defined, return it
-    if (mongoose.models.Order) {
-        return mongoose.model("Order");
-    }
-    const orderSchema = new mongoose.Schema({
-        userId: {
-            type: String,
-            required: true,
-        },
-        status: {
-            type: String,
-            required: true,
-        },
-        crypto: {
-            type: String,
-            required: true,
-        },
-        side: {
-            type: String,
-            required: true,
-        },
-        fiat: {
-            type: String,
-            required: true,
-        },
-        paymentMethod: {
-            type: String,
-        },
-        payoutMethod: {
-            type: String,
-        },
-        createdAt: {
-            type: mongoose.Schema.Types.Date,
-            required: true,
-        },
-        cryptoAddress: {
-            type: String,
-            required: true,
-        },
-        country: {
-            type: String,
-            required: true,
-        },
-        state: {
-            type: String,
-            required: true,
-        },
-        amountFiat: {
-            type: Number,
-        },
-        amountCrypto: {
-            type: Number,
-        },
-        processor: {
-            type: String,
-        },
-        liquidityProvider: {
-            type: String,
-        },
-        depositTxId: {
-            type: String,
-        },
-        withdrawalTxId: {
-            type: String,
-        },
-        depositAddress: {
-            type: String,
-        },
-        fees: {
-            processingFeeCrypto: {
-                type: Number,
-            },
-            transferFeeCrypto: {
-                type: Number,
-            },
-            platformFeeCrypto: {
-                type: Number,
-            },
-            processingFeeFiat: {
-                type: Number,
-            },
-            transferFeeFiat: {
-                type: Number,
-            },
-            platformFeeFiat: {
-                type: Number,
-            },
-            partnerFeeFiat: {
-                type: Number,
-            },
-        },
-        price: {
-            type: Number,
-        },
-        partnerId: {
-            type: String,
-        },
-        addressVerified: {
-            type: Boolean,
-        },
-        brokerCustomerId: {
-            type: String,
-        },
-    }, {
-        toJSON: {
-            transform(doc, ret) {
-                ret.id = ret._id.valueOf();
-                delete ret._id;
-                delete ret.__v;
-            },
-        },
-    });
-    orderSchema.statics.build = (attrs) => {
-        return new Order(attrs);
-    };
-    const Order = mongoose.model("Order", orderSchema);
-    return Order;
-};
-exports.buildOrder = buildOrder;

package/build/models/partner.d.ts

@@ -1,35 +0,0 @@
-import { PartnerStatus } from "../types/partner-status";
-import { Mongoose, Document, Model } from "mongoose";
-interface PartnerAttrs {
-    authId: string;
-    name: string;
-    status: PartnerStatus;
-    partnerFee: number;
-    platformFee: number;
-    color?: string;
-    logo?: string;
-    apiKeys?: {
-        value: string;
-        label: string;
-        id: string;
-    }[];
-}
-interface PartnerDoc extends Document {
-    authId: string;
-    name: string;
-    status: PartnerStatus;
-    partnerFee: number;
-    platformFee: number;
-    color?: string;
-    logo?: string;
-    apiKeys?: {
-        value: string;
-        label: string;
-        id: string;
-    }[];
-}
-interface PartnerModel extends Model<PartnerDoc> {
-    build(attrs: PartnerAttrs): PartnerDoc;
-}
-declare const buildPartner: (mongoose: Mongoose) => PartnerModel;
-export { buildPartner, PartnerDoc };