@sedni/cloud_common 2.1.0 → 3.0.0

package/dist/index.js

@@ -1,65 +1,1102 @@
 import {
+  ActivationModes,
+  AddedAlarmsJson,
+  AlarmIndicatorJson,
   AlarmPriorities,
+  AlarmStates,
   AlarmTypes,
+  AutomaticSemiAutoJson,
+  BackgroundJson,
+  BreakerJson,
+  BreakerPmsJson,
+  CabinetDesigns,
+  CabinetJson,
+  ChannelJson,
   CloudAlarmStates,
+  CommandJson,
+  CommandsOpClJson,
+  CommandsStartStopJson,
+  CompressorDesigns,
+  CompressorJson,
+  ControlLockJson,
+  DamperAutomatedJson,
+  DamperJson,
+  DialJson,
   DiamarAlarmStates,
+  DigitalAlarmStates,
+  DigitalJson,
+  DigitalStates,
+  DisplayJson,
+  DynamicTextJson,
   EventCategories,
   EventCriticalities,
+  FanDesigns,
+  FanDirections,
+  FanJson,
+  FanRunStates,
+  FanTypes,
+  FeedbackOpClJson,
+  FeedbackRunningStoppedJson,
+  GeneratorJson,
+  GeneratorPmsJson,
+  ImageAuxiliaryJson,
+  InfoLocations,
+  LedTypes,
+  LevelBarJson,
+  LevelBarOrientations,
+  LineAuxiliaryJson,
+  LineJson,
+  LinkAuxiliaryJson,
+  LinkDesigns,
+  LocalizedTextJson,
+  LocationJson,
+  LogicExpressionJson,
+  LogicExpressionsJson,
+  MarkTypes,
+  MimicElementTypes,
+  OpClStates,
+  OperationModeStates,
+  OperationModesJson,
+  OrderOpClJson,
+  OrderStartStopJson,
+  PolylineAuxiliaryJson,
+  PrioritiesJson,
+  PriorityDataJson,
+  PumpAutomatedJson,
+  PumpJson,
+  RemoteLocalJson,
+  RepeaterDesigns,
+  RepeaterJson,
+  RunningStoppedStates,
+  ScaleJson,
+  ScalePositions,
+  ShaftJson,
+  SliderJson,
+  SliderOrientations,
+  SquareAuxiliaryJson,
+  StationDesigns,
+  StationJson,
+  TankJson,
+  TextAnchorPoints,
+  TextAttributesJson,
+  TextAuxiliaryJson,
+  TextChannelJson,
+  TitleAligns,
+  TitleJson,
+  ToggleJson,
+  TripResetJson,
+  UnitDesigns,
+  UnitJson,
   UnitTypes,
-  init_alarm_types,
-  init_event_types,
-  init_unit_types
-} from "./chunk-AOC7BD5E.js";
+  ValueTypes,
+  ValveAutomatedJson,
+  ValveDesigns,
+  ValveJson,
+  ZDepths
+} from "./chunk-FO3TASV6.js";
 
-// app/index.ts
-init_alarm_types();
+// app/models/Channel.ts
+import mongoose from "mongoose";
+import mongooseAutopopulate from "mongoose-autopopulate";
+import mongoosePaginate from "mongoose-paginate-v2";
+import mongooseAggregatePaginate from "mongoose-aggregate-paginate-v2";
+var channelSchema = new mongoose.Schema({
+  channel_tag: {
+    type: String,
+    required: true
+  },
+  channel_description: {
+    type: String,
+    required: true
+  },
+  channel_unit_id: {
+    type: mongoose.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(mongoosePaginate);
+channelSchema.plugin(mongooseAggregatePaginate);
+channelSchema.plugin(mongooseAutopopulate);
+var Channel_default = channelSchema;
+
+// app/models/ChannelDataBucket.ts
+import mongoose2 from "mongoose";
+import mongoosePaginate2 from "mongoose-paginate-v2";
+import mongooseAggregatePaginate2 from "mongoose-aggregate-paginate-v2";
+var dataPointSchema = new mongoose2.Schema({
+  channel_id: {
+    type: String,
+    required: true,
+    index: true
+  },
+  timestamp: {
+    type: Number,
+    required: true
+  },
+  value: {
+    type: Number,
+    required: true
+  }
+}, {
+  _id: false
+});
+var channeldataBucketSchema = new mongoose2.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(mongoosePaginate2);
+channeldataBucketSchema.plugin(mongooseAggregatePaginate2);
+var ChannelDataBucket_default = channeldataBucketSchema;
+
+// app/models/ChannelDataPoint.ts
+import mongoose3 from "mongoose";
+import mongoosePaginate3 from "mongoose-paginate-v2";
+import mongooseAggregatePaginate3 from "mongoose-aggregate-paginate-v2";
+var channelDataPointSchema = new mongoose3.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(mongoosePaginate3);
+channelDataPointSchema.plugin(mongooseAggregatePaginate3);
+var ChannelDataPoint_default = channelDataPointSchema;
+
+// app/models/Event.ts
+import mongoose4 from "mongoose";
+import mongoosePaginate4 from "mongoose-paginate-v2";
+import mongooseAggregatePaginate4 from "mongoose-aggregate-paginate-v2";
+var eventSchema = new mongoose4.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(mongoosePaginate4);
+eventSchema.plugin(mongooseAggregatePaginate4);
+var Event_default = eventSchema;
+
+// app/models/History.ts
+import mongoose5 from "mongoose";
+import mongoosePaginate5 from "mongoose-paginate-v2";
+import mongooseAggregatePaginate5 from "mongoose-aggregate-paginate-v2";
+var historySchema = new mongoose5.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(mongoosePaginate5);
+historySchema.plugin(mongooseAggregatePaginate5);
+var History_default = historySchema;
+
+// app/models/Unit.ts
+import mongoose6 from "mongoose";
+import mongoosePaginate6 from "mongoose-paginate-v2";
+import mongooseAggregatePaginate6 from "mongoose-aggregate-paginate-v2";
+var unitSchema = new mongoose6.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(mongoosePaginate6);
+unitSchema.plugin(mongooseAggregatePaginate6);
+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/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/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/index.ts
-init_event_types();
-init_unit_types();
+import mongoose7 from "mongoose";
+import mongooseAutopopulate2 from "mongoose-autopopulate";
+import mongoosePaginate7 from "mongoose-paginate-v2";
+import mongooseAggregatePaginate7 from "mongoose-aggregate-paginate-v2";
+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: mongoose7,
+  mongoosePaginate: mongoosePaginate7,
+  mongooseAggregatePaginate: mongooseAggregatePaginate7,
+  mongooseAutopopulate: mongooseAutopopulate2
 };
 export {
-  Types
+  index_default as default
 };