@sedni/cloud_common 2.1.0 → 3.0.0

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,15 +17,289 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // app/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Types: () => Types
+  default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
 
+// app/models/Channel.ts
+var import_mongoose = __toESM(require("mongoose"), 1);
+var import_mongoose_autopopulate = __toESM(require("mongoose-autopopulate"), 1);
+var import_mongoose_paginate_v2 = __toESM(require("mongoose-paginate-v2"), 1);
+var import_mongoose_aggregate_paginate_v2 = __toESM(require("mongoose-aggregate-paginate-v2"), 1);
+var channelSchema = new import_mongoose.default.Schema({
+  channel_tag: {
+    type: String,
+    required: true
+  },
+  channel_description: {
+    type: String,
+    required: true
+  },
+  channel_unit_id: {
+    type: import_mongoose.default.Schema.Types.ObjectId,
+    ref: "Unit",
+    required: true,
+    autopopulate: true
+  },
+  channel_parsed: {
+    type: Object,
+    required: true
+  },
+  channel_last_bucket_sync: {
+    type: Date,
+    required: false
+  }
+}, {
+  timestamps: {
+    createdAt: true,
+    updatedAt: true
+  },
+  collection: "channels",
+  toJSON: {
+    transform: function(doc, ret) {
+      ret.id = ret._id;
+      ret.channel_unit = ret.channel_unit_id;
+      ret.channel_unit_id = ret.channel_unit_id.unit_id;
+      delete ret._id;
+      delete ret.__v;
+    }
+  }
+});
+channelSchema.index({ "channel_tag": 1 }, { unique: true });
+channelSchema.index({ "channel_description": 1 });
+channelSchema.plugin(import_mongoose_paginate_v2.default);
+channelSchema.plugin(import_mongoose_aggregate_paginate_v2.default);
+channelSchema.plugin(import_mongoose_autopopulate.default);
+var Channel_default = channelSchema;
+
+// app/models/ChannelDataBucket.ts
+var import_mongoose2 = __toESM(require("mongoose"), 1);
+var import_mongoose_paginate_v22 = __toESM(require("mongoose-paginate-v2"), 1);
+var import_mongoose_aggregate_paginate_v22 = __toESM(require("mongoose-aggregate-paginate-v2"), 1);
+var dataPointSchema = new import_mongoose2.default.Schema({
+  channel_id: {
+    type: String,
+    required: true,
+    index: true
+  },
+  timestamp: {
+    type: Number,
+    required: true
+  },
+  value: {
+    type: Number,
+    required: true
+  }
+}, {
+  _id: false
+});
+var channeldataBucketSchema = new import_mongoose2.default.Schema({
+  start_date: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  end_date: {
+    type: Date,
+    required: true,
+    default: function() {
+      return new Date(Date.now() + 1e3 * 60 * 60);
+    }
+  },
+  data: {
+    type: [dataPointSchema],
+    required: true,
+    default: []
+  },
+  size: {
+    type: Number,
+    required: true,
+    default: 0
+  },
+  synced: {
+    type: Number,
+    required: true,
+    default: 0
+  },
+  sum: {
+    type: Number,
+    required: true,
+    default: 0
+  }
+}, {
+  toJSON: {
+    transform: function(doc, ret) {
+      ret.id = ret._id;
+      delete ret._id;
+      delete ret.__v;
+      ret.start_date = ret.start_date.getTime();
+      ret.end_date = ret.end_date.getTime();
+      ret.avg = ret.sum / ret.size;
+    }
+  },
+  versionKey: false
+});
+channeldataBucketSchema.index({ start_date: 1, end_date: 1 }, { background: true });
+channeldataBucketSchema.index({ start_date: 1, end_date: 1, "data.channel_id": 1 }, { background: true });
+channeldataBucketSchema.index({ start_date: 1 }, { expireAfterSeconds: 60 * 60 * 24 * 365, background: true });
+channeldataBucketSchema.plugin(import_mongoose_paginate_v22.default);
+channeldataBucketSchema.plugin(import_mongoose_aggregate_paginate_v22.default);
+var ChannelDataBucket_default = channeldataBucketSchema;
+
+// app/models/ChannelDataPoint.ts
+var import_mongoose3 = __toESM(require("mongoose"), 1);
+var import_mongoose_paginate_v23 = __toESM(require("mongoose-paginate-v2"), 1);
+var import_mongoose_aggregate_paginate_v23 = __toESM(require("mongoose-aggregate-paginate-v2"), 1);
+var channelDataPointSchema = new import_mongoose3.default.Schema({
+  c: {
+    type: String,
+    required: true,
+    index: true,
+    alias: "channel_id"
+  },
+  t: {
+    type: Date,
+    required: true,
+    alias: "timestamp"
+  },
+  v: {
+    type: Number,
+    required: true,
+    alias: "value"
+  }
+}, {
+  collection: "channel_data_points",
+  timestamps: false,
+  timeseries: {
+    timeField: "t",
+    metaField: "c",
+    granularity: "seconds"
+  },
+  toJSON: { getters: true },
+  toObject: { getters: true },
+  versionKey: false
+});
+channelDataPointSchema.index({ c: 1, t: 1 });
+var oneYear = 60 * 60 * 24 * 365;
+channelDataPointSchema.addTTLIndex = function(expirationTimeInSeconds = oneYear, ttlField = "t", metaField = "c") {
+  this.index({
+    [ttlField]: 1
+  }, {
+    expireAfterSeconds: expirationTimeInSeconds,
+    partialFilterExpression: {
+      [metaField]: {
+        $exists: true
+      }
+    },
+    name: "ttl_index_" + ttlField
+  });
+};
+channelDataPointSchema.plugin(import_mongoose_paginate_v23.default);
+channelDataPointSchema.plugin(import_mongoose_aggregate_paginate_v23.default);
+var ChannelDataPoint_default = channelDataPointSchema;
+
+// app/models/Event.ts
+var import_mongoose4 = __toESM(require("mongoose"), 1);
+var import_mongoose_paginate_v24 = __toESM(require("mongoose-paginate-v2"), 1);
+var import_mongoose_aggregate_paginate_v24 = __toESM(require("mongoose-aggregate-paginate-v2"), 1);
+
+// app/types/event.types.ts
+var EventCategories = {
+  ACCESS_CONTROL: "AccessControl",
+  REQUEST_ERROR: "RequestErrors",
+  OS: "OperatingSystemEvents",
+  CONTROL: "ControlSystemEvents",
+  BACKUP: "BackupAndRestoreEvents",
+  CONFIG_CHANGE: "ConfigurationChanges",
+  LOGS: "AuditLogEvents",
+  POTENTIAL_ATTACK: "PotentialAttackActivity"
+};
+var EventCriticalities = {
+  VERBOSE: "Verbose",
+  INFO: "Info",
+  WARNING: "Warning",
+  ERROR: "Error",
+  CRITICAL: "Critical"
+};
+
+// app/models/Event.ts
+var eventSchema = new import_mongoose4.default.Schema({
+  event_message: {
+    type: String,
+    required: true
+  },
+  event_source: {
+    type: String,
+    required: true
+  },
+  event_user: {
+    type: String,
+    required: false
+  },
+  event_category: {
+    type: String,
+    required: true,
+    enum: Object.values(EventCategories)
+  },
+  event_criticality: {
+    type: String,
+    required: true,
+    enum: Object.values(EventCriticalities)
+  },
+  event_type: {
+    type: String,
+    required: true
+  },
+  event_timestamp: {
+    type: Date,
+    default: Date.now
+  },
+  event_data: {
+    type: Object
+  }
+}, {
+  timestamps: {
+    createdAt: true,
+    updatedAt: false
+  },
+  versionKey: false,
+  toJSON: {
+    transform: function(doc, ret) {
+      ret.id = ret._id;
+      delete ret._id;
+      delete ret.createdAt;
+      ret.event_timestamp = ret.event_timestamp.getTime();
+    }
+  }
+});
+eventSchema.index({ "event_type": 1 });
+eventSchema.index({ "event_category": 1 });
+var oneYear2 = 60 * 60 * 24 * 365;
+eventSchema.addTTLIndex = function(expirationTimeInSeconds = oneYear2, ttlField = "event_timestamp") {
+  this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
+};
+eventSchema.plugin(import_mongoose_paginate_v24.default);
+eventSchema.plugin(import_mongoose_aggregate_paginate_v24.default);
+var Event_default = eventSchema;
+
+// app/models/History.ts
+var import_mongoose5 = __toESM(require("mongoose"), 1);
+var import_mongoose_paginate_v25 = __toESM(require("mongoose-paginate-v2"), 1);
+var import_mongoose_aggregate_paginate_v25 = __toESM(require("mongoose-aggregate-paginate-v2"), 1);
+
 // app/types/alarm.types.ts
 var AlarmPriorities = {
   CRITICAL: "Critical",
@@ -64,56 +340,85 @@ var AlarmTypes = {
   ALARM_UNK: "AlarmUnk"
 };
 
-// app/types/channel.types.ts
-var ChannelBaseTypes = {
-  VIRTUAL_ANALOG: "VirtualAnalog",
-  VIRTUAL_DIGITAL: "VirtualDigital",
-  VIRTUAL_STRING: "VirtualString",
-  WIRED_ANALOG: "WiredAnalog",
-  WIRED_DIGITAL: "WiredDigital"
-};
-var ChannelSpecificTypes = {
-  // Wired types
-  DIGITAL_INPUT: "DigitalInput",
-  DIGITAL_OUTPUT: "DigitalOutput",
-  ANALOG_INPUT: "AnalogInput",
-  ANALOG_OUTPUT: "AnalogOutput",
-  // Virtual types
-  ANALOG_SOFTWARE: "AnalogSoftware",
-  DIGITAL_SOFTWARE: "DigitalSoftware",
-  VIRTUAL_STRING: "VirtualString",
-  COMMAND: "Command",
-  // Virtual logic types
-  BROADCAST_COMMAND: "BroadcastCommand",
-  // To be deleted in the near future
-  SOFTWARE: "Software",
-  ANALOG_TIMER: "AnalogTimer",
-  // Serial types
-  SERIAL_DIGITAL_INPUT: "SerialDigitalInput",
-  SERIAL_DIGITAL_OUTPUT: "SerialDigitalOutput",
-  SERIAL_LINE_COMMAND: "SerialLineCommand",
-  SERIAL_ANALOG_INPUT: "SerialAnalogInput",
-  SERIAL_ANALOG_OUTPUT: "SerialAnalogOutput"
+// app/models/History.ts
+var historySchema = new import_mongoose5.default.Schema({
+  channel_tag: {
+    type: String,
+    required: true
+  },
+  alarm_timestamp: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  alarm_priority: {
+    type: String,
+    required: true,
+    enum: Object.values(AlarmPriorities)
+  },
+  alarm_original_state: {
+    type: String,
+    required: true,
+    enum: Object.values(DiamarAlarmStates)
+  },
+  alarm_state: {
+    type: String,
+    required: true,
+    enum: Object.values(CloudAlarmStates)
+  },
+  alarm_type: {
+    type: String,
+    required: true,
+    enum: Object.values(AlarmTypes)
+  },
+  alarm_value: {
+    type: Number,
+    required: false
+  },
+  alarm_message: {
+    type: String,
+    required: false
+  },
+  alarm_data: {
+    type: Object,
+    required: false
+  }
+}, {
+  timestamps: {
+    createdAt: false,
+    updatedAt: false
+  },
+  versionKey: false,
+  collection: "history",
+  toJSON: {
+    transform: function(doc, ret) {
+      ret.id = ret._id;
+      delete ret._id;
+      delete ret.__v;
+      ret.alarm_timestamp = new Date(ret.alarm_timestamp).getTime();
+      ret.alarm = {
+        alarm_priority: ret.alarm_priority,
+        alarm_state: ret.alarm_original_state ?? "Inactive",
+        alarm_type: ret.alarm_type,
+        alarm_value: ret.alarm_value === null ? "inf" : `${ret.alarm_value}`,
+        alarm_timestamp: new Date(ret.alarm_timestamp).getTime()
+      };
+    }
+  }
+});
+historySchema.index({ "channel_tag": 1 });
+var oneYear3 = 60 * 60 * 24 * 365;
+historySchema.addTTLIndex = function(expirationTimeInSeconds = oneYear3, ttlField = "alarm_timestamp") {
+  this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
 };
+historySchema.plugin(import_mongoose_paginate_v25.default);
+historySchema.plugin(import_mongoose_aggregate_paginate_v25.default);
+var History_default = historySchema;
 
-// app/types/event.types.ts
-var EventCategories = {
-  ACCESS_CONTROL: "AccessControl",
-  REQUEST_ERROR: "RequestErrors",
-  OS: "OperatingSystemEvents",
-  CONTROL: "ControlSystemEvents",
-  BACKUP: "BackupAndRestoreEvents",
-  CONFIG_CHANGE: "ConfigurationChanges",
-  LOGS: "AuditLogEvents",
-  POTENTIAL_ATTACK: "PotentialAttackActivity"
-};
-var EventCriticalities = {
-  VERBOSE: "Verbose",
-  INFO: "Info",
-  WARNING: "Warning",
-  ERROR: "Error",
-  CRITICAL: "Critical"
-};
+// app/models/Unit.ts
+var import_mongoose6 = __toESM(require("mongoose"), 1);
+var import_mongoose_paginate_v26 = __toESM(require("mongoose-paginate-v2"), 1);
+var import_mongoose_aggregate_paginate_v26 = __toESM(require("mongoose-aggregate-paginate-v2"), 1);
 
 // app/types/unit.types.ts
 var UnitTypes = {
@@ -127,19 +432,1322 @@ var UnitTypes = {
   TIM28: "Tim28"
 };
 
+// app/models/Unit.ts
+var unitSchema = new import_mongoose6.default.Schema({
+  unit_id: {
+    type: String,
+    required: true
+  },
+  unit_enabled: {
+    type: Boolean,
+    required: true
+  },
+  unit_type: {
+    type: String,
+    required: true,
+    enum: Object.values(UnitTypes)
+  },
+  unit_internal_description: {
+    type: String,
+    required: true
+  },
+  unit_cabinet_id: {
+    type: String,
+    required: false
+  }
+}, {
+  timestamps: true,
+  collection: "units",
+  toJSON: {
+    transform: function(doc, ret) {
+      ret.id = ret._id;
+      delete ret._id;
+      delete ret.__v;
+    }
+  }
+});
+unitSchema.index({ "unit_id": 1 }, { unique: true });
+unitSchema.index({ "unit_internal_description": 1 });
+unitSchema.plugin(import_mongoose_paginate_v26.default);
+unitSchema.plugin(import_mongoose_aggregate_paginate_v26.default);
+var Unit_default = unitSchema;
+
+// app/models/docs/Channel.json
+var Channel_default2 = {
+  components: {
+    schemas: {
+      Channel: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            format: "ObjectId",
+            description: "MongoDB ObjectId",
+            example: "507f1f77bcf86cd799439011",
+            readOnly: true
+          },
+          channel_tag: {
+            type: "string",
+            description: "Channel tag",
+            example: "MOTOR_PS_TEMP",
+            readOnly: true
+          },
+          channel_description: {
+            type: "string",
+            description: "Channel description",
+            example: "Motor Power Supply Temperature",
+            readOnly: true
+          },
+          channel_unit_id: {
+            type: "string",
+            format: "ObjectId",
+            description: "Unit of the channel",
+            example: "507f1f77bcf86cd799439011",
+            readOnly: true
+          },
+          channel_parsed: {
+            type: "object",
+            description: "Parsed channel data",
+            readOnly: true
+          }
+        },
+        required: [
+          "channel_tag",
+          "channel_description",
+          "channel_unit_id",
+          "channel_parsed"
+        ]
+      }
+    },
+    examples: {
+      Channel: {
+        value: {
+          id: "507f1f77bcf86cd799439011",
+          channel_tag: "MOTOR_PS_TEMP",
+          channel_description: "Motor Power Supply Temperature",
+          channel_type: "Analogic"
+        }
+      }
+    }
+  }
+};
+
+// app/models/docs/ChannelDataBucket.json
+var ChannelDataBucket_default2 = {
+  components: {
+    schemas: {
+      ChannelData: {
+        type: "object",
+        description: "ChannelData object. This is the bucket where the data is stored, in batches of 1 hour.",
+        properties: {
+          id: {
+            type: "string",
+            format: "ObjectId",
+            description: "MongoDB ObjectId",
+            example: "507f1f77bcf86cd799439011",
+            readOnly: true
+          },
+          start_date: {
+            type: "string",
+            format: "date-time",
+            description: "Start date of the data",
+            example: "2024-07-03T10:15:30Z",
+            readOnly: true
+          },
+          end_date: {
+            type: "string",
+            format: "date-time",
+            description: "End date of the data",
+            example: "2024-07-03T11:15:30Z",
+            readOnly: true
+          },
+          data: {
+            type: "array",
+            description: "Data array of DataPoint objects",
+            items: {
+              $ref: "#/components/schemas/DataPoint"
+            },
+            readOnly: false
+          },
+          size: {
+            type: "integer",
+            format: "int64",
+            description: "Size of the data array",
+            example: 60,
+            readOnly: true
+          },
+          synced: {
+            type: "TODO",
+            description: "TODO",
+            example: "TODO",
+            readOnly: true
+          },
+          sum: {
+            type: "number",
+            format: "double",
+            description: "Sum of the data",
+            example: 69.42,
+            readOnly: true
+          }
+        }
+      }
+    },
+    examples: {
+      ChannelData: {
+        id: "507f1f77bcf86cd799439011",
+        start_date: "2024-07-03T10:15:30Z",
+        end_date: "2024-07-03T11:15:30Z",
+        data: [
+          {
+            t: 1710251647e3,
+            v: 69.42
+          }
+        ],
+        size: 60,
+        synced: "TODO",
+        sum: 69.42
+      }
+    }
+  }
+};
+
+// app/models/docs/ChannelWithData.json
+var ChannelWithData_default = {
+  components: {
+    schemas: {
+      ChannelWithData: {
+        allOf: [
+          {
+            $ref: "#/components/schemas/Channel"
+          },
+          {
+            type: "object",
+            properties: {
+              channel_latest_value: {
+                type: "string",
+                description: "Latest value of the channel",
+                example: "25.0",
+                readOnly: true
+              },
+              channel_latest_timestamp: {
+                type: "string",
+                format: "date-time",
+                description: "Timestamp of the latest value",
+                example: 1700034034,
+                readOnly: true
+              },
+              channel_alarm_state: {
+                type: "string",
+                description: "Alarm state of the channel",
+                example: "NoAlarm",
+                readOnly: true
+              }
+            }
+          }
+        ],
+        required: [
+          "channel_tag",
+          "channel_description",
+          "channel_type",
+          "channel_latest_value",
+          "channel_latest_timestamp",
+          "channel_alarm_state"
+        ]
+      }
+    },
+    examples: {
+      ChannelWithData: {
+        value: {
+          id: "507f1f77bcf86cd799439011",
+          channel_tag: "MOTOR_PS_TEMP",
+          channel_description: "Motor Power Supply Temperature",
+          channel_type: "Analogic",
+          channel_latest_value: 420.69,
+          channel_latest_timestamp: 1700034034,
+          channel_alarm_state: "NoAlarm"
+        }
+      }
+    }
+  }
+};
+
+// app/models/docs/ChannelDataPoint.json
+var ChannelDataPoint_default2 = {
+  components: {
+    schemas: {
+      ChannelDataPoint: {
+        type: "object",
+        description: "ChannelDataPoint object. This is the object that is sent to and from the API. It includes only the timestamp and the value. No id is included because the data is stored inside a larger bucket in the database.",
+        properties: {
+          c: {
+            type: "string",
+            description: "Channel ID associated with the data point",
+            example: "U001_001",
+            readOnly: true
+          },
+          t: {
+            type: "integer",
+            format: "int64",
+            description: "Timestamp of the data",
+            example: 1710251647e3,
+            readOnly: true
+          },
+          v: {
+            type: "number",
+            format: "double",
+            description: "Value of the data",
+            example: 69.42,
+            readOnly: true
+          }
+        }
+      }
+    },
+    examples: {
+      ChannelDataPoint: {
+        c: "U001_001",
+        t: 1710251647e3,
+        v: 69.42
+      }
+    }
+  }
+};
+
+// app/models/docs/Event.json
+var Event_default2 = {
+  components: {
+    schemas: {
+      Event: {
+        type: "object",
+        description: "Event object. This is the object that is sent to and from the API. It includes the id as a string, the timestamp as a number and the creation timestamp is not included.",
+        properties: {
+          id: {
+            type: "string",
+            format: "ObjectId",
+            description: "MongoDB ObjectId",
+            example: "507f1f77bcf86cd799439011",
+            readOnly: true
+          },
+          event_message: {
+            type: "string",
+            format: "text",
+            description: "Event message",
+            example: "Event message"
+          },
+          event_source: {
+            type: "string",
+            format: "text",
+            description: "Hostname of the source of the event",
+            example: "RMS1"
+          },
+          event_category: {
+            type: "string",
+            format: "text",
+            description: "Event category",
+            example: "Login",
+            enum: "%%EVENT_CATEGORY_ENUM%%"
+          },
+          event_type: {
+            type: "string",
+            format: "text",
+            description: "Event type",
+            example: "Login"
+          },
+          event_timestamp: {
+            type: "number",
+            format: "timestamp",
+            description: "Event timestamp",
+            example: 1709899759
+          },
+          event_data: {
+            type: "object",
+            description: "Event data. Not validated, just stored"
+          }
+        },
+        required: [
+          "event_message",
+          "event_source",
+          "event_category",
+          "event_type",
+          "event_timestamp"
+        ]
+      }
+    },
+    examples: {
+      Event: {
+        value: {
+          id: "507f1f77bcf86cd799439011",
+          event_message: "Profile Root logged in for the next 600 seconds, replacing profile Root.",
+          event_source: "RMS1",
+          event_category: "Login",
+          event_type: "LoiginSuccessful",
+          event_timestamp: 1709899759,
+          event_data: {
+            profile: "Root",
+            duration: 600,
+            replaced_profile: "Monitor"
+          }
+        }
+      }
+    }
+  }
+};
+
+// app/models/docs/History.json
+var History_default2 = {
+  components: {
+    schemas: {
+      History: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            format: "ObjectId",
+            description: "MongoDB ObjectId",
+            example: "507f1f77bcf86cd799439011",
+            readOnly: true
+          },
+          channel_tag: {
+            type: "string",
+            format: "text",
+            description: "Channel tag",
+            example: "Channel tag",
+            readOnly: true
+          },
+          alarm_timestamp: {
+            type: "string",
+            format: "date-time",
+            description: "Alarm timestamp",
+            example: "2020-12-31T23:59:59Z",
+            readOnly: true
+          },
+          alarm_priority: {
+            type: "string",
+            format: "text",
+            description: "Alarm priority",
+            example: "Alarm",
+            enum: "%%ALARM_PRIORITY_ENUM%%",
+            readOnly: true
+          },
+          alarm_original_state: {
+            type: "string",
+            format: "text",
+            description: "Alarm original state",
+            example: "Inactive",
+            enum: "%%DIAMAR_ALARM_STATE_ENUM%%",
+            readOnly: true
+          },
+          alarm_state: {
+            type: "string",
+            format: "text",
+            description: "Alarm new state",
+            example: "Inactive",
+            enum: "%%CLOUD_ALARM_STATE_ENUM%%",
+            readOnly: true
+          },
+          alarm_type: {
+            type: "string",
+            format: "text",
+            description: "Alarm type",
+            example: "AlarmOpen",
+            enum: "%%ALARM_TYPE_ENUM%%",
+            readOnly: true
+          },
+          alarm_value: {
+            type: "number",
+            format: "double",
+            description: "Alarm value",
+            example: 0,
+            readOnly: true
+          },
+          alarm_message: {
+            type: "string",
+            format: "text",
+            description: "Alarm message",
+            example: "Alarm message",
+            readOnly: true
+          }
+        },
+        required: [
+          "channel_tag",
+          "alarm_timestamp",
+          "alarm_priority",
+          "alarm_original_state",
+          "alarm_state",
+          "alarm_type",
+          "alarm_value",
+          "alarm_message"
+        ]
+      }
+    },
+    examples: {
+      History: {
+        value: {
+          id: "507f1f77bcf86cd799439011",
+          channel_tag: "Channel tag",
+          alarm_timestamp: "2020-12-31T23:59:59Z",
+          alarm_priority: "Alarm",
+          alarm_original_state: "Inactive",
+          alarm_state: "Inactive",
+          alarm_type: "AlarmOpen",
+          alarm_value: 0,
+          alarm_message: "AlarmOpen Value: [OP]"
+        }
+      }
+    }
+  }
+};
+
+// app/models/docs/Unit.json
+var Unit_default2 = {
+  components: {
+    schemas: {
+      Unit: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            format: "ObjectId",
+            description: "MongoDB ObjectId",
+            example: "507f1f77bcf86cd799439011",
+            readOnly: true
+          },
+          unit_id: {
+            type: "string",
+            description: "Unit identifier in Diamar",
+            example: "127",
+            readOnly: true
+          },
+          unit_internal_description: {
+            type: "string",
+            description: "Unit description",
+            example: "Motor Power Supply",
+            readOnly: true
+          },
+          unit_enabled: {
+            type: "boolean",
+            description: "Unit enabled",
+            example: true,
+            readOnly: true
+          },
+          unit_type: {
+            type: "string",
+            description: "Unit type",
+            example: "DIM36",
+            readOnly: true
+          },
+          unit_cabinet_id: {
+            type: "string",
+            description: "Cabinet identifier",
+            example: "Cabinet 1",
+            readOnly: true
+          }
+        },
+        required: [
+          "unit_id",
+          "unit_internal_description",
+          "unit_enabled",
+          "unit_type",
+          "unit_cabinet_id"
+        ]
+      }
+    },
+    examples: {
+      Unit: {
+        value: {
+          id: "507f1f77bcf86cd799439011",
+          unit_id: "127",
+          unit_internal_description: "Motor Power Supply",
+          unit_enabled: true,
+          unit_type: "DIM36",
+          unit_cabinet_id: "Cabinet 1"
+        }
+      }
+    }
+  }
+};
+
+// app/models/docs/index.ts
+History_default2.components.schemas.History.properties.alarm_priority.enum = Object.values(AlarmPriorities);
+History_default2.components.schemas.History.properties.alarm_state.enum = Object.values(CloudAlarmStates);
+History_default2.components.schemas.History.properties.alarm_original_state.enum = Object.values(DiamarAlarmStates);
+History_default2.components.schemas.History.properties.alarm_type.enum = Object.values(AlarmTypes);
+Event_default2.components.schemas.Event.properties.event_category.enum = Object.values(EventCategories);
+var Docs = {
+  ChannelDocs: Channel_default2,
+  ChannelDataBucketDocs: ChannelDataBucket_default2,
+  ChannelWithDataDocs: ChannelWithData_default,
+  ChannelDataPointDocs: ChannelDataPoint_default2,
+  EventDocs: Event_default2,
+  HistoryDocs: History_default2,
+  UnitDocs: Unit_default2
+};
+var docs_default = Docs;
+
+// app/types/mimics.types.ts
+var MimicElementTypes = {
+  // Auxiliary
+  IMAGE: "Image",
+  LINE: "Line",
+  SQUARE: "Square",
+  LINK: "Link",
+  POLYLINE: "Polyline",
+  TEXT: "Text",
+  // Elements
+  ALARM_INDICATOR: "AlarmIndicator",
+  BREAKER: "Breaker",
+  COMMAND: "Command",
+  COMPRESSOR: "Compressor",
+  DAMPER: "Damper",
+  DIAL: "Dial",
+  DIGITAL: "Digital",
+  DISPLAY: "Display",
+  FAN: "Fan",
+  GENERATOR: "Generator",
+  LEVEL_BAR: "LevelBar",
+  PUMP: "Pump",
+  SHAFT: "Shaft",
+  TEXT_CHANNEL: "TextChannel",
+  DYNAMIC_TEXT: "DynamicText",
+  TANK: "Tank",
+  VALVE: "Valve",
+  SLIDER: "Slider",
+  TOGGLE: "Toggle",
+  // IAS
+  UNIT: "Unit",
+  REPEATER: "Repeater",
+  STATION: "Station",
+  CABINET: "Cabinet",
+  // ElementsPms
+  BREAKER_PMS: "BreakerPms",
+  GENERATOR_PMS: "GeneratorPms",
+  OPERATION_MODES_PMS: "OperationModesPms",
+  PMS_PRIORITIES: "PmsPriorities",
+  // ElementsAutomated
+  VALVE_AUTOMATED: "ValveAutomated",
+  DAMPER_AUTOMATED: "DamperAutomated",
+  PUMP_AUTOMATED: "PumpAutomated"
+};
+var ZDepths = {
+  BACKGROUND: "Background",
+  LOW: "Low",
+  NORMAL: "Normal",
+  HIGH: "High"
+};
+var TitleAligns = {
+  BOTTOM: "Bottom",
+  LEFT: "Left",
+  RIGHT: "Right",
+  TOP: "Top"
+};
+var DigitalStates = {
+  NO_VALUE: "NoValue",
+  OPEN: "Open",
+  CLOSE: "Close",
+  UNDEFINED: "Undefined"
+};
+var DigitalAlarmStates = {
+  NO_ALARM: "NoAlarm",
+  ALARM: "Alarm",
+  UNDEFINED: "Undefined"
+};
+var AlarmStates = {
+  ALARM: 1,
+  WARNING: 2,
+  UNACKNOWLEDGED_ALARM: 3,
+  UNACKNOWLEDGED_WARNING: 4,
+  ACKNOWLEDGED_ALARM: 5,
+  ACKNOWLEDGED_WARNING: 6,
+  INHIBITED: 7,
+  OFF_SCAN: 8,
+  NORMAL: 9,
+  OFFLINE: 10
+};
+var ActivationModes = {
+  ALARM: "Alarm",
+  LOGIC: "Logic",
+  VALUE: "Value"
+};
+var TextAnchorPoints = {
+  LEFT: "Left",
+  CENTER: "Center",
+  RIGHT: "Right"
+};
+var ValveDesigns = {
+  MECHANIC: "Mechanic",
+  NORMAL: "Normal"
+};
+var FanDesigns = {
+  NORMAL: "Normal",
+  BLADED: "Bladed"
+};
+var FanRunStates = {
+  NO_VALUE: "NoValue",
+  UNDEFINED: "Undefined",
+  STOPPED: "Stopped",
+  RUNNING: "Running",
+  RUNNING_FAST: "RunningFast"
+};
+var FanDirections = {
+  NO_VALUE: "NoValue",
+  UNDEFINED: "Undefined",
+  SUPPLY: "Supply",
+  EXHAUST: "Exhaust"
+};
+var FanTypes = {
+  SIMPLE: "Simple",
+  SIMPLE_WITH_FAST: "SimpleWithFast",
+  REVERSIBLE: "Reversible",
+  REVERSIBLE_WITH_FAST: "ReversibleWithFast"
+};
+var LevelBarOrientations = {
+  VERTICAL: "Vertical",
+  HORIZONTAL: "Horizontal"
+};
+var SliderOrientations = {
+  VERTICAL: "Vertical",
+  HORIZONTAL: "Horizontal"
+};
+var CompressorDesigns = {
+  CENTRIFUGAL: "Centrifugal",
+  MECHANIC: "Mechanic",
+  NORMAL: "Normal",
+  PISTONS: "Pistons",
+  ROTATORY_SCREW: "RotatoryScrew",
+  SCROLL: "Scroll",
+  VANES: "Vanes"
+};
+var LedTypes = {
+  CIRCLE: "Circle",
+  SQUARE: "Square"
+};
+var InfoLocations = {
+  BOTTOM: "Bottom",
+  LEFT: "Left",
+  RIGHT: "Right",
+  TOP: "Top"
+};
+var MarkTypes = {
+  LARGE_LINE: "LargeLine",
+  SHORT_LINE: "ShortLine",
+  TRIANGLE: "Triangle"
+};
+var ScalePositions = {
+  LEFT: "Left",
+  RIGHT: "Right"
+};
+var ValueTypes = {
+  PERCENTAGE: "Percentage",
+  RAW: "Raw"
+};
+var OperationModeStates = {
+  ACTIVE: 0,
+  INACTIVE: 1,
+  IN_TRANSITION: 2,
+  FAILED: 3
+};
+var UnitDesigns = {
+  IMAGE: "Image",
+  MODERN: "Modern"
+};
+var StationDesigns = {
+  IMAGE: "Image",
+  MONITOR: "Monitor",
+  SCREEN: "Screen"
+};
+var RepeaterDesigns = {
+  IMAGE: "Image",
+  SLIM: "SLim",
+  DIAMAR_REPEATER: "DiamarRepeater"
+};
+var CabinetDesigns = {
+  IMAGE: "Image",
+  MODERN: "Modern"
+};
+var LinkDesigns = {
+  BUTTON: "Button",
+  IMAGE: "Image"
+};
+var OpClStates = {
+  NO_VALUE: "NoValue",
+  OPEN: "Open",
+  CLOSE: "Close",
+  UNDEFINED: "Undefined"
+};
+var RunningStoppedStates = {
+  NO_VALUE: "NoValue",
+  RUNNING: "Running",
+  STOPPED: "Stopped",
+  UNDEFINED: "Undefined"
+};
+
+// app/models/mimics/MimicSupport.ts
+var AddedAlarmsJson = {
+  Channels: []
+};
+var BackgroundJson = {
+  Show: false
+};
+var LineJson = {
+  Color: "#000000",
+  Width: 1,
+  Start: { X: 0, Y: 0 },
+  End: { X: 0, Y: 0 }
+};
+var LocalizedTextJson = {
+  English: "",
+  Spanish: "",
+  French: "",
+  German: ""
+};
+var LocationJson = {
+  X: 0,
+  Y: 0,
+  Z: 0,
+  Rotation: 0
+};
+var LogicExpressionJson = {
+  Expression: "",
+  Value: void 0,
+  Variables: []
+};
+var LogicExpressionsJson = {
+  LogicExpressions: []
+};
+var ScaleJson = {
+  Show: false,
+  TextHeight: 12,
+  Color: "#000000",
+  Position: "Bottom",
+  LineWidth: 1,
+  DivisionsNumber: 3,
+  SubdivisionsNumber: 2
+};
+var TextAttributesJson = {
+  AnchorPoint: TextAnchorPoints.LEFT,
+  Color: "#000000",
+  HasUnderline: false,
+  UnderlineColor: "#000000",
+  UnderlineLength: 10,
+  UnderlineWidth: 1
+};
+var TitleJson = {
+  Show: false,
+  Height: 20,
+  Padding: 5,
+  Align: TitleAligns.LEFT,
+  Color: "#000000",
+  Text: LocalizedTextJson,
+  Location: LocationJson
+};
+
+// app/models/mimics/AuxiliaryElements.ts
+var ImageAuxiliaryJson = {
+  DefaultImageName: "image.png",
+  ImageLogic: LogicExpressionsJson
+};
+var LineAuxiliaryJson = {
+  Line: LineJson,
+  LineColorLogic: LogicExpressionsJson
+};
+var LinkAuxiliaryJson = {
+  DefaultImageName: "default.png",
+  MimicId: "",
+  ImageLogic: LogicExpressionsJson,
+  Design: "Default",
+  ButtonColor: "#FFFFFF",
+  TextColor: "#000000",
+  TextHeight: 12,
+  ButtonTexts: LocalizedTextJson
+};
+var PolylineAuxiliaryJson = {
+  Lines: [],
+  LineColorLogic: LogicExpressionsJson
+};
+var SquareAuxiliaryJson = {
+  Lines: [],
+  ColorBorder: "#000000",
+  ColorFill: "#FFFFFF",
+  LineColorLogic: LogicExpressionsJson
+};
+var TextAuxiliaryJson = {
+  TextAttributes: TextAttributesJson,
+  Text: LocalizedTextJson
+};
+
+// app/models/mimics/ChannelMimic.ts
+var ChannelJson = {
+  WithBackup: false,
+  Main: null,
+  Backup: null,
+  Max: 100,
+  Min: 0,
+  Units: ""
+};
+
+// app/models/mimics/MimicTraits.ts
+var AutomaticSemiAutoJson = {
+  withAutomatic: false,
+  automaticCommand: ChannelJson,
+  semiAutoCommand: ChannelJson,
+  automaticFeedback: ChannelJson,
+  hasSemiAutoFeedback: false,
+  semiAutoFeedback: ChannelJson
+};
+var CommandsOpClJson = {
+  commandOpen: ChannelJson,
+  commandClose: ChannelJson
+};
+var CommandsStartStopJson = {
+  commandStart: ChannelJson,
+  commandStop: ChannelJson
+};
+var ControlLockJson = {
+  hasControlLock: false,
+  controlLock: ChannelJson
+};
+var FeedbackOpClJson = {
+  openFeedback: ChannelJson,
+  closeFeedback: ChannelJson
+};
+var FeedbackRunningStoppedJson = {
+  runFeedback: ChannelJson,
+  hasStoppedFeedback: false,
+  stoppedFeedback: ChannelJson
+};
+var OrderOpClJson = {
+  openOrder: ChannelJson,
+  closeOrder: ChannelJson
+};
+var OrderStartStopJson = {
+  startOrder: ChannelJson,
+  stopOrder: ChannelJson
+};
+var RemoteLocalJson = {
+  remoteFeedback: ChannelJson,
+  hasLocalFeedback: false,
+  localFeedback: ChannelJson
+};
+var TripResetJson = {
+  tripFeedback: ChannelJson,
+  withCommandReset: false,
+  resetCommand: ChannelJson
+};
+
+// app/models/mimics/ControlElements.ts
+var CompressorJson = {
+  AutomaticSemiAuto: AutomaticSemiAutoJson,
+  CommandsStartStop: CommandsStartStopJson,
+  ControlLock: ControlLockJson,
+  FeedbackRunningStopped: FeedbackRunningStoppedJson,
+  OrderStartStop: OrderStartStopJson,
+  RemoteLocal: RemoteLocalJson,
+  TripReset: TripResetJson,
+  IsControl: false,
+  CompressorDesign: CompressorDesigns.NORMAL
+};
+var DamperJson = {
+  FeedbackAutoSemiAuto: AutomaticSemiAutoJson,
+  FeedbackOpCl: FeedbackOpClJson,
+  CommandsOpCl: CommandsOpClJson,
+  ControlLock: ControlLockJson,
+  OrderOpCl: OrderOpClJson,
+  RemoteLocal: RemoteLocalJson,
+  TripReset: TripResetJson,
+  IsControl: false
+};
+var DamperAutomatedJson = {
+  Damper: "",
+  CommandsOpClTrait: CommandsOpClJson,
+  TripResetTrait: TripResetJson
+};
+var FanJson = {
+  AutomaticSemiAuto: AutomaticSemiAutoJson,
+  ControlLock: ControlLockJson,
+  RemoteLocal: RemoteLocalJson,
+  TripReset: TripResetJson,
+  FanMode: FanTypes.SIMPLE,
+  FanDesign: FanDesigns.NORMAL,
+  SpeedFeedback: ChannelJson,
+  ConsignedSpeed: ChannelJson,
+  UserConsignedSpeed: ChannelJson,
+  RunFeedbackSupply: ChannelJson,
+  RunFeedbackSupplyFast: ChannelJson,
+  RunFeedbackExhaust: ChannelJson,
+  RunFeedbackExhaustFast: ChannelJson,
+  StoppedFeedback: ChannelJson,
+  StartOrderSupply: ChannelJson,
+  StartOrderSupplyFast: ChannelJson,
+  StartOrderExhaust: ChannelJson,
+  StartOrderExhaustFast: ChannelJson,
+  StopOrder: ChannelJson,
+  StartCommandSupply: ChannelJson,
+  StartCommandSupplyFast: ChannelJson,
+  StartCommandExhaust: ChannelJson,
+  StartCommandExhaustFast: ChannelJson,
+  StopCommand: ChannelJson,
+  StartCommandSupplyConfirmation: LocalizedTextJson,
+  StartCommandSupplyFastConfirmation: LocalizedTextJson,
+  StartCommandExhaustConfirmation: LocalizedTextJson,
+  StartCommandExhaustFastConfirmation: LocalizedTextJson,
+  StopCommandConfirmation: LocalizedTextJson
+};
+var PumpJson = {
+  AutomaticSemiAuto: AutomaticSemiAutoJson,
+  ControlLock: ControlLockJson,
+  CommandsStartStop: CommandsStartStopJson,
+  FeedbackRunningStopped: FeedbackRunningStoppedJson,
+  OrderStartStop: OrderStartStopJson,
+  RemoteLocal: RemoteLocalJson,
+  TripReset: TripResetJson,
+  IsControl: false,
+  PumpDesign: CompressorDesigns.NORMAL
+};
+var PumpAutomatedJson = {
+  Pump: "",
+  PumpDesign: CompressorDesigns.NORMAL,
+  AutomaticSemiAuto: AutomaticSemiAutoJson,
+  TripReset: TripResetJson
+};
+var TankJson = {
+  TankName: "",
+  LocationInfo: InfoLocations.RIGHT,
+  ShowVolume: true,
+  ShowVolumeInPercent: false,
+  ShowVolumeInMeters: false,
+  ShowVolumeInLitres: false,
+  ShowWeight: false,
+  ShowSounding: false,
+  TextValueHeight: 12,
+  TextValuePadding: 2,
+  BackgroundColor: "#FFFFFF",
+  ContentColor: "#000000",
+  ShowAlarmLimits: false,
+  MarkType: MarkTypes.SHORT_LINE,
+  Scale: ScaleJson
+};
+var ValveJson = {
+  IsControl: false,
+  ValveDesign: ValveDesigns.NORMAL,
+  FeedbackOpCl: FeedbackOpClJson,
+  CommandsOpCl: CommandsOpClJson,
+  OrderOpCl: OrderOpClJson,
+  ControlLock: ControlLockJson,
+  RemoteLocal: RemoteLocalJson,
+  TripReset: TripResetJson
+};
+var ValveAutomatedJson = {
+  Valve: "",
+  ValveDesign: ValveDesigns.NORMAL,
+  CommandsOpCl: CommandsOpClJson,
+  TripReset: TripResetJson
+};
+
+// app/models/mimics/Elements.ts
+var AlarmIndicatorJson = {
+  TextHeight: 12,
+  TextColor: "#FFFFFF",
+  Texts: LocalizedTextJson,
+  AlarmFeedback: ChannelJson
+};
+var CommandJson = {
+  TextHeight: 12,
+  MessageColor: "#FFFFFF",
+  TimeoutCommandCheck: 5,
+  CommandCheckColor: "#00FF00",
+  TimeoutCommandResult: 10,
+  CommandOkColor: "#00FF00",
+  CommandErrorColor: "#FF0000",
+  HasConfirmation: false,
+  HasPassword: false,
+  CommandChannel: ChannelJson,
+  CloseChannel: ChannelJson,
+  Messages: LocalizedTextJson,
+  ConfirmationMessages: LocalizedTextJson
+};
+var DialJson = {
+  Color: "#FFFFFF",
+  ShowTextValue: false,
+  Factor: 100,
+  ShowAlarmLimits: false,
+  ShowFactor: false,
+  DivisionsNumber: 3,
+  SubdivisionsNumber: 2,
+  Channel: ChannelJson
+};
+var DigitalJson = {
+  TextHeight: 12,
+  LedType: LedTypes.CIRCLE,
+  OpenLedColor: "#00FF00",
+  CloseLedColor: "#FF0000",
+  OpenTexts: LocalizedTextJson,
+  CloseTexts: LocalizedTextJson,
+  FeedbackOpCl: FeedbackOpClJson
+};
+var DisplayJson = {
+  HeightText: 12,
+  TextColor: "#FFFFFF",
+  ShowMeasureUnit: false,
+  NumCharactersDisplay: 8,
+  Channel: ChannelJson
+};
+var DynamicTextJson = {
+  TextAttributes: TextAttributesJson,
+  DefaultTextColor: "#FFFFFF",
+  DefaultText: LocalizedTextJson,
+  TextLogic: LogicExpressionsJson
+};
+var LevelBarJson = {
+  Orientation: LevelBarOrientations.VERTICAL,
+  BackgroundColor: "#000000",
+  ForegroundColor: "#00FF00",
+  ShowTextValue: false,
+  TextValueHeight: 12,
+  ValueType: ValueTypes.RAW,
+  ShowAlarmLimits: false,
+  MarkType: MarkTypes.LARGE_LINE,
+  Scale: ScaleJson,
+  LevelChannel: ChannelJson
+};
+var SliderJson = {
+  Orientation: SliderOrientations.VERTICAL,
+  Steps: 10,
+  ColorBackground: "#FFFFFF",
+  ColorValue: "#00FF00",
+  ColorValueCircle: "#0000FF",
+  HasTextValue: false,
+  ColorTextValue: "#000000",
+  TextValueFontSize: 12,
+  IsVisualizationOnly: false,
+  Channel: ChannelJson
+};
+var TextChannelJson = {
+  TextAttributes: TextAttributesJson,
+  Channel: ChannelJson
+};
+var ToggleJson = {
+  ColorCircle: "#FFFFFF",
+  ColorOnBackground: "#00FF00",
+  ColorOffBackground: "#FF0000",
+  DisplayValue: false,
+  OnTextValue: "ON",
+  OnTextValueColor: "#00FF00",
+  OffTextValue: "OFF",
+  OffTextValueColor: "#FF0000",
+  IsVisualizationOnly: false,
+  Channel: ChannelJson,
+  CommandOnChannel: ChannelJson,
+  CommandOffChannel: ChannelJson
+};
+
+// app/models/mimics/IasElements.ts
+var CabinetJson = {
+  Design: CabinetDesigns.IMAGE,
+  ImageName: "cabinet.png",
+  CabinetId: ""
+};
+var RepeaterJson = {
+  Design: RepeaterDesigns.IMAGE,
+  ImageName: "repeater.png",
+  RepeaterId: ""
+};
+var StationJson = {
+  Design: StationDesigns.IMAGE,
+  ImageName: "station.png",
+  StationId: ""
+};
+var UnitJson = {
+  Design: UnitDesigns.IMAGE,
+  ImageName: "unit.png",
+  UnitId: ""
+};
+
+// app/models/mimics/PmsElements.ts
+var BreakerJson = {
+  FeedbackOpCl: FeedbackOpClJson,
+  CommandsOpCl: CommandsOpClJson,
+  ControlLock: ControlLockJson,
+  OrderOpCl: OrderOpClJson,
+  RemoteLocal: RemoteLocalJson,
+  TripReset: TripResetJson,
+  AutomaticManual: AutomaticSemiAutoJson,
+  IsControl: false,
+  RemoteIconSize: 24
+};
+var BreakerPmsJson = {
+  Breaker: "",
+  RemoteIconSize: 24,
+  CommandsOpCl: CommandsOpClJson,
+  TripReset: TripResetJson
+};
+var GeneratorJson = {
+  AutomaticSemiAuto: AutomaticSemiAutoJson,
+  CommandsStartStop: CommandsStartStopJson,
+  FeedbackRunningStopped: FeedbackRunningStoppedJson,
+  OrderStartStop: OrderStartStopJson,
+  RemoteLocal: RemoteLocalJson,
+  TripReset: TripResetJson,
+  OrderAuto: ChannelJson,
+  OrderSemiAuto: ChannelJson,
+  IsControl: false
+};
+var GeneratorPmsJson = {
+  Generator: "",
+  GeneratorNameColor: "#FFFFFF",
+  AutomaticSemiAutoTrait: AutomaticSemiAutoJson,
+  CommandsStartStopTrait: CommandsStartStopJson,
+  TripResetTrait: TripResetJson
+};
+var OperationModesJson = {
+  TextHeight: 12,
+  ModeToReach: "",
+  Messages: LocalizedTextJson
+};
+var PriorityDataJson = {
+  Name: "",
+  ChannelPriority: "",
+  ChannelPriorityFeedback: ""
+};
+var PrioritiesJson = {
+  TextHeight: 12,
+  HasPassword: false,
+  Texts: LocalizedTextJson,
+  Priorities: []
+};
+var ShaftJson = {
+  WithFeedbackOpen: false,
+  ActivationMode: "",
+  ActivationValue: false,
+  OpenFeedback: ChannelJson,
+  CloseFeedback: ChannelJson
+};
+
 // app/index.ts
