@dynamatix/gb-schemas 0.0.2

package/applications/application-note.model.js

@@ -0,0 +1,76 @@
+import mongoose from "mongoose";
+
+const noteSchema = new mongoose.Schema({
+    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
+    noteId: {
+        type: String,
+        required: true
+    },
+    createdOn: {
+        type: Date,
+        required: true
+    },
+    createdBy: {
+        type: Number,
+        required: true
+    },
+    createdByUserId: {
+        type: mongoose.Schema.Types.ObjectId, ref: "User",
+    },
+    TypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
+    SubTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
+    subject: {
+        type: String,
+        required: true
+    },
+    note: {
+        type: String,
+        required: true
+    },
+    reminderDate: {
+        type: Date,
+        default: null
+    },
+    attachmentDocumentId: {
+        type: String,
+        default: null
+    },
+    assignedOperation: {
+        type: String,
+        default: ''
+    },
+    autoCreated: {
+        type: Boolean,
+        default: false
+    },
+    additionalData: {
+        type: mongoose.Schema.Types.Mixed,
+        default: null
+    },
+    autoCreatedId: {
+        type: String,
+        default: null
+    },
+    assignedTo: {
+        type: String,
+        default: ''
+    },
+    assignedBy: {
+        type: Number,
+        default: null
+    },
+    assignedByUserId: {
+        type: mongoose.Schema.Types.ObjectId, ref: "User",
+    },
+    comment: {
+        type: String,
+        required: false
+    },
+    reminderStatus: {
+        type: String,
+        default: 'None'
+    },
+});
+
+const ApplictionNoteModel = mongoose.model("ApplictionNote", noteSchema);
+export default ApplictionNoteModel;

package/applications/application-offer.model.js

@@ -0,0 +1,7 @@
+import mongoose from "mongoose";
+
+const offerSchema = new mongoose.Schema({
+  date: { type: Date } // The date associated with the offer
+});
+const OfferModel = mongoose.model("Offer", offerSchema);
+export default OfferModel;

package/applications/application-onboarding.model.js

@@ -0,0 +1,10 @@
+import mongoose from "mongoose";
+
+const onboardingSchema = new mongoose.Schema({
+  errors: { type: String, default: "" }, 
+  status: { type: String, default: "" }, 
+  statusDate: { type: Date },
+  warnings: { type: String, default: "" } 
+});
+const OnboardingModel = mongoose.model("Onboarding", onboardingSchema);
+export default OnboardingModel;

package/applications/application-product.model.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+
+const productSchema = new mongoose.Schema({
+  numberOfYearsToRepay: { type: Number, default: 0 }, 
+  productFeePaymentType: { type: String, default: "" }, 
+  selectedProduct: { type: String, default: "" } 
+});
+
+const ProductModel = mongoose.model("Product", productSchema);
+
+export default ProductModel;

package/applications/application-rational.model.js

@@ -0,0 +1,20 @@
+import mongoose from "mongoose";
+
+const rationaleSchema = new mongoose.Schema({
+  affordabilityDescription: { type: String, default: "" }, 
+  affordabilityStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true }, 
+  applicantsDescription: { type: String, default: "" }, 
+  applicantsStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true }, 
+  creditConductDescription: { type: String, default: "" }, 
+  creditConductStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true }, 
+  fraudCheckDescription: { type: String, default: "" },
+  fraudCheckStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true }, 
+  incomeSourceDescription: { type: String, default: "" }, 
+  incomeSourceStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+  loanDescription: { type: String, default: "" },
+  loanStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+  securityDescription: { type: String, default: "" }, 
+  securityStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true } 
+});
+const RationaleModel = mongoose.model("Rationale", rationaleSchema);
+export default RationaleModel;

package/applications/application-valuation.model.js

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+
+const valuationSchema = new mongoose.Schema({
+  amount: { type: Number }, 
+  epcRating: { type: String, default: "" },
+  epcScore: { type: Number }, 
+  estimatedRentalValue: { type: Number }, 
+  instructionId: { type: String, default: "" }, 
+  instructionStatus: { type: String, default: "" },
+  instructionStatusComment: { type: String, default: "" },
+  isManual: { type: Boolean, default: false },
+  squareMetres: { type: Number }, 
+  valuerNotes: { type: String, default: "" }, 
+  version: { type: String, default: "" } 
+});
+const ValuationModel = mongoose.model("Valuation", valuationSchema);
+export default ValuationModel;

package/applications/application.model.js

