cloud-ide-model-schema 1.1.108 → 1.1.109

package/lib/schema/index.d.ts

@@ -6,3 +6,4 @@ export * from "./accounts";
 export * from "./frontdesk";
 export * from "./admission";
 export * from "./notifications";
+export * from "./system";

package/lib/schema/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./accounts"), exports);
 __exportStar(require("./frontdesk"), exports);
 __exportStar(require("./admission"), exports);
 __exportStar(require("./notifications"), exports);
+__exportStar(require("./system"), exports);

package/lib/schema/system/api_keys.d.ts

@@ -0,0 +1,26 @@
+import mongoose from "mongoose";
+export interface IApiKey {
+    _id?: string;
+    akey_name: string;
+    akey_api_key: string;
+    akey_api_secret?: string;
+    akey_permissions: string[];
+    akey_rate_limit?: {
+        requests_per_minute?: number;
+        requests_per_hour?: number;
+        requests_per_day?: number;
+    };
+    akey_expiry_date?: Date;
+    akey_last_used?: Date;
+    akey_status: 'active' | 'revoked' | 'expired';
+    akey_created_by?: string;
+    akey_created_at?: Date;
+    akey_updated_at?: Date;
+    akey_isactive?: boolean;
+}
+declare const CApiKey: mongoose.Model<IApiKey, {}, {}, {}, mongoose.Document<unknown, {}, IApiKey, {}> & IApiKey & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CApiKey };

package/lib/schema/system/api_keys.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CApiKey = void 0;
+var mongoose_1 = require("mongoose");
+var api_keys = new mongoose_1.Schema({
+    akey_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true
+    },
+    akey_api_key: {
+        type: String,
+        required: true,
+        maxlength: 500,
+        unique: true
+    },
+    akey_api_secret: {
+        type: String,
+        maxlength: 500
+    },
+    akey_permissions: {
+        type: [String],
+        default: []
+    },
+    akey_rate_limit: {
+        requests_per_minute: {
+            type: Number,
+            min: 0
+        },
+        requests_per_hour: {
+            type: Number,
+            min: 0
+        },
+        requests_per_day: {
+            type: Number,
+            min: 0
+        }
+    },
+    akey_expiry_date: {
+        type: Date
+    },
+    akey_last_used: {
+        type: Date
+    },
+    akey_status: {
+        type: String,
+        required: true,
+        enum: ['active', 'revoked', 'expired'],
+        default: 'active',
+        index: true
+    },
+    akey_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    akey_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    akey_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    akey_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'api_keys', timestamps: { createdAt: 'akey_created_at', updatedAt: 'akey_updated_at' } });
+// Indexes
+api_keys.index({ akey_name: 1 });
+api_keys.index({ akey_status: 1 });
+api_keys.index({ akey_api_key: 1 });
+var CApiKey = mongoose_1.default.model("api_keys", api_keys);
+exports.CApiKey = CApiKey;

package/lib/schema/system/backup_jobs.d.ts

@@ -0,0 +1,39 @@
+import mongoose from "mongoose";
+export interface IBackupJob {
+    _id?: string;
+    bjob_name: string;
+    bjob_backup_type: 'full' | 'incremental' | 'differential' | 'file';
+    bjob_schedule: {
+        frequency: 'daily' | 'weekly' | 'monthly' | 'hourly' | 'manual';
+        time?: string;
+        day_of_week?: number;
+        day_of_month?: number;
+    };
+    bjob_status: 'active' | 'paused' | 'disabled';
+    bjob_last_run?: Date;
+    bjob_next_run?: Date;
+    bjob_retention_days: number;
+    bjob_encryption_enabled: boolean;
+    bjob_compression_enabled: boolean;
+    bjob_storage_location: 'local' | 'cloud' | 'both';
+    bjob_cloud_provider?: 'aws' | 'azure' | 'gcp';
+    bjob_cloud_config?: {
+        bucket_name?: string;
+        region?: string;
+        access_key?: string;
+    };
+    bjob_include_collections?: string[];
+    bjob_exclude_collections?: string[];
+    bjob_include_files?: boolean;
+    bjob_file_paths?: string[];
+    bjob_created_by?: string;
+    bjob_created_at?: Date;
+    bjob_updated_at?: Date;
+    bjob_isactive?: boolean;
+}
+declare const CBackupJob: mongoose.Model<IBackupJob, {}, {}, {}, mongoose.Document<unknown, {}, IBackupJob, {}> & IBackupJob & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CBackupJob };

