@dynamatix/gb-schemas 2.0.24 → 2.0.26

package/dist/applications/application-product.model.js

@@ -1,67 +0,0 @@
-import mongoose from "mongoose";
-import { Pound } from "../value-objects/pound";
-const productSchema = new mongoose.Schema({
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true,
-        description: "Unique identifier for the application"
-    },
-    selectedProduct: { type: String, default: "" },
-    lendingTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    pageValidFlag: { type: Boolean, get: (value) => (value ? "Yes" : "No") },
-    repaymentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    numberOfYearsToRepay: { type: Number, default: 0 },
-    repaymentVehicle: { type: String, required: true, default: '', maxLength: 100 },
-    fixedAmount: { type: Pound, default: 0.00, required: false },
-    isFinanceRecommendedToApplicantLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    procFeeRateLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    networkClubSubmission: { type: Boolean, required: true, get: (value) => (value ? "Yes" : "No") },
-    clubNetworkNameLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    introducerSubmission: { type: Boolean, required: true, get: (value) => (value ? "Yes" : "No") },
-    introducer: { type: String, default: '' },
-    bdm: { type: String, required: true, default: '' },
-    tempAppFee: { type: Pound, default: 0.00, required: true },
-    productFeePaymentTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" }
-});
-// virtual property 'lendingType'
-productSchema.virtual('lendingType').get(function () {
-    const lendingType = this.lendingTypeLid;
-    return lendingType && lendingType instanceof mongoose.Types.ObjectId
-        ? null
-        : lendingType?.name || null;
-});
-// virtual property 'repaymentType'
-productSchema.virtual('repaymentType').get(function () {
-    const repaymentType = this.repaymentTypeLid;
-    return repaymentType && repaymentType instanceof mongoose.Types.ObjectId
-        ? null
-        : repaymentType?.name || null;
-});
-// virtual property 'isFinanceRecommendedToApplicant'
-productSchema.virtual('isFinanceRecommendedToApplicant').get(function () {
-    const isFinanceRecommendedToApplicant = this.isFinanceRecommendedToApplicantLid;
-    return isFinanceRecommendedToApplicant && isFinanceRecommendedToApplicant instanceof mongoose.Types.ObjectId
-        ? null
-        : isFinanceRecommendedToApplicant?.name || null;
-});
-// virtual property 'procFeeRate'
-productSchema.virtual('procFeeRate').get(function () {
-    const procFeeRate = this.procFeeRateLid;
-    return procFeeRate && procFeeRate instanceof mongoose.Types.ObjectId
-        ? null
-        : procFeeRate?.name || null;
-});
-// virtual property 'clubNetworkName'
-productSchema.virtual('clubNetworkName').get(function () {
-    const clubNetworkName = this.clubNetworkNameLid;
-    return clubNetworkName && clubNetworkName instanceof mongoose.Types.ObjectId
-        ? null
-        : clubNetworkName?.name || null;
-});
-// virtual property 'productFeePaymentType'
-productSchema.virtual('productFeePaymentType').get(function () {
-    const productFeePaymentType = this.productFeePaymentTypeLid;
-    return productFeePaymentType && productFeePaymentType instanceof mongoose.Types.ObjectId
-        ? null
-        : productFeePaymentType?.name || null;
-});
-const ProductModel = mongoose.model("Product", productSchema);
-export default ProductModel;

package/dist/applications/application-rationale.model.js

