@dynamatix/gb-schemas 2.3.288 → 2.3.290

package/dist/applicants/applicant-welcome-call.model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"applicant-welcome-call.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-welcome-call.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA6lBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA4D,CAAC;AAEnF,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"applicant-welcome-call.model.d.ts","sourceRoot":"","sources":["../../applicants/applicant-welcome-call.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAksBhC,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA4D,CAAC;AAEnF,eAAe,gBAAgB,CAAC"}

package/dist/applicants/applicant-welcome-call.model.js

@@ -237,7 +237,7 @@ welcomeCallSchema.virtual('customerCurrentResidentialAddress').get(function () {
                 applicant.addressLine2,
                 applicant.addressLine3,
                 applicant.addressCity,
-                applicant.propertyAddressCountry,
+                countryName,
                 applicant.addressPostCode
             ].filter(part => part && part.trim() !== '');
             return addressParts.join(', ');
@@ -270,6 +270,9 @@ welcomeCallSchema.virtual('applicantEmployerBusinessName').get(function () {
                         if (employment.employerName && employment.employerName.trim() !== '') {
                             return employment.employerName;
                         }
+                        else {
+                            return '';
+                        }
                         // Field exists but no data - return empty string
                         return '';
                     }
@@ -285,6 +288,9 @@ welcomeCallSchema.virtual('applicantEmployerBusinessName').get(function () {
                         if (selfEmployment.nameOfBusiness && selfEmployment.nameOfBusiness.trim() !== '') {
                             return selfEmployment.nameOfBusiness;
                         }
+                        else {
+                            return '';
+                        }
                         // Field exists but no data - return empty string
                         return '';
                     }
@@ -341,7 +347,7 @@ welcomeCallSchema.virtual('otherApplicantsNameAndDOB').get(function () {
                 return 'N/A';
             }
             // Format each other applicant as: "First and middle names, last name, Date of birth"
-            const formattedApplicants = otherApplicants.map((applicant) => {
+            const formattedApplicants = otherApplicants.map((applicant, index) => {
                 // Check if applicant is an ObjectId (not populated)
                 if (typeof applicant === 'string' || (applicant.constructor && applicant.constructor.name === 'ObjectId')) {
                     return null; // Skip unpopulated references
@@ -379,11 +385,17 @@ welcomeCallSchema.virtual('otherApplicantsNameAndDOB').get(function () {
                         }
                     }
                 }
-                // Format as "First and middle names, last name, Date of birth"
-                return `${fullFirstName}, ${lastName}, ${formattedDOB}`;
-            }).filter((line) => line && line.trim() !== ', ,' && line.trim() !== '');
-            // Join all applicants with newline
-            return formattedApplicants.join('\n');
+                const isLast = index === otherApplicants.length - 1;
+                const comma = isLast ? '' : ',';
+                // Format as an HTML line (with bold labels and inline values)
+                return `
+            <div class="applicant-line">
+                <span class="readonly-data">${fullFirstName}, ${lastName}, ${formattedDOB}${comma}</span>
+            </div>
+        `;
+            }).filter((line) => line && line.trim() !== '');
+            // Join all applicants as HTML (no \n needed)
+            return formattedApplicants.join('');
         }
     }
     // If application not populated or no applicants, return "N/A"
@@ -559,6 +571,89 @@ welcomeCallSchema.virtual('initialRatePercentage').get(function () {
     }
     return null;
 });
+// Virtual property for finance summary HTML
+welcomeCallSchema.virtual('financeSummaryHtml').get(function () {
+    let application = null;
+    if (this.applicantId && typeof this.applicantId === 'object' && !(typeof this.applicantId.toHexString === 'function') && this.applicantId.applicationId) {
+        application = this.applicantId.applicationId;
+    }
+    else if (this.applicationId && typeof this.applicationId === 'object') {
+        application = this.applicationId;
+    }
+    else {
+        return '-';
+    }
+    if (application) {
+        // Initialize summary data
+        let product = '';
+        let financeTerm = '';
+        let monthlyFinance = '';
+        let rentalIncome = '';
+        let occupancy = '';
+        // Get product information (first 3 characters)
+        if (application.selectedProduct && typeof application.selectedProduct === 'string') {
+            const extracted = application.selectedProduct.split('(')[0].trim();
+            product = `${extracted} product`;
+        }
+        else if (application.productId && typeof application.productId === 'object' && application.productId.selectedProduct) {
+            const extracted = application.productId.selectedProduct.split('(')[0].trim();
+            product = `${extracted} product`;
+        }
+        else {
+            product = '-';
+        }
+        // Get finance term from productId if available
+        if (application.productId && typeof application.productId === 'object') {
+            if (application.productId.numberOfYearsToRepay !== undefined && application.productId.numberOfYearsToRepay !== null) {
+                financeTerm = `${application.productId.numberOfYearsToRepay} year finance term`;
+            }
+        }
+        else {
+            financeTerm = '-';
+        }
+        // Get rental income from mortgage - mortgageId is at application level
+        let mortgage = null;
+        if (application.mortgageId && typeof application.mortgageId === 'object') {
+            mortgage = application.mortgageId;
+        }
+        if (mortgage) {
+            // Get rental income - check if it exists (even if 0)
+            if (mortgage.monthlyRentalIncome !== undefined && mortgage.monthlyRentalIncome !== null) {
+                // Convert to number first, then format
+                const numericValue = Number(mortgage.monthlyRentalIncome);
+                const rentalValue = isNaN(numericValue) ? '0.00' : numericValue.toFixed(2);
+                rentalIncome = `£${rentalValue}`;
+            }
+            // Get finance amount from loanRequired
+            if (mortgage.loanRequired !== undefined && mortgage.loanRequired !== null) {
+                const numericValue = Number(mortgage.loanRequired);
+                const financeValue = isNaN(numericValue) ? '0.00' : numericValue.toFixed(2);
+                monthlyFinance = `£${financeValue}`;
+            }
+            // Get occupancy information from mortgage
+            if (mortgage.proposedTenantsLids && Array.isArray(mortgage.proposedTenantsLids) && mortgage.proposedTenantsLids.length > 0) {
+                // Get the first proposed tenant type
+                const firstTenant = mortgage.proposedTenantsLids[0];
+                if (firstTenant && typeof firstTenant === 'object' && firstTenant.name) {
+                    occupancy = firstTenant.name;
+                }
+            }
+            else {
+                occupancy = '-';
+            }
+        }
+        // Create HTML content
+        const summaryContent = `
+        <div class="flex align-items-center mb-2"><p class="text-bold m-0 readonly-data">Product:</p> <span class="readonly-data ml-2">${product}</span></div>
+        <div class="flex align-items-center mb-2"><p class="text-bold m-0 readonly-data">Finance Term:</p> <span class="readonly-data ml-2">${financeTerm}</span></div>
+        <div class="flex align-items-center mb-2"><p class="text-bold m-0 readonly-data">Monthly Finance:</p> <span class="readonly-data ml-2">${monthlyFinance}</span></div>
+        <div class="flex align-items-center mb-2"><p class="text-bold m-0 readonly-data">Rental Income:</p> <span class="readonly-data ml-2">${rentalIncome}</span></div>
+        <div class="flex align-items-center"><p class="text-bold m-0 readonly-data">Occupancy:</p> <span class="readonly-data ml-2">${occupancy}</span></div>
+        `;
+        return summaryContent;
+    }
+    return '-';
+});
 applyAuditMiddleware(welcomeCallSchema, "ApplicantWelcomeCall");
 // Apply workflow plugin to the schema
 applyWorkflowPlugin(welcomeCallSchema, 'applicantwelcomecall');

package/dist/shared/audit-log.model.d.ts

@@ -0,0 +1,180 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from "mongoose";
+declare const AuditLogModel: mongoose.Model<{
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}, {}> & {
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: false;
+    toJSON: {
+        virtuals: true;
+    };
+    toObject: {
+        virtuals: true;
+    };
+}, {
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}>, {}> & mongoose.FlatRecord<{
+    name: string;
+    action: "read" | "create" | "update" | "delete";
+    timestamp: NativeDate;
+    recordId: mongoose.Types.ObjectId;
+    isSystemGenerated: boolean;
+    metadata?: any;
+    source?: string | null | undefined;
+    oldValue?: any;
+    newValue?: any;
+    fieldName?: string | null | undefined;
+    userId?: mongoose.Types.ObjectId | null | undefined;
+    ipAddress?: string | null | undefined;
+    userAgent?: string | null | undefined;
+    sessionId?: string | null | undefined;
+    externalData?: {
+        apprivoAuditId?: string | null | undefined;
+        syncStatus?: "pending" | "synced" | "failed" | null | undefined;
+        syncedAt?: NativeDate | null | undefined;
+        externalSystemId?: string | null | undefined;
+    } | null | undefined;
+    severity?: "low" | "medium" | "high" | "critical" | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default AuditLogModel;
+//# sourceMappingURL=audit-log.model.d.ts.map

package/dist/shared/audit-log.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log.model.d.ts","sourceRoot":"","sources":["../../shared/audit-log.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA6ChC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}

package/dist/shared/audit-log.model.js

@@ -0,0 +1,43 @@
+import mongoose from "mongoose";
+const auditLogSchema = new mongoose.Schema({
+    name: { type: String, required: true }, // Collection/model name
+    recordId: { type: mongoose.Schema.Types.ObjectId, required: true }, // ID of the record being audited
+    action: { type: String, required: true, enum: ['create', 'update', 'delete', 'read'] },
+    userId: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false }, // User who performed the action
+    timestamp: { type: Date, default: Date.now, required: true },
+    oldValue: { type: mongoose.Schema.Types.Mixed, required: false }, // Previous value
+    newValue: { type: mongoose.Schema.Types.Mixed, required: false }, // New value
+    fieldName: { type: String, required: false }, // Specific field that changed
+    ipAddress: { type: String, required: false },
+    userAgent: { type: String, required: false },
+    sessionId: { type: String, required: false },
+    source: { type: String, required: false, default: 'application' }, // Source of the change
+    metadata: { type: mongoose.Schema.Types.Mixed, required: false },
+    externalData: {
+        apprivoAuditId: { type: String, required: false }, // External system audit ID
+        syncStatus: { type: String, required: false, enum: ['pending', 'synced', 'failed'] },
+        syncedAt: { type: Date, required: false },
+        externalSystemId: { type: String, required: false }
+    },
+    isSystemGenerated: { type: Boolean, default: false },
+    severity: { type: String, required: false, enum: ['low', 'medium', 'high', 'critical'], default: 'low' }
+}, {
+    timestamps: false, // We use our own timestamp field
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+});
+// Virtual for formatted timestamp
+auditLogSchema.virtual('formattedTimestamp').get(function () {
+    return this.timestamp ? this.timestamp.toISOString() : null;
+});
+// Add indexes to match database
+auditLogSchema.index({ 'externalData.apprivoAuditId': 1 }); // External audit ID lookup
+auditLogSchema.index({ name: 1, newValue: 1, recordId: 1, timestamp: -1 }); // Complex compound index
+auditLogSchema.index({ name: 1, recordId: 1 }); // Filter by collection and record
+auditLogSchema.index({ recordId: 1, timestamp: -1, _id: -1 }); // Record history with fallback sort
+auditLogSchema.index({ timestamp: -1 }); // Sort by recent changes
+auditLogSchema.index({ userId: 1, timestamp: -1 }); // User activity history
+auditLogSchema.index({ action: 1, timestamp: -1 }); // Filter by action type
+auditLogSchema.index({ name: 1, action: 1, timestamp: -1 }); // Collection-specific action history
+const AuditLogModel = mongoose.model("AuditLog", auditLogSchema);
+export default AuditLogModel;