package/lib/schema/system/backup_jobs.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CBackupJob = void 0;
+var mongoose_1 = require("mongoose");
+var backup_jobs = new mongoose_1.Schema({
+    bjob_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true,
+        unique: true
+    },
+    bjob_backup_type: {
+        type: String,
+        required: true,
+        enum: ['full', 'incremental', 'differential', 'file'],
+        trim: true
+    },
+    bjob_schedule: {
+        frequency: {
+            type: String,
+            required: true,
+            enum: ['daily', 'weekly', 'monthly', 'hourly', 'manual']
+        },
+        time: {
+            type: String,
+            maxlength: 5
+        },
+        day_of_week: {
+            type: Number,
+            min: 0,
+            max: 6
+        },
+        day_of_month: {
+            type: Number,
+            min: 1,
+            max: 31
+        }
+    },
+    bjob_status: {
+        type: String,
+        required: true,
+        enum: ['active', 'paused', 'disabled'],
+        default: 'active'
+    },
+    bjob_last_run: {
+        type: Date
+    },
+    bjob_next_run: {
+        type: Date
+    },
+    bjob_retention_days: {
+        type: Number,
+        required: true,
+        default: 30,
+        min: 1
+    },
+    bjob_encryption_enabled: {
+        type: Boolean,
+        default: false
+    },
+    bjob_compression_enabled: {
+        type: Boolean,
+        default: true
+    },
+    bjob_storage_location: {
+        type: String,
+        required: true,
+        enum: ['local', 'cloud', 'both'],
+        default: 'local'
+    },
+    bjob_cloud_provider: {
+        type: String,
+        enum: ['aws', 'azure', 'gcp']
+    },
+    bjob_cloud_config: {
+        type: Object
+    },
+    bjob_include_collections: {
+        type: [String]
+    },
+    bjob_exclude_collections: {
+        type: [String]
+    },
+    bjob_include_files: {
+        type: Boolean,
+        default: false
+    },
+    bjob_file_paths: {
+        type: [String]
+    },
+    bjob_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    bjob_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    bjob_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    bjob_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'backup_jobs', timestamps: { createdAt: 'bjob_created_at', updatedAt: 'bjob_updated_at' } });
+// Indexes
+backup_jobs.index({ bjob_name: 1 });
+backup_jobs.index({ bjob_status: 1 });
+backup_jobs.index({ bjob_next_run: 1 });
+var CBackupJob = mongoose_1.default.model("backup_jobs", backup_jobs);
+exports.CBackupJob = CBackupJob;

package/lib/schema/system/backup_policies.d.ts

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+export interface IBackupPolicy {
+    _id?: string;
+    bpol_name: string;
+    bpol_retention_days: number;
+    bpol_backup_frequency: 'hourly' | 'daily' | 'weekly' | 'monthly';
+    bpol_encryption_enabled: boolean;
+    bpol_compression_enabled: boolean;
+    bpol_auto_cleanup: boolean;
+    bpol_notification_enabled: boolean;
+    bpol_notification_emails?: string[];
+    bpol_description?: string;
+    bpol_created_by?: string;
+    bpol_created_at?: Date;
+    bpol_updated_at?: Date;
+    bpol_isactive?: boolean;
+}
+declare const CBackupPolicy: mongoose.Model<IBackupPolicy, {}, {}, {}, mongoose.Document<unknown, {}, IBackupPolicy, {}> & IBackupPolicy & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CBackupPolicy };

package/lib/schema/system/backup_policies.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CBackupPolicy = void 0;
+var mongoose_1 = require("mongoose");
+var backup_policies = new mongoose_1.Schema({
+    bpol_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true,
+        unique: true
+    },
+    bpol_retention_days: {
+        type: Number,
+        required: true,
+        default: 30,
+        min: 1
+    },
+    bpol_backup_frequency: {
+        type: String,
+        required: true,
+        enum: ['hourly', 'daily', 'weekly', 'monthly']
+    },
+    bpol_encryption_enabled: {
+        type: Boolean,
+        default: false
+    },
+    bpol_compression_enabled: {
+        type: Boolean,
+        default: true
+    },
+    bpol_auto_cleanup: {
+        type: Boolean,
+        default: true
+    },
+    bpol_notification_enabled: {
+        type: Boolean,
+        default: true
+    },
+    bpol_notification_emails: {
+        type: [String]
+    },
+    bpol_description: {
+        type: String,
+        maxlength: 500
+    },
+    bpol_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    bpol_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    bpol_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    bpol_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'backup_policies', timestamps: { createdAt: 'bpol_created_at', updatedAt: 'bpol_updated_at' } });
+// Indexes
+backup_policies.index({ bpol_name: 1 });
+backup_policies.index({ bpol_isactive: 1 });
+var CBackupPolicy = mongoose_1.default.model("backup_policies", backup_policies);
+exports.CBackupPolicy = CBackupPolicy;

package/lib/schema/system/backup_records.d.ts