+var import_mongoose7 = __toESM(require("mongoose"), 1);
+var import_mongoose_autopopulate2 = __toESM(require("mongoose-autopopulate"), 1);
+var import_mongoose_paginate_v27 = __toESM(require("mongoose-paginate-v2"), 1);
+var import_mongoose_aggregate_paginate_v27 = __toESM(require("mongoose-aggregate-paginate-v2"), 1);
+var Schemas = {
+  Channel: Channel_default,
+  ChannelDataBucket: ChannelDataBucket_default,
+  ChannelDataPoint: ChannelDataPoint_default,
+  Event: Event_default,
+  History: History_default,
+  Unit: Unit_default
+};
+var Mimics = {
+  // Auxiliary
+  ImageAuxiliaryJson,
+  LineAuxiliaryJson,
+  LinkAuxiliaryJson,
+  PolylineAuxiliaryJson,
+  SquareAuxiliaryJson,
+  TextAuxiliaryJson,
+  // Channel
+  ChannelJson,
+  // Control elements
+  CompressorJson,
+  DamperJson,
+  DamperAutomatedJson,
+  FanJson,
+  PumpJson,
+  PumpAutomatedJson,
+  TankJson,
+  ValveJson,
+  ValveAutomatedJson,
+  // Elements
+  AlarmIndicatorJson,
+  CommandJson,
+  DialJson,
+  DigitalJson,
+  DisplayJson,
+  DynamicTextJson,
+  LevelBarJson,
+  SliderJson,
+  TextChannelJson,
+  ToggleJson,
+  // IAS elements
+  CabinetJson,
+  RepeaterJson,
+  StationJson,
+  UnitJson,
+  // Support
+  AddedAlarmsJson,
+  BackgroundJson,
+  LineJson,
+  LocalizedTextJson,
+  LocationJson,
+  LogicExpressionJson,
+  LogicExpressionsJson,
+  ScaleJson,
+  TextAttributesJson,
+  TitleJson,
+  // Traits
+  AutomaticSemiAutoJson,
+  CommandsOpClJson,
+  CommandsStartStopJson,
+  ControlLockJson,
+  FeedbackOpClJson,
+  FeedbackRunningStoppedJson,
+  OrderOpClJson,
+  OrderStartStopJson,
+  RemoteLocalJson,
+  TripResetJson,
+  // PMS elements
+  BreakerJson,
+  BreakerPmsJson,
+  GeneratorJson,
+  GeneratorPmsJson,
+  OperationModesJson,
+  PriorityDataJson,
+  PrioritiesJson,
+  ShaftJson
+};
+var MimicsTypes = {
+  MimicElementTypes,
+  ZDepths,
+  TitleAligns,
+  DigitalStates,
+  DigitalAlarmStates,
+  AlarmStates,
+  ActivationModes,
+  TextAnchorPoints,
+  ValveDesigns,
+  FanDesigns,
+  FanRunStates,
+  FanDirections,
+  FanTypes,
+  LevelBarOrientations,
+  SliderOrientations,
+  CompressorDesigns,
+  LedTypes,
+  InfoLocations,
+  MarkTypes,
+  ScalePositions,
+  ValueTypes,
+  OperationModeStates,
+  UnitDesigns,
+  StationDesigns,
+  RepeaterDesigns,
+  CabinetDesigns,
+  LinkDesigns,
+  OpClStates,
+  RunningStoppedStates
+};
 var Types = {
   AlarmTypes,
   AlarmPriorities,
   CloudAlarmStates,
   DiamarAlarmStates,
-  ChannelBaseTypes,
-  ChannelSpecificTypes,
   EventCategories,
-  EventCriticalities,
-  UnitTypes
+  Mimics: MimicsTypes
+};
+var index_default = {
+  Schemas,
+  Docs: docs_default,
+  Mimics,
+  Types,
+  mongoose: import_mongoose7.default,
+  mongoosePaginate: import_mongoose_paginate_v27.default,
+  mongooseAggregatePaginate: import_mongoose_aggregate_paginate_v27.default,
+  mongooseAutopopulate: import_mongoose_autopopulate2.default
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Types
-});