pristine-member-nest-api-database 1.0.53 → 1.0.55

package/dist/index.js

@@ -33,9 +33,10 @@ __exportStar(require("./models/Member.model"), exports);
 __exportStar(require("./models/MembershipStatus.model"), exports);
 __exportStar(require("./models/MembershipType.model"), exports);
 __exportStar(require("./models/NatureOfBusiness.model"), exports);
+__exportStar(require("./models/ProductsServices.model"), exports);
+__exportStar(require("./models/MainProductOrServices.model"), exports);
 __exportStar(require("./models/OrganizationTypesMaster.model"), exports);
 __exportStar(require("./models/payment.model"), exports);
-__exportStar(require("./models/ProductsServices.model"), exports);
 __exportStar(require("./models/SeatingArrangement.ir.model"), exports);
 __exportStar(require("./models/ServiceRequest.ir.model"), exports);
 __exportStar(require("./models/User.model"), exports);

package/dist/interface/IApplicationCategory.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interface/IApplicationFiels.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Containers.model.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Container = void 0;
+exports.mongoContainer = void 0;
 const mongoose_1 = __importStar(require("mongoose"));
 const ContainerSchema = new mongoose_1.Schema({
     ContainerCode: { type: String },
@@ -39,5 +39,5 @@ const ContainerSchema = new mongoose_1.Schema({
         },
     ],
 });
-const Container = mongoose_1.default.model("Editor.Container", ContainerSchema);
-exports.Container = Container;
+const mongoContainer = mongoose_1.default.model("Editor.Container", ContainerSchema);
+exports.mongoContainer = mongoContainer;

package/dist/models/Editor.Application.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/Editor.BPCompany.Types.js