@@ -0,0 +1,29 @@
+import mongoose from "mongoose";
+export interface IBackupRecord {
+    _id?: string;
+    brec_backup_job_id: string;
+    brec_backup_type: 'full' | 'incremental' | 'differential' | 'file';
+    brec_backup_path: string;
+    brec_file_name: string;
+    brec_size: number;
+    brec_status: 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    brec_verification_status: 'pending' | 'verified' | 'failed';
+    brec_started_at?: Date;
+    brec_completed_at?: Date;
+    brec_duration?: number;
+    brec_error_message?: string;
+    brec_metadata?: {
+        collections_backed_up?: string[];
+        collections_count?: number;
+        files_backed_up?: number;
+        compression_ratio?: number;
+    };
+    brec_created_at?: Date;
+    brec_isactive?: boolean;
+}
+declare const CBackupRecord: mongoose.Model<IBackupRecord, {}, {}, {}, mongoose.Document<unknown, {}, IBackupRecord, {}> & IBackupRecord & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CBackupRecord };

package/lib/schema/system/backup_records.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CBackupRecord = void 0;
+var mongoose_1 = require("mongoose");
+var backup_records = new mongoose_1.Schema({
+    brec_backup_job_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "backup_jobs",
+        required: true,
+        index: true
+    },
+    brec_backup_type: {
+        type: String,
+        required: true,
+        enum: ['full', 'incremental', 'differential', 'file']
+    },
+    brec_backup_path: {
+        type: String,
+        required: true,
+        maxlength: 500
+    },
+    brec_file_name: {
+        type: String,
+        required: true,
+        maxlength: 255
+    },
+    brec_size: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    brec_status: {
+        type: String,
+        required: true,
+        enum: ['in_progress', 'completed', 'failed', 'cancelled'],
+        default: 'in_progress',
+        index: true
+    },
+    brec_verification_status: {
+        type: String,
+        required: true,
+        enum: ['pending', 'verified', 'failed'],
+        default: 'pending'
+    },
+    brec_started_at: {
+        type: Date,
+        default: Date.now
+    },
+    brec_completed_at: {
+        type: Date
+    },
+    brec_duration: {
+        type: Number,
+        min: 0
+    },
+    brec_error_message: {
+        type: String,
+        maxlength: 1000
+    },
+    brec_metadata: {
+        type: Object
+    },
+    brec_created_at: {
+        type: Date,
+        default: Date.now,
+        index: true
+    },
+    brec_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'backup_records', timestamps: { createdAt: 'brec_created_at' } });
+// Indexes
+backup_records.index({ brec_backup_job_id: 1, brec_created_at: -1 });
+backup_records.index({ brec_status: 1 });
+backup_records.index({ brec_verification_status: 1 });
+var CBackupRecord = mongoose_1.default.model("backup_records", backup_records);
+exports.CBackupRecord = CBackupRecord;

package/lib/schema/system/index.d.ts

@@ -0,0 +1,12 @@
+export { CBackupJob, IBackupJob } from './backup_jobs';
+export { CBackupRecord, IBackupRecord } from './backup_records';
+export { CRecoveryOperation, IRecoveryOperation } from './recovery_operations';
+export { CBackupPolicy, IBackupPolicy } from './backup_policies';
+export { CIntegration, IIntegration } from './integrations';
+export { CApiKey, IApiKey } from './api_keys';
+export { CWebhook, IWebhook } from './webhooks';
+export { CIntegrationLog, IIntegrationLog } from './integration_logs';
+export { CSubscriptionPlan, ISubscriptionPlan } from './subscription_plans';
+export { CSubscriptionFeature, ISubscriptionFeature } from './subscription_features';
+export { CSubscription, ISubscription } from './subscriptions';
+export { CSubscriptionPayment, ISubscriptionPayment } from './subscription_payments';