@@ -1,38 +0,0 @@
-import mongoose from "mongoose";
-const rationaleSchema = new mongoose.Schema({
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
-    affordabilityDescription: { type: String, default: "" },
-    affordabilityAreaOfOfferCondition: { type: String, default: "" },
-    affordabilityAreaOfConcern: { type: String, default: "" },
-    affordabilityStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    applicantsDescription: { type: String, default: "" },
-    applicantsAreaOfOfferCondition: { type: String, default: "" },
-    applicantsAreaOfConcern: { type: String, default: "" },
-    applicantsStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    creditConductDescription: { type: String, default: "" },
-    creditConductAreaOfOfferCondition: { type: String, default: "" },
-    creditConductAreaOfConcern: { type: String, default: "" },
-    creditConductStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    fraudCheckDescription: { type: String, default: "" },
-    fraudCheckAreaOfOfferCondition: { type: String, default: "" },
-    fraudCheckAreaOfConcern: { type: String, default: "" },
-    fraudCheckStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    incomeSourceDescription: { type: String, default: "" },
-    incomeSourceAreaOfOfferCondition: { type: String, default: "" },
-    incomeSourceAreaOfConcern: { type: String, default: "" },
-    incomeSourceStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    loanDescription: { type: String, default: "" },
-    loanAreaOfOfferCondition: { type: String, default: "" },
-    loanAreaOfConcern: { type: String, default: "" },
-    loanStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    securityDescription: { type: String, default: "" },
-    securityAreaOfOfferCondition: { type: String, default: "" },
-    securityAreaOfConcern: { type: String, default: "" },
-    securityStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-    propertyDescription: { type: String, default: "" },
-    propertyAreaOfOfferCondition: { type: String, default: "" },
-    propertyAreaOfConcern: { type: String, default: "" },
-    propertyStatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup" },
-});
-const ApplicationRationaleModel = mongoose.model("ApplicationRationale", rationaleSchema);
-export default ApplicationRationaleModel;

package/dist/applications/application-risk-narrative.model.js

@@ -1,12 +0,0 @@
-import mongoose from 'mongoose';
-const applicantionRiskNarrativeSchema = new mongoose.Schema({
-    call1RequestedOn: { type: String },
-    call2RequestedOn: { type: String },
-    call2StatusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-    rationaleForRiskRating: { type: String },
-    retryCount: { type: String },
-    riskRating: { type: String },
-    statusLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", default: null },
-});
-const ApplicationRiskNarrativeModel = mongoose.model('ApplicationRiskNarrative', applicantionRiskNarrativeSchema);
-export default ApplicationRiskNarrativeModel;

package/dist/applications/application-valuation.model.js

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

package/dist/applications/application.model.js