package/dist/shared/document.model.d.ts

@@ -0,0 +1,180 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from "mongoose";
+declare const DocumentModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}, {}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    toJSON: {
+        virtuals: true;
+    };
+    toObject: {
+        virtuals: true;
+    };
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    applicationId: mongoose.Types.ObjectId;
+    status: "pending" | "uploaded" | "verified" | "rejected" | "archived";
+    category: string;
+    fileName: string;
+    originalName: string;
+    mimeType: string;
+    fileSize: number;
+    filePath: string;
+    uploadedBy: mongoose.Types.ObjectId;
+    tags: string[];
+    metadata?: any;
+    contextId?: mongoose.Types.ObjectId | null | undefined;
+    rejectionReason?: string | null | undefined;
+    subCategory?: string | null | undefined;
+    verifiedBy?: mongoose.Types.ObjectId | null | undefined;
+    verifiedAt?: NativeDate | null | undefined;
+    expiresAt?: NativeDate | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default DocumentModel;
+//# sourceMappingURL=document.model.d.ts.map

package/dist/shared/document.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.model.d.ts","sourceRoot":"","sources":["../../shared/document.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA0ChC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA6C,CAAC;AACjE,eAAe,aAAa,CAAC"}

package/dist/shared/document.model.js

@@ -0,0 +1,40 @@
+import mongoose from "mongoose";
+import { applyAuditMiddleware } from "@dynamatix/cat-shared/middlewares";
+import { applyWorkflowPlugin } from "./workflow.plugin";
+const documentSchema = new mongoose.Schema({
+    applicationId: { type: mongoose.Schema.Types.ObjectId, ref: "Application", required: true },
+    contextId: { type: mongoose.Schema.Types.ObjectId, required: false },
+    status: { type: String, required: true, enum: ['pending', 'uploaded', 'verified', 'rejected', 'archived'] },
+    category: { type: String, required: true },
+    subCategory: { type: String, required: false },
+    fileName: { type: String, required: true },
+    originalName: { type: String, required: true },
+    mimeType: { type: String, required: true },
+    fileSize: { type: Number, required: true },
+    filePath: { type: String, required: true },
+    uploadedBy: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: true },
+    verifiedBy: { type: mongoose.Schema.Types.ObjectId, ref: "User", required: false },
+    verifiedAt: { type: Date, required: false },
+    rejectionReason: { type: String, required: false },
+    metadata: { type: mongoose.Schema.Types.Mixed, required: false },
+    tags: [{ type: String }],
+    isActive: { type: Boolean, default: true },
+    expiresAt: { type: Date, required: false }
+}, {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+});
+applyAuditMiddleware(documentSchema, "Document");
+applyWorkflowPlugin(documentSchema, 'document');
+// Add indexes to match database
+documentSchema.index({ applicationId: 1 }); // Filter by application
+documentSchema.index({ contextId: 1 }); // Filter by context
+documentSchema.index({ status: 1 }); // Filter by status
+documentSchema.index({ category: 1 }); // Filter by category
+documentSchema.index({ subCategory: 1 }); // Filter by subcategory
+documentSchema.index({ applicationId: 1, status: 1 }); // Compound: application + status
+documentSchema.index({ contextId: 1, status: 1 }); // Compound: context + status
+documentSchema.index({ category: 1, status: 1 }); // Compound: category + status
+const DocumentModel = mongoose.model("Document", documentSchema);
+export default DocumentModel;