package/lib/schema/system/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSubscriptionPayment = exports.CSubscription = exports.CSubscriptionFeature = exports.CSubscriptionPlan = exports.CIntegrationLog = exports.CWebhook = exports.CApiKey = exports.CIntegration = exports.CBackupPolicy = exports.CRecoveryOperation = exports.CBackupRecord = exports.CBackupJob = void 0;
+// System Module Schemas
+var backup_jobs_1 = require("./backup_jobs");
+Object.defineProperty(exports, "CBackupJob", { enumerable: true, get: function () { return backup_jobs_1.CBackupJob; } });
+var backup_records_1 = require("./backup_records");
+Object.defineProperty(exports, "CBackupRecord", { enumerable: true, get: function () { return backup_records_1.CBackupRecord; } });
+var recovery_operations_1 = require("./recovery_operations");
+Object.defineProperty(exports, "CRecoveryOperation", { enumerable: true, get: function () { return recovery_operations_1.CRecoveryOperation; } });
+var backup_policies_1 = require("./backup_policies");
+Object.defineProperty(exports, "CBackupPolicy", { enumerable: true, get: function () { return backup_policies_1.CBackupPolicy; } });
+var integrations_1 = require("./integrations");
+Object.defineProperty(exports, "CIntegration", { enumerable: true, get: function () { return integrations_1.CIntegration; } });
+var api_keys_1 = require("./api_keys");
+Object.defineProperty(exports, "CApiKey", { enumerable: true, get: function () { return api_keys_1.CApiKey; } });
+var webhooks_1 = require("./webhooks");
+Object.defineProperty(exports, "CWebhook", { enumerable: true, get: function () { return webhooks_1.CWebhook; } });
+var integration_logs_1 = require("./integration_logs");
+Object.defineProperty(exports, "CIntegrationLog", { enumerable: true, get: function () { return integration_logs_1.CIntegrationLog; } });
+var subscription_plans_1 = require("./subscription_plans");
+Object.defineProperty(exports, "CSubscriptionPlan", { enumerable: true, get: function () { return subscription_plans_1.CSubscriptionPlan; } });
+var subscription_features_1 = require("./subscription_features");
+Object.defineProperty(exports, "CSubscriptionFeature", { enumerable: true, get: function () { return subscription_features_1.CSubscriptionFeature; } });
+var subscriptions_1 = require("./subscriptions");
+Object.defineProperty(exports, "CSubscription", { enumerable: true, get: function () { return subscriptions_1.CSubscription; } });
+var subscription_payments_1 = require("./subscription_payments");
+Object.defineProperty(exports, "CSubscriptionPayment", { enumerable: true, get: function () { return subscription_payments_1.CSubscriptionPayment; } });

package/lib/schema/system/integration_logs.d.ts

@@ -0,0 +1,21 @@
+import mongoose from "mongoose";
+export interface IIntegrationLog {
+    _id?: string;
+    ilog_integration_id?: string;
+    ilog_operation: string;
+    ilog_status: 'success' | 'failed' | 'pending';
+    ilog_request_data?: any;
+    ilog_response_data?: any;
+    ilog_error_message?: string;
+    ilog_error_code?: string;
+    ilog_duration?: number;
+    ilog_retry_count?: number;
+    ilog_created_at?: Date;
+    ilog_isactive?: boolean;
+}
+declare const CIntegrationLog: mongoose.Model<IIntegrationLog, {}, {}, {}, mongoose.Document<unknown, {}, IIntegrationLog, {}> & IIntegrationLog & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CIntegrationLog };

package/lib/schema/system/integration_logs.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CIntegrationLog = void 0;
+var mongoose_1 = require("mongoose");
+var integration_logs = new mongoose_1.Schema({
+    ilog_integration_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "integrations",
+        index: true
+    },
+    ilog_operation: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        index: true
+    },
+    ilog_status: {
+        type: String,
+        required: true,
+        enum: ['success', 'failed', 'pending'],
+        default: 'pending',
+        index: true
+    },
+    ilog_request_data: {
+        type: Object
+    },
+    ilog_response_data: {
+        type: Object
+    },
+    ilog_error_message: {
+        type: String,
+        maxlength: 1000
+    },
+    ilog_error_code: {
+        type: String,
+        maxlength: 50
+    },
+    ilog_duration: {
+        type: Number,
+        min: 0
+    },
+    ilog_retry_count: {
+        type: Number,
+        default: 0,
+        min: 0
+    },
+    ilog_created_at: {
+        type: Date,
+        default: Date.now,
+        index: true
+    },
+    ilog_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'integration_logs', timestamps: { createdAt: 'ilog_created_at' } });
+// Indexes
+integration_logs.index({ ilog_integration_id: 1, ilog_created_at: -1 });
+integration_logs.index({ ilog_status: 1 });
+integration_logs.index({ ilog_operation: 1 });
+var CIntegrationLog = mongoose_1.default.model("integration_logs", integration_logs);
+exports.CIntegrationLog = CIntegrationLog;

package/lib/schema/system/integrations.d.ts

@@ -0,0 +1,31 @@
+import mongoose from "mongoose";
+export interface IIntegration {
+    _id?: string;
+    intg_name: string;
+    intg_type: 'payment_gateway' | 'shipping_carrier' | 'accounting_software' | 'ecommerce_platform' | 'sms_gateway' | 'email_service' | 'bank' | 'tax_service' | 'custom';
+    intg_provider: string;
+    intg_api_key?: string;
+    intg_api_secret?: string;
+    intg_merchant_id?: string;
+    intg_status: 'active' | 'inactive' | 'testing';
+    intg_configuration?: {
+        endpoint?: string;
+        webhook_url?: string;
+        timeout?: number;
+        retry_count?: number;
+        [key: string]: any;
+    };
+    intg_test_mode: boolean;
+    intg_last_sync?: Date;
+    intg_sync_frequency?: 'realtime' | 'hourly' | 'daily' | 'manual';
+    intg_created_by?: string;
+    intg_created_at?: Date;
+    intg_updated_at?: Date;
+    intg_isactive?: boolean;
+}
+declare const CIntegration: mongoose.Model<IIntegration, {}, {}, {}, mongoose.Document<unknown, {}, IIntegration, {}> & IIntegration & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CIntegration };