@@ -1,153 +0,0 @@
-import mongoose from "mongoose";
-import creditProfileSchema from "./application-credit-profile.model";
-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: String, 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 },
-    caseManager: { type: String, default: "" },
-    caseManagerAccepted: { type: String, default: false },
-    completedReason: { type: String, default: "" },
-    isIntendToOccupy: { type: String, required: true },
-    introducer: { type: String, default: "" },
-    isIntroducerSubmission: { type: String, required: true },
-    isBrokerAssigned: { type: String, default: false },
-    isFinanceRecommendedToApplicant: { type: String, required: true },
-    isWorkflowTaskCreated: { type: String, required: true },
-    lastUpdated: { type: String },
-    lendingTypeLid: { type: mongoose.Schema.Types.ObjectId, ref: "Lookup", required: true },
-    networkClubName: { type: String, default: "" },
-    isNetworkClubSubmission: { type: String, 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: false },
-    sourceOfWealthLids: [{ 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: String },
-    underwriter: { type: String, default: "" },
-    isValuationFeePaid: { type: String, required: true },
-    withdrawalReason: { type: String, default: "" },
-    withdrawalReasonCode: { type: String, default: "" },
-    productId: { type: mongoose.Schema.Types.ObjectId, ref: "Product", required: false },
-    product: { type: String },
-    securityId: { type: mongoose.Schema.Types.ObjectId, ref: "Security", required: true },
-    solicitorId: { type: mongoose.Schema.Types.ObjectId, ref: "Solicitor", required: true },
-    applicants: [
-        { type: mongoose.Schema.Types.ObjectId, ref: "Applicant" }
-    ],
-    isActive: { type: String, default: false },
-    isUkResident: { type: String, default: true },
-    riskRating: { type: String },
-    directDebitId: { type: mongoose.Schema.Types.ObjectId, ref: "Application_DirectDebit" },
-    creditProfile: creditProfileSchema,
-    mortgageId: { type: mongoose.Schema.Types.ObjectId, ref: "Mortgage" },
-    companyId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationCompany" },
-    rationaleId: { type: mongoose.Schema.Types.ObjectId, ref: "ApplicationRationale" },
-    newAuditRecordsCount: { type: String, default: 0 }, // Ensure it is a Number
-    currentApprivoAuditId: Number,
-    propertyIds: [{ type: mongoose.Schema.Types.ObjectId, ref: "Property" }]
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-});
-// Virtual property 'noOfApplicants'
-applicationSchema.virtual('noOfApplicants').get(function () {
-    return this.applicants ? this.applicants.length : 0;
-});
-// Virtual property 'applicationTypeName'
-applicationSchema.virtual('applicationTypeName').get(function () {
-    return this.applicationTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.applicationTypeLid?.name ?? null;
-});
-// Virtual property 'lendingType'
-applicationSchema.virtual('lendingType').get(function () {
-    return this.lendingTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.lendingTypeLid?.name ?? null;
-});
-// Virtual property 'purchaseType'
-applicationSchema.virtual('purchaseType').get(function () {
-    return this.purchaseTypeLid instanceof mongoose.Types.ObjectId
-        ? null
-        : this.purchaseTypeLid?.text ?? null;
-});
-// Virtual property 'status'
-applicationSchema.virtual('status').get(function () {
-    return this.statusLid instanceof mongoose.Types.ObjectId ? null : this.statusLid?.name ?? null;
-});
-// Ensure the fields are populated when querying
-applicationSchema.pre('find', function () {
-    this.populate('applicationTypeLid').populate('lendingTypeLid').populate('statusLid');
-});
-applicationSchema.pre('findOne', function () {
-    this.populate('applicationTypeLid').populate('lendingTypeLid').populate('statusLid');
-});
-// Virtual property 'LTV %'
-applicationSchema.virtual('ltv').get(function () {
-    const purchasePrice = this.mortgageId?.purchasePrice;
-    const loanRequired = this.mortgageId?.loanRequired;
-    if (purchasePrice && loanRequired) {
-        const parseCurrency = (value) => {
-            if (typeof value === 'string') {
-                return parseFloat(value.replace(/[^0-9.-]+/g, ""));
-            }
-            return value;
-        };
-        const parsedPurchasePrice = parseCurrency(purchasePrice);
-        const parsedLoanRequired = parseCurrency(loanRequired);
-        const ltv = (parsedLoanRequired / parsedPurchasePrice) * 100;
-        return ltv.toFixed(2) + "%";
-    }
-    return null;
-});
-applicationSchema.virtual('submittedDateFormatted').get(function () {
-    if (!this.submittedDate)
-        return null;
-    const date = new Date(this.submittedDate);
-    const day = String(date.getDate()).padStart(2, '0');
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const year = date.getFullYear();
-    return `${day}-${month}-${year}`;
-});
-// Virtual property for broker name
-applicationSchema.virtual('brokerName').get(function () {
-    if (this.brokerId && typeof this.brokerId === 'object' && this.brokerId.firstName && this.brokerId.lastName) {
-        return this.brokerId.firstName + " " + this.brokerId.lastName;
-    }
-    return null;
-});
-applicationSchema.virtual('brokerEmail').get(function () {
-    return this.brokerId && typeof this.brokerId === 'object' ? this.brokerId.email : null;
-});
-applicationSchema.virtual('solicitorName').get(function () {
-    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.nameOfAccountHolder : null;
-});
-applicationSchema.virtual('solicitorEmail').get(function () {
-    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.email : null;
-});
-applicationSchema.virtual('brokerPhone').get(function () {
-    return this.brokerId && typeof this.brokerId === 'object' ? this.brokerId.mobileTelephone : null;
-});
-applicationSchema.virtual('solicitorPhone').get(function () {
-    return this.solicitorId && typeof this.solicitorId === 'object' ? this.solicitorId.telephone : null;
-});
-const ApplicationModel = mongoose.model("Application", applicationSchema);
-export default ApplicationModel;

package/dist/applications/broker.model.js