package/dist/shared/queue.model.d.ts

@@ -0,0 +1,180 @@
+/// <reference path="../value-objects/pound.d.ts" />
+/// <reference path="../value-objects/account-number.d.ts" />
+/// <reference path="../value-objects/sort-code.d.ts" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from "mongoose";
+declare const QueueModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    name: string;
+    retryAttempts: number;
+    retryDelay: number;
+    priority: number;
+    maxConcurrency: number;
+    processingTimeout: number;
+    assignedUsers: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+    departmentId?: mongoose.Types.ObjectId | null | undefined;
+    workflowId?: mongoose.Types.ObjectId | null | undefined;
+    settings?: any;
+    statistics?: {
+        totalProcessed: number;
+        totalFailed: number;
+        averageProcessingTime: number;
+        lastProcessedAt?: NativeDate | null | undefined;
+    } | null | undefined;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    name: string;
+    retryAttempts: number;
+    retryDelay: number;
+    priority: number;
+    maxConcurrency: number;
+    processingTimeout: number;
+    assignedUsers: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+    departmentId?: mongoose.Types.ObjectId | null | undefined;
+    workflowId?: mongoose.Types.ObjectId | null | undefined;
+    settings?: any;
+    statistics?: {
+        totalProcessed: number;
+        totalFailed: number;
+        averageProcessingTime: number;
+        lastProcessedAt?: NativeDate | null | undefined;
+    } | null | undefined;
+}, {}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    name: string;
+    retryAttempts: number;
+    retryDelay: number;
+    priority: number;
+    maxConcurrency: number;
+    processingTimeout: number;
+    assignedUsers: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+    departmentId?: mongoose.Types.ObjectId | null | undefined;
+    workflowId?: mongoose.Types.ObjectId | null | undefined;
+    settings?: any;
+    statistics?: {
+        totalProcessed: number;
+        totalFailed: number;
+        averageProcessingTime: number;
+        lastProcessedAt?: NativeDate | null | undefined;
+    } | null | undefined;
+} & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    toJSON: {
+        virtuals: true;
+    };
+    toObject: {
+        virtuals: true;
+    };
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    name: string;
+    retryAttempts: number;
+    retryDelay: number;
+    priority: number;
+    maxConcurrency: number;
+    processingTimeout: number;
+    assignedUsers: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+    departmentId?: mongoose.Types.ObjectId | null | undefined;
+    workflowId?: mongoose.Types.ObjectId | null | undefined;
+    settings?: any;
+    statistics?: {
+        totalProcessed: number;
+        totalFailed: number;
+        averageProcessingTime: number;
+        lastProcessedAt?: NativeDate | null | undefined;
+    } | null | undefined;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    name: string;
+    retryAttempts: number;
+    retryDelay: number;
+    priority: number;
+    maxConcurrency: number;
+    processingTimeout: number;
+    assignedUsers: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+    departmentId?: mongoose.Types.ObjectId | null | undefined;
+    workflowId?: mongoose.Types.ObjectId | null | undefined;
+    settings?: any;
+    statistics?: {
+        totalProcessed: number;
+        totalFailed: number;
+        averageProcessingTime: number;
+        lastProcessedAt?: NativeDate | null | undefined;
+    } | null | undefined;
+}>, {}> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    isActive: boolean;
+    name: string;
+    retryAttempts: number;
+    retryDelay: number;
+    priority: number;
+    maxConcurrency: number;
+    processingTimeout: number;
+    assignedUsers: mongoose.Types.ObjectId[];
+    description?: string | null | undefined;
+    departmentId?: mongoose.Types.ObjectId | null | undefined;
+    workflowId?: mongoose.Types.ObjectId | null | undefined;
+    settings?: any;
+    statistics?: {
+        totalProcessed: number;
+        totalFailed: number;
+        averageProcessingTime: number;
+        lastProcessedAt?: NativeDate | null | undefined;
+    } | null | undefined;
+}> & {
+    _id: mongoose.Types.ObjectId;
+} & {
+    __v: number;
+}>>;
+export default QueueModel;
+//# sourceMappingURL=queue.model.d.ts.map