package/lib/schema/system/integrations.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CIntegration = void 0;
+var mongoose_1 = require("mongoose");
+var integrations = new mongoose_1.Schema({
+    intg_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true
+    },
+    intg_type: {
+        type: String,
+        required: true,
+        enum: ['payment_gateway', 'shipping_carrier', 'accounting_software', 'ecommerce_platform', 'sms_gateway', 'email_service', 'bank', 'tax_service', 'custom'],
+        index: true
+    },
+    intg_provider: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true
+    },
+    intg_api_key: {
+        type: String,
+        maxlength: 500
+    },
+    intg_api_secret: {
+        type: String,
+        maxlength: 500
+    },
+    intg_merchant_id: {
+        type: String,
+        maxlength: 100
+    },
+    intg_status: {
+        type: String,
+        required: true,
+        enum: ['active', 'inactive', 'testing'],
+        default: 'testing',
+        index: true
+    },
+    intg_configuration: {
+        type: Object
+    },
+    intg_test_mode: {
+        type: Boolean,
+        default: true
+    },
+    intg_last_sync: {
+        type: Date
+    },
+    intg_sync_frequency: {
+        type: String,
+        enum: ['realtime', 'hourly', 'daily', 'manual'],
+        default: 'manual'
+    },
+    intg_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    intg_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    intg_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    intg_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'integrations', timestamps: { createdAt: 'intg_created_at', updatedAt: 'intg_updated_at' } });
+// Indexes
+integrations.index({ intg_name: 1 });
+integrations.index({ intg_type: 1, intg_status: 1 });
+integrations.index({ intg_provider: 1 });
+var CIntegration = mongoose_1.default.model("integrations", integrations);
+exports.CIntegration = CIntegration;

package/lib/schema/system/recovery_operations.d.ts

@@ -0,0 +1,23 @@
+import mongoose from "mongoose";
+export interface IRecoveryOperation {
+    _id?: string;
+    recv_backup_record_id: string;
+    recv_recovery_type: 'full' | 'partial' | 'point_in_time' | 'file';
+    recv_status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+    recv_target_date?: Date;
+    recv_collections_to_restore?: string[];
+    recv_files_to_restore?: string[];
+    recv_started_at?: Date;
+    recv_completed_at?: Date;
+    recv_duration?: number;
+    recv_error_message?: string;
+    recv_created_by?: string;
+    recv_created_at?: Date;
+    recv_isactive?: boolean;
+}
+declare const CRecoveryOperation: mongoose.Model<IRecoveryOperation, {}, {}, {}, mongoose.Document<unknown, {}, IRecoveryOperation, {}> & IRecoveryOperation & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CRecoveryOperation };

package/lib/schema/system/recovery_operations.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRecoveryOperation = void 0;
+var mongoose_1 = require("mongoose");
+var recovery_operations = new mongoose_1.Schema({
+    recv_backup_record_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "backup_records",
+        required: true,
+        index: true
+    },
+    recv_recovery_type: {
+        type: String,
+        required: true,
+        enum: ['full', 'partial', 'point_in_time', 'file']
+    },
+    recv_status: {
+        type: String,
+        required: true,
+        enum: ['pending', 'in_progress', 'completed', 'failed', 'cancelled'],
+        default: 'pending',
+        index: true
+    },
+    recv_target_date: {
+        type: Date
+    },
+    recv_collections_to_restore: {
+        type: [String]
+    },
+    recv_files_to_restore: {
+        type: [String]
+    },
+    recv_started_at: {
+        type: Date
+    },
+    recv_completed_at: {
+        type: Date
+    },
+    recv_duration: {
+        type: Number,
+        min: 0
+    },
+    recv_error_message: {
+        type: String,
+        maxlength: 1000
+    },
+    recv_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    recv_created_at: {
+        type: Date,
+        default: Date.now,
+        index: true
+    },
+    recv_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'recovery_operations', timestamps: { createdAt: 'recv_created_at' } });
+// Indexes
+recovery_operations.index({ recv_backup_record_id: 1 });
+recovery_operations.index({ recv_status: 1 });
+recovery_operations.index({ recv_created_at: -1 });
+var CRecoveryOperation = mongoose_1.default.model("recovery_operations", recovery_operations);
+exports.CRecoveryOperation = CRecoveryOperation;