@@ -0,0 +1,69 @@
+import mongoose from "mongoose";
+import mortgageSchema from "./application-mortgage.model.js";
+
+const applicationSchema = new mongoose.Schema(
+    {
+        queueID: [{
+            type: mongoose.Schema.Types.ObjectId,
+            ref: "Queue",
+            required: true,
+        }],
+        assignedToUserId: { type: mongoose.Schema.Types.ObjectId, ref: "User" },
+        applicationId: { type: String, required: true },
+        isApplicationFeePaid: { type: Boolean, required: true },
+        applicationNumber: { type: String, required: true },
+        applicationTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+        bankSolicitor: { type: String, default: "" },
+        brokerId: { type: mongoose.Schema.Types.ObjectId, ref: "Broker", required: true },
+        brokerName: { type: String }, // Broker name field added
+        caseManager: { type: String, default: "" },
+        caseManagerAccepted: { type: Boolean, default: false },
+        completedReason: { type: String, default: "" },
+        isIntendToOccupy: { type: Boolean, required: true },
+        introducer: { type: String, default: "" },
+        isIntroducerSubmission: { type: Boolean, required: true },
+        isBrokerAssigned: { type: Boolean, default: false },
+        isFinanceRecommendedToApplicant: { type: Boolean, required: true },
+        isWorkflowTaskCreated: { type: Boolean, required: true },
+        lastUpdated: { type: Date },
+        lendingTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+        networkClubName: { type: String, default: "" },
+        isNetworkClubSubmission: { type: Boolean, required: true },
+        newReason: { type: String, default: "" },
+        purchaseTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+        rejectedReason: { type: String, default: "" },
+        repaymentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+        selectedProduct: { type: String, required: true },
+        sourceOfWealthLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+        sowBusiness: { type: String, default: "" },
+        sowInheritance: { type: String, default: "" },
+        sowOther: { type: String, default: "" },
+        sowProperty: { type: String, default: "" },
+        sowSalary: { type: String, default: "" },
+        statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+        submitReason: { type: String, default: "" },
+        submittedDate: { type: Date },
+        underwriter: { type: String, default: "" },
+        isValuationFeePaid: { type: Boolean, required: true },
+        withdrawalReason: { type: String, default: "" },
+        withdrawalReasonCode: { type: String, default: "" },
+        productId: { type: mongoose.Schema.Types.ObjectId, ref: "Product", required: true },
+        product: { type: String },
+        propertyId: { type: mongoose.Schema.Types.ObjectId, ref: "Property", required: true },
+        solicitorId: { type: mongoose.Schema.Types.ObjectId, ref: "Solicitor", required: true },
+        applicants: [
+            { type: mongoose.Schema.Types.ObjectId, ref: "Applicant" }
+        ],
+        statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+        submittedDate: { type: Date },
+        isValuationFeePaid: { type: Boolean, required: true },
+        isActive: { type: Boolean, default: false },
+        isUkResident: { type: Boolean, default: true },
+        riskRating: { type: String },
+        mortgage: mortgageSchema
+    },
+    { timestamps: true }
+);
+
+const ApplicationModel = mongoose.model("Application", applicationSchema);
+export default ApplicationModel;

package/applications/broker.model.js

@@ -0,0 +1,25 @@
+import mongoose from "mongoose";
+
+const brokerSchema = new mongoose.Schema({
+    brokerID: { type: Number },
+    landlinePhone: { type: String },
+    mobileTelephone: { type: String },
+    addressPostCode: { type: String },
+    addressLine1: { type: String },
+    addressLine2: { type: String },
+    addressLine3: { type: String },
+    addressCity: { type: String },
+    addressCountry: { type: String },
+    tradingName: { type: String },
+    fcaNumber: { type: String },
+    brokerType: { type: String },
+    email: { type: String },
+    network: { type: String },
+    firstName: { type: String },
+    lastName: { type: String }
+},
+    { timestamps: true });
+
+
+const BrokerModel = mongoose.model("Broker", brokerSchema);
+export default BrokerModel;

package/applications/document.model.js