@@ -1,21 +0,0 @@
-import mongoose from "mongoose";
-const brokerSchema = new mongoose.Schema({
-    brokerId: { type: String },
-    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/dist/applications/document.model.js

@@ -1,35 +0,0 @@
-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: mongoose.Schema.Types.ObjectId, ref: "DocumentType", required: false },
-    fileName: { type: String, required: false },
-    contentType: { type: String, required: false },
-    created: { type: String, required: false },
-    createdBy: { type: String, required: false },
-    isGenerated: { type: String, required: false },
-    data: { type: String, required: false },
-    envelopeId: { type: String, required: false },
-    signers: { type: Array, default: [] },
-    documentType: {
-        documentTypeId: { type: String, 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/dist/applications/index.js

@@ -1,20 +0,0 @@
-export { default as ApplicationModel } from './application.model';
-export { default as ApplicationAuditModel } from './application-audit.model';
-export { default as ApplicationCheckListModel } from './application-checklist-Item.model';
-export { default as ApplicationCompanyModel } from './application-company-model.js';
-export { default as ApplicationNoteModel } from './application-note.model';
-export { default as ApplicationCreditProfileModel } from './application-credit-profile.model';
-export { default as ApplicationDirectDebitModel } from './application-direct-debit.model';
-export { default as ApplicationMortgageModel } from './application-mortgage.model';
-export { default as ApplicationOnboardingModel } from './application-onboarding.model';
-export { default as ApplicationRationaleModel } from './application-rationale.model';
-export { default as ApplicationValuationModel } from './application-valuation.model';
-export { default as BrokerModel } from './broker.model';
-export { default as ProductModel } from './application-product.model';
-export { default as SolicitorModel } from './solicitor.model';
-export { default as ApplicationDocumentModel } from './application-document.model';
-export { default as ApplicationRiskNarrativeModel } from './application-risk-narrative.model';
-export { default as ApplicationFieldConfigModel } from './application-fieldconfig.model';
-export { default as DocumentModel } from './document.model';
-export { default as MortgageModel } from './application-mortgage.model';
-export { default as ApplicationProductFeaturesModel } from './application-productfeatures.model';

package/dist/applications/solicitor.model.js

@@ -1,114 +0,0 @@
-import mongoose from "mongoose";
-import { SortCode } from "../value-objects/sort-code";
-const Schema = mongoose.Schema;
-const solicitorSchema = new Schema({
-    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application",
-        required: true,
-        description: "Unique identifier for the application",
-    },
-    pageValidFlag: {
-        type: Boolean,
-        default: true,
-    },
-    accountNumber: {
-        type: Number,
-        description: "Account number associated with the solicitor"
-    },
-    addressCity: {
-        type: String,
-        maxLength: 30,
-        description: "City where the solicitor is located"
-    },
-    addressCountryLid: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: "Lookup",
-        description: "Country ID from the lookup list"
-    },
-    addressLine1: {
-        type: String,
-        maxLength: 35,
-        description: "First line of the solicitor's address"
-    },
-    addressLine2: {
-        type: String,
-        maxLength: 35,
-        description: "Second line of the solicitor's address"
-    },
-    addressLine3: {
-        type: String,
-        maxLength: 35,
-        description: "Third line of the solicitor's address"
-    },
-    addressPostCode: {
-        type: String,
-        maxLength: 50,
-        description: "Postal code for the solicitor's address"
-    },
-    bankAddressLine1: {
-        type: String,
-        description: "First line of the solicitor's bank address"
-    },
-    bankAddressLine2: {
-        type: String,
-        description: "Second line of the solicitor's bank address"
-    },
-    bankBranch: {
-        type: String,
-        description: "Branch of the solicitor's bank"
-    },
-    bankCity: {
-        type: String,
-        description: "City where the solicitor's bank is located"
-    },
-    contactPostcode: {
-        type: String,
-        description: "Postal code for the solicitor's contact address"
-    },
-    email: {
-        type: String,
-        description: "Email address of the solicitor"
-    },
-    institution: {
-        type: String,
-        description: "Institution name where the solicitor works"
-    },
-    nameOfAccountHolder: {
-        type: String,
-        description: "Name of the account holder associated with the solicitor"
-    },
-    nameOfFirm: {
-        type: String,
-        description: "Name of the solicitor's firm"
-    },
-    signatory: {
-        type: String,
-        description: "Signatory name for the solicitor"
-    },
-    solicitorActing: {
-        type: String,
-        maxLength: 50,
-        description: "Indicates if the solicitor is acting in a particular capacity"
-    },
-    sortCode: {
-        type: SortCode,
-        description: "Sort code associated with the solicitor's account"
-    },
-    telephone: {
-        type: String,
-        maxLength: 15,
-        description: "Telephone number of the solicitor"
-    },
-}, {
-    timestamps: true,
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-});
-const virtualCountry = solicitorSchema.virtual('addressCountry', {
-    ref: 'Lookup',
-    localField: 'addressCountryLid',
-    foreignField: '_id',
-    justOne: true
-});
-virtualCountry.description = 'Populated lookup value for the solicitor\'s address country';
-const SolicitorModel = mongoose.model("Solicitor", solicitorSchema);
-export default SolicitorModel;

package/dist/index.js

@@ -1,9 +0,0 @@
-export * from './applications/index.js';
-export * from './shared/index.js';
-export * from './properties/index.js';
-export * from './applicants/index.js';
-export * from './users/index.js';
-export * from './product-catalogues/index.js';
-export * from './underwriter/index.js';
-// Export Prisma/Postgres schemas
-export * from './entities/index.js';

package/dist/product-catalogues/index.js

@@ -1,3 +0,0 @@
-export { default as ProductCatalogueModel } from './product-catalogue.model';
-export { default as ProductDefinitionsModel } from './product-definitions.model';
-export { default as ProductVariantModel } from './product-variant.model';

package/dist/product-catalogues/product-catalogue.model.js

@@ -1,18 +0,0 @@
-import mongoose from "mongoose";
-const productCatalogueSchema = new mongoose.Schema({
-    productCatalogueId: { type: String, required: true },
-    name: { type: String, required: true },
-    description: { type: String },
-    applyFrom: { type: String, required: true },
-    applyUntil: { type: String, required: true },
-    submitUntil: { type: String, required: true },
-    status: { type: String, required: true },
-    lockedForEdit: { type: String, required: true },
-    baseRateName: { type: String },
-    baseRate: { type: String },
-    mapperName: { type: String }
-}, {
-    timestamps: true
-});
-const ProductCatalogueModel = mongoose.model('ProductCatalogue', productCatalogueSchema);
-export default ProductCatalogueModel;

package/dist/product-catalogues/product-definitions.model.js

@@ -1,26 +0,0 @@
-import mongoose from "mongoose";
-const ruleSchema = new mongoose.Schema({
-    ruleId: { type: String, required: true },
-    rule: { type: String, required: true }, // Storing as a string (JSON stringified)
-    name: { type: String, required: true },
-    description: { type: String },
-    scope: { type: String },
-    mandatory: { type: String, required: true },
-    overrideRuleType: { type: String },
-    overrideRuleMessage: { type: String },
-    inheritedFrom: { type: String },
-    anyPass: { type: String, required: true },
-    preCashflow: { type: String, required: true }
-});
-const productDefinitionsSchema = new mongoose.Schema({
-    productDefinitionId: { type: String, required: true },
-    productCatalogueId: { ref: "ProductCatalogue", type: mongoose.Schema.Types.ObjectId, required: true },
-    name: { type: String, required: true },
-    atLeastOnePass: { type: String, required: true },
-    elements: { type: [mongoose.Schema.Types.Mixed], default: [] },
-    rules: { type: [ruleSchema], default: [] } // Embedded array of RuleSchema
-}, {
-    timestamps: true
-});
-const ProductDefinitionsModel = mongoose.model('ProductDefinitions', productDefinitionsSchema);
-export default ProductDefinitionsModel;

package/dist/product-catalogues/product-variant.model.js

@@ -1,12 +0,0 @@
-import mongoose from "mongoose";
-const productVariantSchema = new mongoose.Schema({
-    productCatalogueId: { ref: "ProductCatalogue", type: mongoose.Schema.Types.ObjectId, required: true },
-    variantid: { type: String, required: true },
-    name: { type: String, required: true },
-    variantCode: { type: String, required: true },
-    label: { type: String },
-}, {
-    timestamps: true
-});
-const ProductVariantModel = mongoose.model('ProductVariant', productVariantSchema);
-export default ProductVariantModel;

package/dist/properties/index.js

@@ -1,2 +0,0 @@
-export { default as SecurityModel } from './security.model';
-export { default as PropertyModel } from './property.model';