package/lib/schema/system/subscription_features.d.ts

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+export interface ISubscriptionFeature {
+    _id?: string;
+    sfea_name: string;
+    sfea_code: string;
+    sfea_description?: string;
+    sfea_category: 'users' | 'storage' | 'api' | 'features' | 'support' | 'custom';
+    sfea_value?: string | number;
+    sfea_unit?: string;
+    sfea_created_at?: Date;
+    sfea_updated_at?: Date;
+    sfea_isactive?: boolean;
+}
+declare const CSubscriptionFeature: mongoose.Model<ISubscriptionFeature, {}, {}, {}, mongoose.Document<unknown, {}, ISubscriptionFeature, {}> & ISubscriptionFeature & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CSubscriptionFeature };

package/lib/schema/system/subscription_features.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSubscriptionFeature = void 0;
+var mongoose_1 = require("mongoose");
+var subscription_features = new mongoose_1.Schema({
+    sfea_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true
+    },
+    sfea_code: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        unique: true,
+        uppercase: true
+    },
+    sfea_description: {
+        type: String,
+        maxlength: 500
+    },
+    sfea_category: {
+        type: String,
+        required: true,
+        enum: ['users', 'storage', 'api', 'features', 'support', 'custom'],
+        index: true
+    },
+    sfea_value: {
+        type: mongoose_1.Schema.Types.Mixed
+    },
+    sfea_unit: {
+        type: String,
+        maxlength: 20
+    },
+    sfea_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    sfea_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    sfea_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'subscription_features', timestamps: { createdAt: 'sfea_created_at', updatedAt: 'sfea_updated_at' } });
+// Indexes
+subscription_features.index({ sfea_code: 1 });
+subscription_features.index({ sfea_category: 1 });
+var CSubscriptionFeature = mongoose_1.default.model("subscription_features", subscription_features);
+exports.CSubscriptionFeature = CSubscriptionFeature;

package/lib/schema/system/subscription_payments.d.ts

@@ -0,0 +1,25 @@
+import mongoose from "mongoose";
+export interface ISubscriptionPayment {
+    _id?: string;
+    spay_subscription_id: string;
+    spay_amount: number;
+    spay_currency: string;
+    spay_payment_method: string;
+    spay_transaction_id?: string;
+    spay_payment_gateway?: string;
+    spay_status: 'pending' | 'completed' | 'failed' | 'refunded';
+    spay_billing_period_start: Date;
+    spay_billing_period_end: Date;
+    spay_paid_at?: Date;
+    spay_failure_reason?: string;
+    spay_invoice_url?: string;
+    spay_receipt_url?: string;
+    spay_created_at?: Date;
+    spay_isactive?: boolean;
+}
+declare const CSubscriptionPayment: mongoose.Model<ISubscriptionPayment, {}, {}, {}, mongoose.Document<unknown, {}, ISubscriptionPayment, {}> & ISubscriptionPayment & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CSubscriptionPayment };

package/lib/schema/system/subscription_payments.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSubscriptionPayment = void 0;
+var mongoose_1 = require("mongoose");
+var subscription_payments = new mongoose_1.Schema({
+    spay_subscription_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "subscriptions",
+        required: true,
+        index: true
+    },
+    spay_amount: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    spay_currency: {
+        type: String,
+        required: true,
+        maxlength: 3,
+        default: 'USD',
+        uppercase: true
+    },
+    spay_payment_method: {
+        type: String,
+        required: true,
+        maxlength: 50
+    },
+    spay_transaction_id: {
+        type: String,
+        maxlength: 200,
+        index: true
+    },
+    spay_payment_gateway: {
+        type: String,
+        maxlength: 100
+    },
+    spay_status: {
+        type: String,
+        required: true,
+        enum: ['pending', 'completed', 'failed', 'refunded'],
+        default: 'pending',
+        index: true
+    },
+    spay_billing_period_start: {
+        type: Date,
+        required: true
+    },
+    spay_billing_period_end: {
+        type: Date,
+        required: true
+    },
+    spay_paid_at: {
+        type: Date
+    },
+    spay_failure_reason: {
+        type: String,
+        maxlength: 500
+    },
+    spay_invoice_url: {
+        type: String,
+        maxlength: 500
+    },
+    spay_receipt_url: {
+        type: String,
+        maxlength: 500
+    },
+    spay_created_at: {
+        type: Date,
+        default: Date.now,
+        index: true
+    },
+    spay_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'subscription_payments', timestamps: { createdAt: 'spay_created_at' } });
+// Indexes
+subscription_payments.index({ spay_subscription_id: 1, spay_created_at: -1 });
+subscription_payments.index({ spay_status: 1 });
+subscription_payments.index({ spay_transaction_id: 1 });
+var CSubscriptionPayment = mongoose_1.default.model("subscription_payments", subscription_payments);
+exports.CSubscriptionPayment = CSubscriptionPayment;

