@sedni/cloud_common 1.2.0 → 2.0.0

package/dist/node-entry.js

@@ -0,0 +1,1078 @@
+import {
+  __commonJS,
+  __require,
+  __toCommonJS,
+  alarm_types_exports,
+  event_types_exports,
+  init_alarm_types,
+  init_event_types,
+  init_unit_types,
+  unit_types_exports
+} from "./chunk-NCUZ3O3P.js";
+
+// app/models/Channel.cjs
+var require_Channel = __commonJS({
+  "app/models/Channel.cjs"(exports, module) {
+    "use strict";
+    var mongoose = __require("mongoose");
+    var mongooseAutopopulate = __require("mongoose-autopopulate");
+    var mongoosePaginate = __require("mongoose-paginate-v2");
+    var mongooseAggregatePaginate = __require("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);
+    module.exports = channelSchema;
+  }
+});
+
+// app/models/ChannelDataBucket.cjs
+var require_ChannelDataBucket = __commonJS({
+  "app/models/ChannelDataBucket.cjs"(exports, module) {
+    "use strict";
+    var mongoose = __require("mongoose");
+    var mongooseAutopopulate = __require("mongoose-autopopulate");
+    var mongoosePaginate = __require("mongoose-paginate-v2");
+    var mongooseAggregatePaginate = __require("mongoose-aggregate-paginate-v2");
+    var dataPointSchema = new mongoose.Schema({
+      timestamp: {
+        type: Number,
+        required: true
+      },
+      value: {
+        type: Number,
+        required: true
+      }
+    }, {
+      _id: false
+    });
+    var channeldataBucketSchema = new mongoose.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 }, { expireAfterSeconds: 60 * 60 * 24 * 365, background: true });
+    channeldataBucketSchema.plugin(mongoosePaginate);
+    channeldataBucketSchema.plugin(mongooseAggregatePaginate);
+    channeldataBucketSchema.plugin(mongooseAutopopulate);
+    channeldataBucketSchema.methods.insertDataPoint = async function(timestamp, value) {
+      this.data.push({ timestamp, value });
+      this.size++;
+      this.sum += value;
+      await this.save();
+    };
+    channeldataBucketSchema.methods.removeDataPointsOutsideDateRange = function(start_date, end_date) {
+      start_date = start_date instanceof Date ? start_date.getTime() : start_date;
+      end_date = end_date instanceof Date ? end_date.getTime() : end_date;
+      this.data = this.data.filter((data_point) => data_point.timestamp >= start_date && data_point.timestamp < end_date);
+      this.size = this.data.length;
+      this.sum = this.data.reduce((sum, data_point) => sum + data_point.value, 0);
+    };
+    channeldataBucketSchema.methods.isBucketClosed = function(timestamp = Date.now()) {
+      return timestamp >= this.end_date.getTime();
+    };
+    channeldataBucketSchema.statics.insertDataPoint = async function(timestamp, value) {
+      const date = new Date(timestamp);
+      date.setMinutes(0);
+      date.setSeconds(0);
+      date.setMilliseconds(0);
+      const bucket = await this.findOneAndUpdate(
+        {
+          start_date: date
+        },
+        {
+          $push: {
+            data: {
+              timestamp,
+              value
+            }
+          },
+          $inc: {
+            size: 1,
+            sum: value
+          },
+          $set: {
+            end_date: new Date(date.getTime() + 1e3 * 60 * 60)
+          }
+        },
+        {
+          upsert: true,
+          new: true
+        }
+      );
+      return bucket;
+    };
+    channeldataBucketSchema.statics.lastTimeSynced = async function(options) {
+      let last_sync = 0;
+      if (options?.channel_tag && options?.db) {
+        const channel = await options.db.collection("channels").findOne({
+          channel_tag: options.channel_tag
+        });
+        last_sync = channel.channel_last_bucket_sync.getTime();
+      }
+      return last_sync;
+    };
+    channeldataBucketSchema.statics.getNotUploadedData = async function(options) {
+      const last_sync = options?.last_sync ?? await this.lastTimeSynced(options);
+      const buckets = await this.find({
+        end_date: {
+          $gt: new Date(last_sync)
+        }
+      });
+      return buckets;
+    };
+    channeldataBucketSchema.statics.getData = async function(start_date, end_date, plain = false) {
+      const date = new Date(start_date);
+      date.setMinutes(0);
+      date.setSeconds(0);
+      date.setMilliseconds(0);
+      const data = await this.find({
+        start_date: {
+          $gte: date,
+          $lt: new Date(end_date)
+        }
+      });
+      if (!data || data.length === 0) {
+        return [];
+      }
+      data[0].removeDataPointsOutsideDateRange(start_date, end_date);
+      if (data.length > 1) {
+        data[1].removeDataPointsOutsideDateRange(start_date, end_date);
+      }
+      return plain ? data.flatMap((bucket) => {
+        return bucket.data.map((data_point) => {
+          return {
+            timestamp: data_point.timestamp,
+            value: data_point.value
+          };
+        });
+      }) : data;
+    };
+    channeldataBucketSchema.statics.upsertBucket = async function(bucket) {
+      const date = new Date(bucket.start_date);
+      date.setMinutes(0);
+      date.setSeconds(0);
+      date.setMilliseconds(0);
+      const result = await this.updateOne(
+        {
+          start_date: date
+        },
+        {
+          $set: {
+            data: bucket.data,
+            size: bucket.size,
+            sum: bucket.sum,
+            end_date: new Date(date.getTime() + 1e3 * 60 * 60)
+          }
+        },
+        {
+          upsert: true
+        }
+      );
+      return result;
+    };
+    module.exports = channeldataBucketSchema;
+  }
+});
+
+// app/models/Event.cjs
+var require_Event = __commonJS({
+  "app/models/Event.cjs"(exports, module) {
+    "use strict";
+    var mongoose = __require("mongoose");
+    var mongooseAutopopulate = __require("mongoose-autopopulate");
+    var mongoosePaginate = __require("mongoose-paginate-v2");
+    var mongooseAggregatePaginate = __require("mongoose-aggregate-paginate-v2");
+    var { EventCategories, EventCriticalities } = (init_event_types(), __toCommonJS(event_types_exports));
+    var eventSchema = new mongoose.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 oneYear = 60 * 60 * 24 * 365;
+    eventSchema.addTTLIndex = function(ttlField, expirationTimeInSeconds = oneYear) {
+      this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
+    };
+    eventSchema.plugin(mongoosePaginate);
+    eventSchema.plugin(mongooseAggregatePaginate);
+    eventSchema.plugin(mongooseAutopopulate);
+    module.exports = eventSchema;
+  }
+});
+
+// app/models/History.cjs
+var require_History = __commonJS({
+  "app/models/History.cjs"(exports, module) {
+    "use strict";
+    var mongoose = __require("mongoose");
+    var mongooseAutopopulate = __require("mongoose-autopopulate");
+    var mongoosePaginate = __require("mongoose-paginate-v2");
+    var mongooseAggregatePaginate = __require("mongoose-aggregate-paginate-v2");
+    var { AlarmTypes, AlarmPriorities, CloudAlarmStates, DiamarAlarmStates } = (init_alarm_types(), __toCommonJS(alarm_types_exports));
+    var historySchema = new mongoose.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 oneYear = 60 * 60 * 24 * 365;
+    historySchema.addTTLIndex = function(ttlField, expirationTimeInSeconds = oneYear) {
+      this.index({ [ttlField]: 1 }, { expireAfterSeconds: expirationTimeInSeconds });
+    };
+    historySchema.plugin(mongoosePaginate);
+    historySchema.plugin(mongooseAggregatePaginate);
+    historySchema.plugin(mongooseAutopopulate);
+    module.exports = historySchema;
+  }
+});
+
+// app/models/Unit.cjs
+var require_Unit = __commonJS({
+  "app/models/Unit.cjs"(exports, module) {
+    "use strict";
+    var mongoose = __require("mongoose");
+    var mongooseAutopopulate = __require("mongoose-autopopulate");
+    var mongoosePaginate = __require("mongoose-paginate-v2");
+    var mongooseAggregatePaginate = __require("mongoose-aggregate-paginate-v2");
+    var { UnitTypes } = (init_unit_types(), __toCommonJS(unit_types_exports));
+    var unitSchema = new mongoose.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(mongoosePaginate);
+    unitSchema.plugin(mongooseAggregatePaginate);
+    unitSchema.plugin(mongooseAutopopulate);
+    module.exports = unitSchema;
+  }
+});
+
+// app/models/docs/Channel.json
+var require_Channel2 = __commonJS({
+  "app/models/docs/Channel.json"(exports, module) {
+    module.exports = {
+      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 require_ChannelDataBucket2 = __commonJS({
+  "app/models/docs/ChannelDataBucket.json"(exports, module) {
+    module.exports = {
+      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
+              }
+            }
+          },
+          DataPoint: {
+            type: "object",
+            description: "DataPoint 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: {
+              timestamp: {
+                type: "integer",
+                format: "int64",
+                description: "Timestamp of the data",
+                example: 1710251647e3,
+                readOnly: true
+              },
+              value: {
+                type: "number",
+                format: "double",
+                description: "Value 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: [
+              {
+                timestamp: 1710251647e3,
+                value: 69.42
+              }
+            ],
+            size: 60,
+            synced: "TODO",
+            sum: 69.42
+          },
+          DataPoint: {
+            timestamp: 1710251647e3,
+            value: 69.42
+          }
+        }
+      }
+    };
+  }
+});
+
+// app/models/docs/ChannelWithData.json
+var require_ChannelWithData = __commonJS({
+  "app/models/docs/ChannelWithData.json"(exports, module) {
+    module.exports = {
+      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/DataPoint.json
+var require_DataPoint = __commonJS({
+  "app/models/docs/DataPoint.json"(exports, module) {
+    module.exports = {
+      components: {
+        schemas: {
+          DataPoint: {
+            type: "object",
+            description: "DataPoint 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: {
+              timestamp: {
+                type: "integer",
+                format: "int64",
+                description: "Timestamp of the data",
+                example: 1710251647e3,
+                readOnly: true
+              },
+              value: {
+                type: "number",
+                format: "double",
+                description: "Value of the data",
+                example: 69.42,
+                readOnly: true
+              }
+            }
+          }
+        },
+        examples: {
+          DataPoint: {
+            timestamp: 1710251647e3,
+            value: 69.42
+          }
+        }
+      }
+    };
+  }
+});
+
+// app/models/docs/Event.json
+var require_Event2 = __commonJS({
+  "app/models/docs/Event.json"(exports, module) {
+    module.exports = {
+      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 require_History2 = __commonJS({
+  "app/models/docs/History.json"(exports, module) {
+    module.exports = {
+      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 require_Unit2 = __commonJS({
+  "app/models/docs/Unit.json"(exports, module) {
+    module.exports = {
+      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.cjs
+var require_docs = __commonJS({
+  "app/models/docs/index.cjs"(exports, module) {
+    "use strict";
+    var { AlarmTypes, AlarmPriorities, CloudAlarmStates, DiamarAlarmStates } = (init_alarm_types(), __toCommonJS(alarm_types_exports));
+    var { EventCategories } = (init_event_types(), __toCommonJS(event_types_exports));
+    var ChannelDocs = require_Channel2();
+    var ChannelDataBucketDocs = require_ChannelDataBucket2();
+    var ChannelWithDataDocs = require_ChannelWithData();
+    var DataPointDocs = require_DataPoint();
+    var EventDocs = require_Event2();
+    var HistoryDocs = require_History2();
+    var UnitDocs = require_Unit2();
+    HistoryDocs.components.schemas.History.properties.alarm_priority.enum = Object.values(AlarmPriorities);
+    HistoryDocs.components.schemas.History.properties.alarm_state.enum = Object.values(CloudAlarmStates);
+    HistoryDocs.components.schemas.History.properties.alarm_original_state.enum = Object.values(DiamarAlarmStates);
+    HistoryDocs.components.schemas.History.properties.alarm_type.enum = Object.values(AlarmTypes);
+    EventDocs.components.schemas.Event.properties.event_category.enum = Object.values(EventCategories);
+    var Docs = {
+      ChannelDocs,
+      ChannelDataBucketDocs,
+      ChannelWithDataDocs,
+      DataPointDocs,
+      EventDocs,
+      HistoryDocs,
+      UnitDocs
+    };
+    module.exports = Docs;
+  }
+});
+
+// app/node-entry.cjs
+var require_node_entry = __commonJS({
+  "app/node-entry.cjs"(exports, module) {
+    var Channel = require_Channel();
+    var ChannelDataBucket = require_ChannelDataBucket();
+    var Event = require_Event();
+    var History = require_History();
+    var Unit = require_Unit();
+    var Schemas = {
+      Channel,
+      ChannelDataBucket,
+      Event,
+      History,
+      Unit
+    };
+    var Docs = require_docs();
+    var { AlarmTypes, AlarmPriorities, CloudAlarmStates, DiamarAlarmStates } = (init_alarm_types(), __toCommonJS(alarm_types_exports));
+    var { EventCategories } = (init_event_types(), __toCommonJS(event_types_exports));
+    var Types = {
+      AlarmTypes,
+      AlarmPriorities,
+      CloudAlarmStates,
+      DiamarAlarmStates,
+      EventCategories
+    };
+    var mongoose = __require("mongoose");
+    var mongooseAutopopulate = __require("mongoose-autopopulate");
+    var mongoosePaginate = __require("mongoose-paginate-v2");
+    var mongooseAggregatePaginate = __require("mongoose-aggregate-paginate-v2");
+    module.exports = {
+      Schemas,
+      Docs,
+      Types,
+      mongoose,
+      mongoosePaginate,
+      mongooseAggregatePaginate,
+      mongooseAutopopulate
+    };
+  }
+});
+export default require_node_entry();