@@ -0,0 +1,37 @@
+import mongoose from "mongoose";
+
+const documentSchema = new mongoose.Schema({
+    applicationId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Application",
+        required: false,
+    },
+    documentId: { type: String, required: true },
+    owningEntityId: { type: String, required: false },
+    documentTypeLid: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Lookup",
+        required: false,
+    },
+    documentTypeId: { type: Number, required: false },
+    fileName: { type: String, required: false },
+    contentType: { type: String, required: false },
+    created: { type: Date, required: false },
+    createdBy: { type: Number, required: false },
+    isGenerated: { type: Boolean, required: false },
+    data: { type: String, required: false },
+    envelopeId: { type: String, required: false },
+    signers: { type: Array, default: [] },
+    documentType: {
+        documentTypeId: { type: Number, required: false },
+        displayName: { type: String, required: false },
+        value: { type: String, required: false },
+        data: { type: Object, required: false },
+    },
+    documentUrl: { type: String, required: false },
+}, {
+    timestamps: true
+});
+
+const DocumentModel = mongoose.model("Document", documentSchema);
+export default DocumentModel;

package/applications/productfeatures.model.js

@@ -0,0 +1,100 @@
+import mongoose from "mongoose";
+
+const feeSchema = new mongoose.Schema({
+    feeType: { type: String, required: true },
+    description: { type: String, required: true },
+    feeAmount: { type: Number, required: true },
+    rate: { type: Number, default: 0 },
+    addedToLoan: { type: Boolean, default: false },
+    allowOverride: { type: Boolean, default: false },
+    additionalData: { type: mongoose.Schema.Types.Mixed, default: null }
+});
+
+const cashflowPeriodSchema = new mongoose.Schema({
+    from: { type: Number, default: null },
+    to: { type: Number, default: null },
+    instalmentAmount: { type: Number, default: null },
+    instalmentInterest: { type: Number, default: null },
+    instalmentCapitalRepaid: { type: Number, default: null },
+    otherCosts: { type: Number, default: 0 },
+    outstandingCapital: { type: Number, default: null }
+});
+
+const calculationsSchema = new mongoose.Schema({
+    ltv: { type: Number, default: null },
+    rentalCoverageRatioRate: { type: Number, default: null },
+    bankContributionRate: { type: Number, default: null },
+    bankInitialShareRate: { type: Number, default: null },
+    totalAmountPayable: { type: Number, default: null },
+    fixedMonthlyPayment: { type: Number, default: null },
+    fixedMonthlyCapital: { type: Number, default: null },
+    fixedMonthlyInterest: { type: Number, default: null },
+    variableMonthlyPayment: { type: Number, default: null },
+    summaryTotal: { type: Number, default: null },
+    reimbursementPerPound: { type: Number, default: null },
+    stressedPayment: { type: Number, default: null },
+    stressedPaymentRate: { type: Number, default: null },
+    rentalCoverage: { type: Number, default: null },
+    rentalCoverageWithoutTopUp: { type: Number, default: null }
+});
+
+const productFeaturesSchema = new mongoose.Schema({
+    name: { type: String, required: true },
+    clientAdvance: { type: Number, required: true },
+    ltv: { type: Number, required: true },
+    repayment: { type: Number, required: true },
+    variableRepayment: { type: Number, required: true },
+    reversionRateWithoutBaseRate: { type: Number, default: null },
+    totalReversionRate: { type: Number, default: null },
+    initialRate: { type: Number, required: true },
+    fixedTerm: { type: Number, required: true },
+    fixedTermEndDate: { type: Date, default: null },
+    baseRate: { type: Number, default: null },
+    productRate: { type: Number, default: null },
+    apr: { type: Number, default: null },
+    rentalCoverage: { type: Number, default: null },
+    repaymentType: { type: String, default: null },
+    applicationCategory: { type: String, default: null },
+    securityType: { type: String, default: null },
+    erc: { type: String, default: null },
+    loanType: { type: String, default: null },
+    maxLtvLimit: { type: String, default: null },
+    reimbursement: { type: Number, default: null },
+    reimbursementPerPound: { type: Number, default: null },
+    stressedApr: { type: Number, default: null },
+    stressedRate: { type: Number, default: null },
+    stressedRepayment: { type: Number, default: null },
+    liborFloorRate: { type: String, default: null },
+    totalTermInMonths: { type: Number, default: null },
+    chargeType: { type: String, default: '' },
+    productCategory: { type: String, default: '' },
+    ercCode: { type: String, default: '' },
+    variableTerm: { type: Number, default: null },
+    totalFeePayable: { type: Number, default: null },
+    dipIssueDate: { type: Date, default: null },
+    estimatedCompletionDate: { type: Date, default: null },
+    dipExpiryDate: { type: Date, default: null },
+    fixedRepaymentUntillDate: { type: Date, default: null },
+    rentalReviewDate: { type: Date, default: null },
+    totalReimbursementWithFee: { type: Number, default: null },
+    finalRentPayment: { type: Number, default: null },
+    clientDeposit: { type: Number, default: null },
+    firstRentPayment: { type: Number, default: null },
+    fees: [feeSchema],
+    ercFeatures: { type: mongoose.Schema.Types.Mixed, default: null },
+    cashflowPeriods: {
+        totalNoOfPayments: { type: Number, default: null },
+        fixed: cashflowPeriodSchema,
+        variable: cashflowPeriodSchema,
+        total: cashflowPeriodSchema
+    },
+    icr: { type: String, default: null },
+    ufssProductCode: { type: String, default: null },
+    ufssInterestRateCode: { type: String, default: null },
+    stressedPayment: { type: Number, default: null },
+    stressedPaymentRate: { type: Number, default: null },
+    calculations: calculationsSchema
+});
+
+const ProductFeaturesModel = mongoose.model("ProductFeatures", productFeaturesSchema);
+export default ProductFeaturesModel;