package/lib/schema/system/subscription_plans.d.ts

@@ -0,0 +1,27 @@
+import mongoose from "mongoose";
+export interface ISubscriptionPlan {
+    _id?: string;
+    spln_name: string;
+    spln_code: string;
+    spln_description?: string;
+    spln_price: number;
+    spln_currency: string;
+    spln_billing_cycle: 'monthly' | 'quarterly' | 'yearly' | 'lifetime';
+    spln_features: string[];
+    spln_max_users?: number;
+    spln_max_storage?: number;
+    spln_max_api_calls?: number;
+    spln_trial_days?: number;
+    spln_is_popular?: boolean;
+    spln_is_active: boolean;
+    spln_created_by?: string;
+    spln_created_at?: Date;
+    spln_updated_at?: Date;
+    spln_isactive?: boolean;
+}
+declare const CSubscriptionPlan: mongoose.Model<ISubscriptionPlan, {}, {}, {}, mongoose.Document<unknown, {}, ISubscriptionPlan, {}> & ISubscriptionPlan & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CSubscriptionPlan };

package/lib/schema/system/subscription_plans.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSubscriptionPlan = void 0;
+var mongoose_1 = require("mongoose");
+var subscription_plans = new mongoose_1.Schema({
+    spln_name: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        trim: true
+    },
+    spln_code: {
+        type: String,
+        required: true,
+        maxlength: 50,
+        trim: true,
+        unique: true,
+        uppercase: true
+    },
+    spln_description: {
+        type: String,
+        maxlength: 500
+    },
+    spln_price: {
+        type: Number,
+        required: true,
+        min: 0
+    },
+    spln_currency: {
+        type: String,
+        required: true,
+        maxlength: 3,
+        default: 'USD',
+        uppercase: true
+    },
+    spln_billing_cycle: {
+        type: String,
+        required: true,
+        enum: ['monthly', 'quarterly', 'yearly', 'lifetime'],
+        default: 'monthly'
+    },
+    spln_features: {
+        type: [String],
+        default: []
+    },
+    spln_max_users: {
+        type: Number,
+        min: 0
+    },
+    spln_max_storage: {
+        type: Number,
+        min: 0
+    },
+    spln_max_api_calls: {
+        type: Number,
+        min: 0
+    },
+    spln_trial_days: {
+        type: Number,
+        default: 0,
+        min: 0
+    },
+    spln_is_popular: {
+        type: Boolean,
+        default: false
+    },
+    spln_is_active: {
+        type: Boolean,
+        default: true
+    },
+    spln_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    spln_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    spln_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    spln_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'subscription_plans', timestamps: { createdAt: 'spln_created_at', updatedAt: 'spln_updated_at' } });
+// Indexes
+subscription_plans.index({ spln_code: 1 });
+subscription_plans.index({ spln_is_active: 1 });
+subscription_plans.index({ spln_billing_cycle: 1 });
+var CSubscriptionPlan = mongoose_1.default.model("subscription_plans", subscription_plans);
+exports.CSubscriptionPlan = CSubscriptionPlan;

package/lib/schema/system/subscriptions.d.ts

@@ -0,0 +1,26 @@
+import mongoose from "mongoose";
+export interface ISubscription {
+    _id?: string;
+    subs_entity_id?: string;
+    subs_plan_id: string;
+    subs_status: 'active' | 'cancelled' | 'expired' | 'suspended' | 'trial';
+    subs_start_date: Date;
+    subs_end_date?: Date;
+    subs_trial_start_date?: Date;
+    subs_trial_end_date?: Date;
+    subs_auto_renew: boolean;
+    subs_next_billing_date?: Date;
+    subs_cancelled_at?: Date;
+    subs_cancellation_reason?: string;
+    subs_payment_method?: string;
+    subs_created_by?: string;
+    subs_created_at?: Date;
+    subs_updated_at?: Date;
+    subs_isactive?: boolean;
+}
+declare const CSubscription: mongoose.Model<ISubscription, {}, {}, {}, mongoose.Document<unknown, {}, ISubscription, {}> & ISubscription & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CSubscription };