package/dist/shared/queue.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.model.d.ts","sourceRoot":"","sources":["../../shared/queue.model.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AA6ChC,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAuC,CAAC;AACxD,eAAe,UAAU,CAAC"}

package/dist/shared/queue.model.js

@@ -0,0 +1,42 @@
+import mongoose from "mongoose";
+import { applyAuditMiddleware } from "@dynamatix/cat-shared/middlewares";
+import { applyWorkflowPlugin } from "./workflow.plugin";
+const queueSchema = new mongoose.Schema({
+    name: { type: String, required: true, unique: true },
+    description: { type: String, required: false },
+    isActive: { type: Boolean, default: true },
+    priority: { type: Number, default: 0 },
+    maxConcurrency: { type: Number, default: 1 },
+    retryAttempts: { type: Number, default: 3 },
+    retryDelay: { type: Number, default: 5000 }, // milliseconds
+    processingTimeout: { type: Number, default: 300000 }, // 5 minutes in milliseconds
+    assignedUsers: [{ type: mongoose.Schema.Types.ObjectId, ref: "User" }],
+    departmentId: { type: mongoose.Schema.Types.ObjectId, ref: "Department", required: false },
+    workflowId: { type: mongoose.Schema.Types.ObjectId, ref: "Workflow", required: false },
+    settings: { type: mongoose.Schema.Types.Mixed, required: false },
+    statistics: {
+        totalProcessed: { type: Number, default: 0 },
+        totalFailed: { type: Number, default: 0 },
+        averageProcessingTime: { type: Number, default: 0 },
+        lastProcessedAt: { type: Date, required: false }
+    }
+}, {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true }
+});
+// Virtual for current queue size (would need to be populated from related collections)
+queueSchema.virtual('currentSize').get(function () {
+    // This would typically be calculated by counting related queue items
+    return 0;
+});
+applyAuditMiddleware(queueSchema, "Queue");
+applyWorkflowPlugin(queueSchema, 'queue');
+// Add indexes to match database
+queueSchema.index({ name: 1 }, { unique: true }); // Unique queue name
+queueSchema.index({ isActive: 1 }); // Filter by active status
+queueSchema.index({ priority: -1 }); // Sort by priority (highest first)
+queueSchema.index({ departmentId: 1 }); // Filter by department
+queueSchema.index({ isActive: 1, priority: -1 }); // Compound: active + priority
+const QueueModel = mongoose.model("Queue", queueSchema);
+export default QueueModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamatix/gb-schemas",
-  "version": "2.3.288",
+  "version": "2.3.290",
   "description": "All the schemas for gatehouse bank back-end",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,7 +35,7 @@
   },
   "homepage": "https://github.com/DynamatixAnalyticsPvtLtd/gb-schemas#readme",
   "dependencies": {
-    "@dynamatix/cat-shared": "^0.0.127",
+    "@dynamatix/cat-shared": "^0.0.129",
     "dotenv": "^16.4.5",
     "mongodb": "^6.14.2",
     "mongoose": "^8.9.5"