package/applications/solicitor.model.js

@@ -0,0 +1,35 @@
+import mongoose from "mongoose";
+
+const Schema = mongoose.Schema;
+
+const solicitorSchema = new Schema({
+    dualRep: { type: Boolean, default: false },
+    isSraApprovedManagers: { type: Boolean, default: true },
+    pageValidFlag: { type: Boolean, default: true },
+    solicitorsList: { type: String},
+    useExistingSolicitor: { type: Boolean, default: true },
+    accountNumber: { type: String},
+    addressCity: { type: String},
+    addressCountryLID: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
+    addressLine1: { type: String, },
+    addressLine2: { type: String },
+    addressLine3: { type: String },
+    addressPostCode: { type: String, },
+    bankAddressLine1: { type: String, },
+    bankAddressLine2: { type: String },
+    bankBranch: { type: String,  },
+    bankCity: { type: String,  },
+    contactPostcode: { type: String,  },
+    email: { type: String },
+    institution: { type: String },
+    isActive: { type: Boolean, default: true },
+    nameOfAccountHolder: { type: String },
+    nameOfFirm: { type: String},
+    signatory: { type: String},
+    solicitorActing: { type: String},
+    sortCode: { type: String, },
+    telephone: { type: String,},
+});
+
+const SolicitorModel = mongoose.model("Solicitor", solicitorSchema);
+export default SolicitorModel;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@dynamatix/gb-schemas",
+  "version": "0.0.2",
+  "description": "All the schemas for gatehouse bank back-end.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DynamatixAnalyticsPvtLtd/gb-schemas.git"
+  },
+  "author": "Dynamatix",
+  "type": "module",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/DynamatixAnalyticsPvtLtd/gb-schemas/issues"
+  },
+  "homepage": "https://github.com/DynamatixAnalyticsPvtLtd/gb-schemas#readme",
+  "dependencies": {
+    "mongoose": "^8.9.5"
+  }
+}

package/properties/property.model.js