package/lib/schema/system/subscriptions.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSubscription = void 0;
+var mongoose_1 = require("mongoose");
+var subscriptions = new mongoose_1.Schema({
+    subs_entity_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "core_system_entity",
+        index: true
+    },
+    subs_plan_id: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "subscription_plans",
+        required: true,
+        index: true
+    },
+    subs_status: {
+        type: String,
+        required: true,
+        enum: ['active', 'cancelled', 'expired', 'suspended', 'trial'],
+        default: 'trial',
+        index: true
+    },
+    subs_start_date: {
+        type: Date,
+        required: true,
+        default: Date.now
+    },
+    subs_end_date: {
+        type: Date
+    },
+    subs_trial_start_date: {
+        type: Date
+    },
+    subs_trial_end_date: {
+        type: Date
+    },
+    subs_auto_renew: {
+        type: Boolean,
+        default: true
+    },
+    subs_next_billing_date: {
+        type: Date
+    },
+    subs_cancelled_at: {
+        type: Date
+    },
+    subs_cancellation_reason: {
+        type: String,
+        maxlength: 500
+    },
+    subs_payment_method: {
+        type: String,
+        maxlength: 50
+    },
+    subs_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    subs_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    subs_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    subs_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'subscriptions', timestamps: { createdAt: 'subs_created_at', updatedAt: 'subs_updated_at' } });
+// Indexes
+subscriptions.index({ subs_entity_id: 1 });
+subscriptions.index({ subs_plan_id: 1 });
+subscriptions.index({ subs_status: 1 });
+subscriptions.index({ subs_end_date: 1 });
+var CSubscription = mongoose_1.default.model("subscriptions", subscriptions);
+exports.CSubscription = CSubscription;

package/lib/schema/system/webhooks.d.ts

@@ -0,0 +1,28 @@
+import mongoose from "mongoose";
+export interface IWebhook {
+    _id?: string;
+    whk_webhook_url: string;
+    whk_event_type: string;
+    whk_secret?: string;
+    whk_http_method: 'POST' | 'PUT' | 'PATCH';
+    whk_headers?: {
+        [key: string]: string;
+    };
+    whk_status: 'active' | 'inactive' | 'failed';
+    whk_last_triggered?: Date;
+    whk_success_count: number;
+    whk_failure_count: number;
+    whk_retry_on_failure: boolean;
+    whk_max_retries?: number;
+    whk_timeout?: number;
+    whk_created_by?: string;
+    whk_created_at?: Date;
+    whk_updated_at?: Date;
+    whk_isactive?: boolean;
+}
+declare const CWebhook: mongoose.Model<IWebhook, {}, {}, {}, mongoose.Document<unknown, {}, IWebhook, {}> & IWebhook & Required<{
+    _id: string;
+}> & {
+    __v: number;
+}, any>;
+export { CWebhook };

package/lib/schema/system/webhooks.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CWebhook = void 0;
+var mongoose_1 = require("mongoose");
+var webhooks = new mongoose_1.Schema({
+    whk_webhook_url: {
+        type: String,
+        required: true,
+        maxlength: 500,
+        trim: true
+    },
+    whk_event_type: {
+        type: String,
+        required: true,
+        maxlength: 100,
+        index: true
+    },
+    whk_secret: {
+        type: String,
+        maxlength: 500
+    },
+    whk_http_method: {
+        type: String,
+        required: true,
+        enum: ['POST', 'PUT', 'PATCH'],
+        default: 'POST'
+    },
+    whk_headers: {
+        type: Object
+    },
+    whk_status: {
+        type: String,
+        required: true,
+        enum: ['active', 'inactive', 'failed'],
+        default: 'active',
+        index: true
+    },
+    whk_last_triggered: {
+        type: Date
+    },
+    whk_success_count: {
+        type: Number,
+        default: 0,
+        min: 0
+    },
+    whk_failure_count: {
+        type: Number,
+        default: 0,
+        min: 0
+    },
+    whk_retry_on_failure: {
+        type: Boolean,
+        default: true
+    },
+    whk_max_retries: {
+        type: Number,
+        default: 3,
+        min: 0
+    },
+    whk_timeout: {
+        type: Number,
+        default: 30000, // 30 seconds
+        min: 1000
+    },
+    whk_created_by: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: "auth_user_mst"
+    },
+    whk_created_at: {
+        type: Date,
+        default: Date.now
+    },
+    whk_updated_at: {
+        type: Date,
+        default: Date.now
+    },
+    whk_isactive: {
+        type: Boolean,
+        default: true
+    }
+}, { collection: 'webhooks', timestamps: { createdAt: 'whk_created_at', updatedAt: 'whk_updated_at' } });
+// Indexes
+webhooks.index({ whk_webhook_url: 1 });
+webhooks.index({ whk_event_type: 1 });
+webhooks.index({ whk_status: 1 });
+var CWebhook = mongoose_1.default.model("webhooks", webhooks);
+exports.CWebhook = CWebhook;

package/package.json

@@ -9,7 +9,7 @@
     "typescript": "^5.8.3"
   },
   "name": "cloud-ide-model-schema",
-  "version": "1.1.108",
+  "version": "1.1.109",
   "description": "Pachage for schema management of Cloud IDEsys LMS",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",