@@ -0,0 +1,43 @@
+"use strict";
+// Editor.BPCompany.Types.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoBpCompanySchema = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const BPCompanyTypesSchema = new mongoose_1.Schema({
+    BPCompanyTypeName: { type: String, required: true },
+    BPCompanyTypeCode: { type: mongoose_1.Schema.Types.ObjectId, ref: "Field.Categories" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoBpCompanySchema = mongoose_1.default.model("Editor.BPCompany.Types", BPCompanyTypesSchema);
+exports.mongoBpCompanySchema = mongoBpCompanySchema;

package/dist/models/Editor.BPcompanyTpes.Branch.Field.Category.Mapping.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoBranchBpCompanyTypesFieldCategoryMappingSchema = void 0;
+// Editor.BPcompanyTpes.Branch.Field.Category.Mapping.ts
+const mongoose_1 = __importStar(require("mongoose"));
+const BranchCompanyTypesFieldCategoryMappingSchema = new mongoose_1.Schema({
+    BranchId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Branch" },
+    companyTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Editor.BPCompany.Types",
+    },
+    categoryId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoBranchBpCompanyTypesFieldCategoryMappingSchema = mongoose_1.default.model("Editor.Branch.CompanyTypes.Field.Category.Mapping", BranchCompanyTypesFieldCategoryMappingSchema);
+exports.mongoBranchBpCompanyTypesFieldCategoryMappingSchema = mongoBranchBpCompanyTypesFieldCategoryMappingSchema;

package/dist/models/Editor.PureStatic.Category.Field.Mapping.js

@@ -0,0 +1,43 @@
+"use strict";
+//Editor.PureStaticFieldsMapping.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongopureStaticFieldMappingSchema = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const pureStaticFieldMappingSchema = new mongoose_1.Schema({
+    categoryId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongopureStaticFieldMappingSchema = mongoose_1.default.model("Editor.PureStatic.Category.Field.Mapping", pureStaticFieldMappingSchema);
+exports.mongopureStaticFieldMappingSchema = mongopureStaticFieldMappingSchema;

package/dist/models/Editor.SLIITO.Category.Field.Mapping.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoSLITOCategoryFieldMappingSchema = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const SLITOCategoryFieldMappingSchema = new mongoose_1.Schema({
+    categoryId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    membershipTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Membership.Types",
+    },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoSLITOCategoryFieldMappingSchema = mongoose_1.default.model("Editor.SLITO.Category.Field.Mapping", SLITOCategoryFieldMappingSchema);
+exports.mongoSLITOCategoryFieldMappingSchema = mongoSLITOCategoryFieldMappingSchema;

package/dist/models/Editor.StaticVariable.Category.Field.Mapping.js

@@ -0,0 +1,43 @@
+"use strict";
+//Editor.PureStaticFieldsMapping.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongostaticVariableFieldMappingSchema = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const staticVariableFieldMappingSchema = new mongoose_1.Schema({
+    categoryId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongostaticVariableFieldMappingSchema = mongoose_1.default.model("Editor.StaticVariable.Category.Field.Mapping", staticVariableFieldMappingSchema);
+exports.mongostaticVariableFieldMappingSchema = mongostaticVariableFieldMappingSchema;

package/dist/models/EditorFieldMaster.model.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoEditorField = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const fieldSchema = new mongoose_1.Schema({
+    fieldCode: { type: String },
+    fieldName: { type: String },
+    FieldTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Field.Types", // Reference to the 'Container' model
+        required: false,
+        default: null,
+    },
+    ManagerEdit: { type: Boolean, default: false },
+    MemberEdit: { type: Boolean, default: false },
+    SapSync: { type: Boolean, default: false },
+    Mandatory: { type: Boolean, default: false },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoEditorField = mongoose_1.default.model("Editor.Fields.Master", fieldSchema);
+exports.mongoEditorField = mongoEditorField;

package/dist/models/FieldCategory.model.js

@@ -29,12 +29,6 @@ const fieldCategorySchema = new mongoose_1.Schema({
     fieldUUId: { type: String },
     fieldCategoryCode: { type: String },
     fieldCategoryName: { type: String },
-    containerId: {
-        type: mongoose_1.Schema.Types.ObjectId,
-        ref: "Editor.Container", // Reference to the 'Container' model
-        required: false,
-        default: null,
-    },
     isSystemDefined: { type: Boolean, default: false },
     isActive: { type: Boolean, default: true },
     audit: [

package/dist/models/FieldTypes.model.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoEditorFieldType = exports.FieldTypeEnum = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+/* =========================
+   FIELD TYPE ENUM
+========================= */
+var FieldTypeEnum;
+(function (FieldTypeEnum) {
+    FieldTypeEnum["TEXT"] = "TEXT";
+    FieldTypeEnum["NUMBER"] = "NUMBER";
+    FieldTypeEnum["CHECKBOX"] = "CHECKBOX";
+    FieldTypeEnum["DROPDOWN"] = "DROPDOWN";
+    FieldTypeEnum["TABLE"] = "TABLE";
+    FieldTypeEnum["MATRIX"] = "MATRIX";
+})(FieldTypeEnum || (exports.FieldTypeEnum = FieldTypeEnum = {}));
+/* =========================
+   SCHEMA
+========================= */
+const fieldSchema = new mongoose_1.Schema({
+    fieldTypeCode: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    fieldEnum: {
+        type: String,
+        required: true,
+        enum: Object.values(FieldTypeEnum), // store only enum values
+    },
+    fieldTypeName: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    fieldTypeDescription: {
+        type: String,
+        trim: true,
+    },
+    config: {
+        type: mongoose_1.Schema.Types.Mixed,
+        default: {},
+    },
+    isSystemDefined: {
+        type: Boolean,
+        default: false,
+    },
+    isActive: {
+        type: Boolean,
+        default: true,
+    },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+}, {
+    timestamps: true,
+});
+/* =========================
+   MODEL
+========================= */
+exports.mongoEditorFieldType = mongoose_1.default.model("Editor.FieldType", fieldSchema);

package/dist/models/MainProductOrServices.model.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoMainProductsOrServicesMaster = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const MainProductsOrServicesMasterSchema = new mongoose_1.Schema({
+    MainProductsOrServicesMasterCode: { type: String },
+    MainProductsOrServicesName: { type: String },
+    prodcutServiceId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Products.ServicesMaster", // Reference to the 'Products.ServicesMaster' model
+        required: false,
+        default: null,
+    },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoMainProductsOrServicesMaster = mongoose_1.default.model("MainProductsOrServices.Master", MainProductsOrServicesMasterSchema);
+exports.mongoMainProductsOrServicesMaster = mongoMainProductsOrServicesMaster;

package/dist/models/MembershipType.model.js

@@ -29,11 +29,13 @@ const membershipTypeSchema = new mongoose_1.Schema({
     membershipTypeCode: { type: String },
     membershipTypeName: { type: String },
     isActive: { type: Boolean, default: true },
-    audit: [{
+    audit: [
+        {
             userId: { type: String },
             auditedOn: { type: Date, default: Date.now() },
-            actionType: { type: String }
-        }]
+            actionType: { type: String },
+        },
+    ],
 });
-const mongoMembershipType = mongoose_1.default.model('Membership.Types', membershipTypeSchema);
+const mongoMembershipType = mongoose_1.default.model("Membership.Types", membershipTypeSchema);
 exports.mongoMembershipType = mongoMembershipType;

package/dist/models/ProductsServices.model.js

@@ -28,6 +28,12 @@ const mongoose_1 = __importStar(require("mongoose"));
 const ProductsAndServicesMasterSchema = new mongoose_1.Schema({
     ProductsAndServicesMasterCode: { type: String },
     ProductsAndServicesMasterName: { type: String },
+    NatureOfBusinessId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "NatureOfBusiness.Master", // Reference to the 'NatureOfBusiness' model
+        required: false,
+        default: null,
+    },
     isActive: { type: Boolean, default: true },
     audit: [
         {

package/index.ts

@@ -17,9 +17,11 @@ export * from "./models/Member.model";
 export * from "./models/MembershipStatus.model";
 export * from "./models/MembershipType.model";
 export * from "./models/NatureOfBusiness.model";
+export * from "./models/ProductsServices.model";
+export * from "./models/MainProductOrServices.model";
+
 export * from "./models/OrganizationTypesMaster.model";
 export * from "./models/payment.model";
-export * from "./models/ProductsServices.model";
 export * from "./models/SeatingArrangement.ir.model";
 export * from "./models/ServiceRequest.ir.model";
 export * from "./models/User.model";

package/interface/IApplicationCategory.interface.ts

@@ -0,0 +1,8 @@
+import { Types } from "mongoose";
+import IFieldApplication from "./IApplicationFiels.interface";
+
+export default interface IApplicationCategory {
+  categoryId: Types.ObjectId;
+  categorySequence: number;
+  fields: IFieldApplication[];
+}

package/interface/IApplicationFiels.interface.ts

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+
+/**
+ * Interface for a appication fields
+ */
+
+export default interface IFieldApplication {
+  fieldId: mongoose.Types.ObjectId;
+  fieldSequence: number;
+  fieldDescription: string;
+}

package/interface/IField.interface.ts

@@ -4,6 +4,7 @@ import IFile from "./IFile.interface";
 /**
  * Interface for a fields contains in a category
  */
+
 export default interface IField {
   fieldSequence: number;
   fieldCode: string;

package/models/Containers.model.ts

@@ -26,9 +26,9 @@ const ContainerSchema = new Schema<ContainerDocument>({
   ],
 });
 
-const Container = mongoose.model<ContainerDocument>(
+const mongoContainer = mongoose.model<ContainerDocument>(
   "Editor.Container",
   ContainerSchema,
 );
 
-export { ContainerDocument, Container };
+export { ContainerDocument, mongoContainer };

package/models/DynamicTemplate.model.ts

@@ -139,7 +139,7 @@ const dynamicTemplateModel = mongoose.model<IDynamicTemplateDocument>(
         actionType: { type: String },
       },
     ],
-  })
+  }),
 );
 
 export { dynamicTemplateModel, IDynamicTemplateDocument };

package/models/Editor.Application.model.ts

@@ -0,0 +1,20 @@
+import mongoose, { Document, Schema, Types } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+import IApplicationCategory from "../interface/IApplicationCategory.interface";
+
+/**
+ * Interface for Full Application Creation
+ */
+
+interface IApplicationDocument extends Document {
+  branchId: Types.ObjectId;
+  applicationName: string;
+  applicationDescription: string;
+  categories: IApplicationCategory[];
+  SLITOOptionEnabled: boolean;
+  organizationApplicationEnabled: boolean;
+  approverOneEnabled: boolean;
+  approverTwoEnabled: boolean;
+  createdDate: Schema.Types.Date;
+  audit: Audit[];
+}

package/models/Editor.BPCompany.Types.ts

@@ -0,0 +1,33 @@
+// Editor.BPCompany.Types.ts
+
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface BPCompanyTypes extends Document {
+  BPCompanyTypeName: string;
+  BPCompanyTypeCode: mongoose.Types.ObjectId;
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const BPCompanyTypesSchema = new Schema<BPCompanyTypes>({
+  BPCompanyTypeName: { type: String, required: true },
+  BPCompanyTypeCode: { type: Schema.Types.ObjectId, ref: "Field.Categories" },
+  isSystemDefined: { type: Boolean, default: false },
+  isActive: { type: Boolean, default: true },
+  audit: [
+    {
+      userId: { type: String },
+      auditedOn: { type: Date, default: null },
+      actionType: { type: String },
+    },
+  ],
+});
+
+const mongoBpCompanySchema = mongoose.model<BPCompanyTypes>(
+  "Editor.BPCompany.Types",
+  BPCompanyTypesSchema,
+);
+
+export { BPCompanyTypes, mongoBpCompanySchema };

package/models/Editor.BPcompanyTpes.Branch.Field.Category.Mapping.ts

@@ -0,0 +1,45 @@
+// Editor.BPcompanyTpes.Branch.Field.Category.Mapping.ts
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface BranchCompanyTypesFieldCategoryMapping extends Document {
+  BranchId: mongoose.Types.ObjectId;
+  companyTypeId: mongoose.Types.ObjectId;
+  categoryId: mongoose.Types.ObjectId;
+  fieldId: mongoose.Types.ObjectId;
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const BranchCompanyTypesFieldCategoryMappingSchema =
+  new Schema<BranchCompanyTypesFieldCategoryMapping>({
+    BranchId: { type: Schema.Types.ObjectId, ref: "Branch" },
+    companyTypeId: {
+      type: Schema.Types.ObjectId,
+      ref: "Editor.BPCompany.Types",
+    },
+    categoryId: { type: Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+      {
+        userId: { type: String },
+        auditedOn: { type: Date, default: null },
+        actionType: { type: String },
+      },
+    ],
+  });
+
+const mongoBranchBpCompanyTypesFieldCategoryMappingSchema =
+  mongoose.model<BranchCompanyTypesFieldCategoryMapping>(
+    "Editor.Branch.CompanyTypes.Field.Category.Mapping",
+    BranchCompanyTypesFieldCategoryMappingSchema,
+  );
+
+export {
+  BranchCompanyTypesFieldCategoryMapping,
+  mongoBranchBpCompanyTypesFieldCategoryMappingSchema,
+};

package/models/Editor.PureStatic.Category.Field.Mapping.ts

@@ -0,0 +1,35 @@
+//Editor.PureStaticFieldsMapping.ts
+
+import mongoose, { Document, ObjectId, Schema, Types } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface PureStaticFieldsCategoryMapping extends Document {
+  categoryId: mongoose.Types.ObjectId;
+  fieldId: mongoose.Types.ObjectId;
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const pureStaticFieldMappingSchema =
+  new Schema<PureStaticFieldsCategoryMapping>({
+    categoryId: { type: Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+      {
+        userId: { type: String },
+        auditedOn: { type: Date, default: null },
+        actionType: { type: String },
+      },
+    ],
+  });
+
+const mongopureStaticFieldMappingSchema =
+  mongoose.model<PureStaticFieldsCategoryMapping>(
+    "Editor.PureStatic.Category.Field.Mapping",
+    pureStaticFieldMappingSchema,
+  );
+
+export { PureStaticFieldsCategoryMapping, mongopureStaticFieldMappingSchema };

package/models/Editor.SLIITO.Category.Field.Mapping.ts

@@ -0,0 +1,37 @@
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface SLITOCategoryFieldMapping extends Document {
+  categoryId: mongoose.Types.ObjectId;
+  fieldId: mongoose.Types.ObjectId;
+  membershipTypeId: mongoose.Types.ObjectId;
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const SLITOCategoryFieldMappingSchema = new Schema<SLITOCategoryFieldMapping>({
+  categoryId: { type: Schema.Types.ObjectId, ref: "Field.Categories" },
+  fieldId: { type: Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+  membershipTypeId: {
+    type: Schema.Types.ObjectId,
+    ref: "Membership.Types",
+  },
+  isSystemDefined: { type: Boolean, default: false },
+  isActive: { type: Boolean, default: true },
+  audit: [
+    {
+      userId: { type: String },
+      auditedOn: { type: Date, default: null },
+      actionType: { type: String },
+    },
+  ],
+});
+
+const mongoSLITOCategoryFieldMappingSchema =
+  mongoose.model<SLITOCategoryFieldMapping>(
+    "Editor.SLITO.Category.Field.Mapping",
+    SLITOCategoryFieldMappingSchema,
+  );
+
+export { SLITOCategoryFieldMapping, mongoSLITOCategoryFieldMappingSchema };

package/models/Editor.StaticVariable.Category.Field.Mapping.ts

@@ -0,0 +1,38 @@
+//Editor.PureStaticFieldsMapping.ts
+
+import mongoose, { Document, ObjectId, Schema, Types } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface StaticVariableFieldsCategoryMapping extends Document {
+  categoryId: mongoose.Types.ObjectId;
+  fieldId: mongoose.Types.ObjectId;
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const staticVariableFieldMappingSchema =
+  new Schema<StaticVariableFieldsCategoryMapping>({
+    categoryId: { type: Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+      {
+        userId: { type: String },
+        auditedOn: { type: Date, default: null },
+        actionType: { type: String },
+      },
+    ],
+  });
+
+const mongostaticVariableFieldMappingSchema =
+  mongoose.model<StaticVariableFieldsCategoryMapping>(
+    "Editor.StaticVariable.Category.Field.Mapping",
+    staticVariableFieldMappingSchema,
+  );
+
+export {
+  StaticVariableFieldsCategoryMapping,
+  mongostaticVariableFieldMappingSchema,
+};

package/models/EditorFieldMaster.model.ts

@@ -0,0 +1,46 @@
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface EditorField extends Document {
+  fieldCode: string;
+  fieldName: string;
+  FieldTypeId: mongoose.Types.ObjectId;
+  isSystemDefined: boolean;
+  SapSync: boolean;
+  MemberEdit: boolean;
+  ManagerEdit: boolean;
+  Mandatory: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const fieldSchema = new Schema<EditorField>({
+  fieldCode: { type: String },
+  fieldName: { type: String },
+  FieldTypeId: {
+    type: Schema.Types.ObjectId,
+    ref: "Field.Types", // Reference to the 'Container' model
+    required: false,
+    default: null,
+  },
+  ManagerEdit: { type: Boolean, default: false },
+  MemberEdit: { type: Boolean, default: false },
+  SapSync: { type: Boolean, default: false },
+  Mandatory: { type: Boolean, default: false },
+  isSystemDefined: { type: Boolean, default: false },
+  isActive: { type: Boolean, default: true },
+  audit: [
+    {
+      userId: { type: String },
+      auditedOn: { type: Date, default: null },
+      actionType: { type: String },
+    },
+  ],
+});
+
+const mongoEditorField = mongoose.model<EditorField>(
+  "Editor.Fields.Master",
+  fieldSchema,
+);
+
+export { EditorField, mongoEditorField };

package/models/FieldCategory.model.ts

@@ -5,7 +5,6 @@ interface FieldCategoryDocument extends Document {
   fieldUUId: string;
   fieldCategoryCode: string;
   fieldCategoryName: string;
-  containerId: mongoose.Types.ObjectId;
   isSystemDefined: boolean;
   isActive: boolean;
   audit: Audit[];
@@ -15,12 +14,6 @@ const fieldCategorySchema = new Schema<FieldCategoryDocument>({
   fieldUUId: { type: String },
   fieldCategoryCode: { type: String },
   fieldCategoryName: { type: String },
-  containerId: {
-    type: Schema.Types.ObjectId,
-    ref: "Editor.Container", // Reference to the 'Container' model
-    required: false,
-    default: null,
-  },
   isSystemDefined: { type: Boolean, default: false },
   isActive: { type: Boolean, default: true },
   audit: [

package/models/FieldTypes.model.ts

@@ -0,0 +1,154 @@
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+/* =========================
+   FIELD TYPE ENUM
+========================= */
+export enum FieldTypeEnum {
+  TEXT = "TEXT",
+  NUMBER = "NUMBER",
+  CHECKBOX = "CHECKBOX",
+  DROPDOWN = "DROPDOWN",
+  TABLE = "TABLE",
+  MATRIX = "MATRIX",
+}
+
+/* =========================
+   CONFIG INTERFACES
+========================= */
+
+// TEXT
+export interface TextFieldConfig {
+  maxLength?: number;
+  minLength?: number;
+  placeholder?: string;
+}
+
+// OPTIONS (checkbox / dropdown)
+export interface OptionConfig {
+  value: string;
+  label: string;
+}
+
+export interface OptionFieldConfig {
+  options: OptionConfig[];
+  allowMultiple?: boolean;
+}
+
+// TABLE
+export interface TableColumn {
+  columnId: string;
+  label: string;
+  type: string; // can be dynamic
+  required?: boolean;
+}
+
+export interface TableFieldConfig {
+  columns: TableColumn[];
+  minRows?: number;
+  maxRows?: number;
+}
+
+// MATRIX
+export interface MatrixRow {
+  rowId: string;
+  label: string;
+}
+
+export interface MatrixColumn {
+  columnId: string;
+  label: string;
+  type: string; // can be dynamic
+}
+
+export interface MatrixFieldConfig {
+  rows: MatrixRow[];
+  columns: MatrixColumn[];
+}
+
+/* =========================
+   UNION CONFIG TYPE
+========================= */
+export type FieldConfig =
+  | TextFieldConfig
+  | OptionFieldConfig
+  | TableFieldConfig
+  | MatrixFieldConfig;
+
+/* =========================
+   MAIN DOCUMENT INTERFACE
+========================= */
+export interface EditorFieldType extends Document {
+  fieldTypeCode: string; // dynamic string code
+  fieldEnum: FieldTypeEnum; // holds enum value
+  fieldTypeName: string;
+  fieldTypeDescription?: string;
+  config: FieldConfig;
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+/* =========================
+   SCHEMA
+========================= */
+const fieldSchema = new Schema<EditorFieldType>(
+  {
+    fieldTypeCode: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+
+    fieldEnum: {
+      type: String,
+      required: true,
+      enum: Object.values(FieldTypeEnum), // store only enum values
+    },
+
+    fieldTypeName: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+
+    fieldTypeDescription: {
+      type: String,
+      trim: true,
+    },
+
+    config: {
+      type: Schema.Types.Mixed,
+      default: {},
+    },
+
+    isSystemDefined: {
+      type: Boolean,
+      default: false,
+    },
+
+    isActive: {
+      type: Boolean,
+      default: true,
+    },
+
+    audit: [
+      {
+        userId: { type: String },
+        auditedOn: { type: Date, default: null },
+        actionType: { type: String },
+      },
+    ],
+  },
+  {
+    timestamps: true,
+  },
+);
+
+/* =========================
+   MODEL
+========================= */
+export const mongoEditorFieldType = mongoose.model<EditorFieldType>(
+  "Editor.FieldType",
+  fieldSchema,
+);

package/models/MainProductOrServices.model.ts

@@ -0,0 +1,41 @@
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface MainProductsOrServicesMasterDocument extends Document {
+  MainProductsOrServicesMasterCode: string;
+  MainProductsOrServicesName: string;
+  prodcutServiceId: mongoose.Types.ObjectId;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const MainProductsOrServicesMasterSchema =
+  new Schema<MainProductsOrServicesMasterDocument>({
+    MainProductsOrServicesMasterCode: { type: String },
+    MainProductsOrServicesName: { type: String },
+    prodcutServiceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Products.ServicesMaster", // Reference to the 'Products.ServicesMaster' model
+      required: false,
+      default: null,
+    },
+    isActive: { type: Boolean, default: true },
+    audit: [
+      {
+        userId: { type: String },
+        auditedOn: { type: Date, default: null },
+        actionType: { type: String },
+      },
+    ],
+  });
+
+const mongoMainProductsOrServicesMaster =
+  mongoose.model<MainProductsOrServicesMasterDocument>(
+    "MainProductsOrServices.Master",
+    MainProductsOrServicesMasterSchema,
+  );
+
+export {
+  MainProductsOrServicesMasterDocument,
+  mongoMainProductsOrServicesMaster,
+};

package/models/MembershipType.model.ts

@@ -1,5 +1,5 @@
-import mongoose, { Document, Schema } from 'mongoose';
-import { Audit } from '../interface/Audit.interface';
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
 
 interface MembershipTypeDocument extends Document {
   membershipTypeCode: string;
@@ -12,13 +12,18 @@ const membershipTypeSchema = new Schema<MembershipTypeDocument>({
   membershipTypeCode: { type: String },
   membershipTypeName: { type: String },
   isActive: { type: Boolean, default: true },
-  audit: [{
-    userId: { type: String },
-    auditedOn: { type: Date, default: Date.now() },
-    actionType: { type: String }
-  }]
+  audit: [
+    {
+      userId: { type: String },
+      auditedOn: { type: Date, default: Date.now() },
+      actionType: { type: String },
+    },
+  ],
 });
 
-const mongoMembershipType = mongoose.model<MembershipTypeDocument>('Membership.Types', membershipTypeSchema);
+const mongoMembershipType = mongoose.model<MembershipTypeDocument>(
+  "Membership.Types",
+  membershipTypeSchema,
+);
 
 export { MembershipTypeDocument, mongoMembershipType };

package/models/ProductsServices.model.ts

@@ -4,6 +4,7 @@ import { Audit } from "../interface/Audit.interface";
 interface ProductsAndServicesMasterDocument extends Document {
   ProductsAndServicesMasterCode: string;
   ProductsAndServicesMasterName: string;
+  NatureOfBusinessId: mongoose.Types.ObjectId;
   isActive: boolean;
   audit: Audit[];
 }
@@ -12,6 +13,12 @@ const ProductsAndServicesMasterSchema =
   new Schema<ProductsAndServicesMasterDocument>({
     ProductsAndServicesMasterCode: { type: String },
     ProductsAndServicesMasterName: { type: String },
+    NatureOfBusinessId: {
+      type: Schema.Types.ObjectId,
+      ref: "NatureOfBusiness.Master", // Reference to the 'NatureOfBusiness' model
+      required: false,
+      default: null,
+    },
     isActive: { type: Boolean, default: true },
     audit: [
       {
@@ -25,7 +32,7 @@ const ProductsAndServicesMasterSchema =
 const mongoProductsAndServicesMaster =
   mongoose.model<ProductsAndServicesMasterDocument>(
     "Products.ServicesMaster",
-    ProductsAndServicesMasterSchema
+    ProductsAndServicesMasterSchema,
   );
 
 export { ProductsAndServicesMasterDocument, mongoProductsAndServicesMaster };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pristine-member-nest-api-database",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "description": "application verification database changes with gs1 branch. not tested. ",
   "main": "dist/index.js",
   "scripts": {