@@ -0,0 +1,99 @@
+import mongoose from "mongoose";
+
+const dataStreetSchema = new mongoose.Schema({
+    floorArea: { type: String, default: '' },
+    propertyType: { type: String, default: '' },
+    noOfBedrooms: { type: Number, default: 0 },
+    noOfBathrooms: { type: Number, default: 0 },
+    lats: { type: String, },
+    longs: { type: String,  },
+    lmkKey: { type: String, default: '' },
+    matchConfidence: { type: Number, default: 0 },
+    transactions:[{
+        transactionDate: String,
+        epc: String,
+        price: String,
+        isNewBuild: Boolean,
+    }],
+    nearByListings: [{
+        listedDate: String,
+        price: Number,
+        noOfBedrooms: Number,
+        noOfBathrooms: Number,
+        internalArea: String,
+        distance: String,
+        address: String,
+        propertyType: String
+    }],
+    nearByCompletedTransactions:[{
+        transactionDate: String,
+        price: Number,
+        noOfBedrooms: Number,
+        noOfBathrooms: Number,
+        internalArea: String,
+        distance: String,
+        address: String,
+    }],
+    risk: {
+        conservationArea: String,
+        listedBuildingsOnPlot: String,
+        nearByListedBuildings: [{
+            name: String,
+            listedDate: String,
+            grade: String,
+            disatanceInMetres: String
+        }],
+        floodRisk: {
+            riverAndSeaRisk: String,
+            surfaceWaterRisk: String,
+        }
+    }
+});
+
+const propertySchema = new mongoose.Schema({
+    haveAnyBuyToLetProperties: { type: Boolean, required: true },
+    isPropertyInEnglandOrWales: { type: Boolean, required: true },
+    price: { type: String, default: '' },
+    noOfBuyToLetProperties: { type: Number },
+    totalMonthlyRentalIncome: { type: String, default: '' },
+    totalMonthlyRepayment: { type: String, default: '' },
+    totalOutstandingBalance: { type: String, default: '' },
+    areAllBedRoomsOver10sqm: { type: Boolean, required: true },
+    isBrickTileConstruction: { type: Boolean, required: true },
+    constructionDetails: { type: String, default: '' },
+    isExLAExclusion: { type: Boolean, required: true },
+    isFlatLift: { type: Boolean, required: true },
+    flatNumberOfBedrooms: { type: Number},
+    isGreenEPC: { type: Boolean, required: true },
+    isGroundRent: { type: String, default: '' },
+    isHouseLicensed: { type: Boolean, required: true },
+    houseNumberOfFloors: { type: Number },
+    houseNumberOfKitchens: { type: Number },
+    houseNumberOfLivingRooms: { type: Number },
+    houseNumberOfBathrooms: { type: Number },
+    houseNumberOfTenancies: { type: Number },
+    hasHousePlanningPermission: { type: Boolean, required: true },
+    isGarage: { type: Boolean, required: true },
+    isNewBuild: { type: Boolean, required: true },
+    propertyAddressCity: { type: String, required: true },
+    propertyAddressCountry: { type: String, required: true },
+    propertyAddressLine1: { type: String, required: true },
+    propertyAddressLine2: { type: String, default: '' },
+    propertyAddressLine3: { type: String, default: '' },
+    propertyAddressPostCode: { type: String, required: true },
+    propertyTenureLID: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    propertyTypeLID: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
+    propertyYearBuilt: { type: Number },
+    receiptOfAnyDiscount: { type: Boolean, },
+    receiptOfDiscountDetails: { type: String, default: '' },
+    sectorExperience: { type: String, required: true },
+    serviceCharge: { type: String, default: '' },
+    unexpiredRemainingLease: { type: String, default: '' },
+    yearLeaseExpires: { type: String, default: '' },
+    energyEfficiencyRating: { type: String},
+    energyEfficiencyRatingValue: { type: Number },
+    dataStreetSchema: dataStreetSchema,
+});
+
+const PropertyModel = mongoose.model("Property", propertySchema);
+export default PropertyModel;

package/shared/lookup-group.model.js

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+
+const lookupGroupSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    lookups: [
+        {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: "Lookup", // References the Lookup collection
+        },
+    ],
+});
+
+const LookupGroupModel = mongoose.model('LookupGroup', lookupGroupSchema);
+export default LookupGroupModel;

package/shared/lookup.model.js

@@ -0,0 +1,22 @@
+import mongoose from "mongoose";
+
+const lookupSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    text: {
+        type: String,
+        required: true
+    },
+    lookupGroupID:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "LookupGroup", // References the LookupGroup collection
+    },
+    value: {
+        type: String
+    }
+});
+
+const LookupModel = mongoose.model('Lookup', lookupSchema);
+export default LookupModel;

package/shared/system-parameter.model.js

@@ -0,0 +1,34 @@
+import mongoose from "mongoose";
+
+const systemParameterSchema = new mongoose.Schema({
+    parameterName: {
+        type: String,
+        required: true,
+    },
+    parameterValue: {
+        type: mongoose.Schema.Types.Mixed,
+        required: true,
+    },
+    notes: {
+        type: String,
+    },
+    createdByUserId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User', 
+        required: true,
+    },
+    createdOn: {
+        type: Date,
+        default: Date.now,
+    },
+    updatedByUserId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User', 
+    },
+    updatedOn: {
+        type: Date,
+    },
+});
+
+const SystemParameterModel = mongoose.model('SystemParameter', systemParameterSchema);
+export default SystemParameterModel;

package/users/role-group.model.js

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+
+const RoleGroupSchema = new mongoose.Schema({
+    groupId: { type: Number, required: true },
+    name: { type: String, required: true },
+    description: { type: String },
+    roles: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Role'
+    }]
+},{
+    timestamps: true
+});
+
+const RoleGroupModel = mongoose.model('RoleGroup', RoleGroupSchema);
+export default RoleGroupModel;

package/users/role.model.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+
+const RoleSchema = new mongoose.Schema({
+    roleId: { type: Number, required: true },
+    name: { type: String, required: true },
+    description: { type: String }
+},{
+    timestamps: true
+});
+
+
+const RoleModel = mongoose.model('Role', RoleSchema);
+
+export default RoleModel;