@sedni/cloud_common 2.1.0 → 3.0.0

package/dist/index.d.ts

@@ -1,197 +1,939 @@
-declare const AlarmPriorities: {
-    readonly CRITICAL: "Critical";
-    readonly ALARM: "Alarm";
-    readonly WARNING: "Warning";
-};
-type AlarmPriority = (typeof AlarmPriorities)[keyof typeof AlarmPriorities];
-declare const DiamarAlarmStates: {
-    readonly INACTIVE: "Inactive";
-    readonly ACKNOWLEDGED: "Acknowledged";
-    readonly ACTIVE: "Active";
-    readonly UNACKNOWLEDGED: "Unacknowledged";
-    readonly UNDEFINED: "Undefined";
-};
-type DiamarAlarmState = (typeof DiamarAlarmStates)[keyof typeof DiamarAlarmStates];
-declare const CloudAlarmStates: {
-    readonly INACTIVE: "Inactive";
-    readonly ALARM: "Active";
-    readonly ALARM_ACK: "Acknowledged";
-    readonly WARNING: "WarningActive";
-    readonly WARNING_ACK: "WarningAcknowledged";
-    readonly RETURN_NO_ACK: "Unacknowledged";
-    readonly INHIBITED: "Inhibited";
-    readonly OFFSCAN: "Offscan";
-    readonly UNDEFINED: "Undefined";
-};
-type CloudAlarmState = (typeof CloudAlarmStates)[keyof typeof CloudAlarmStates];
-declare const AlarmTypes: {
-    readonly NORMAL: "Normal";
-    readonly ALARM_OPEN: "AlarmOpen";
-    readonly ALARM_CLOSE: "AlarmClose";
-    readonly ALARM_IFH: "AlarmIfh";
-    readonly ALARM_HH: "AlarmHh";
-    readonly ALARM_H: "AlarmH";
-    readonly ALARM_L: "AlarmL";
-    readonly ALARM_LL: "AlarmLl";
-    readonly ALARM_IFL: "AlarmIfl";
-    readonly ALARM_OFFSCAN: "AlarmOffScan";
-    readonly ALARM_FAIL: "AlarmFail";
-    readonly ALARM_INH: "AlarmInh";
-    readonly ALARM_UNK: "AlarmUnk";
+import { aD as UnitTypes, aE as AlarmPriorities, aF as DiamarAlarmStates, aG as CloudAlarmStates, aH as AlarmTypes, aI as EventCategories, aJ as EventCriticalities, I as ImageAuxiliaryJsonSchema, L as LineAuxiliaryJsonSchema, a as LinkAuxiliaryJsonSchema, P as PolylineAuxiliaryJsonSchema, S as SquareAuxiliaryJsonSchema, T as TextAuxiliaryJsonSchema, C as ChannelJsonSchema, b as CompressorJsonSchema, D as DamperJsonSchema, c as DamperAutomatedJsonSchema, F as FanJsonSchema, d as PumpJsonSchema, e as PumpAutomatedJsonSchema, f as TankJsonSchema, V as ValveJsonSchema, g as ValveAutomatedJsonSchema, A as AlarmIndicatorJsonSchema, h as CommandJsonSchema, i as DialJsonSchema, j as DigitalJsonSchema, k as DisplayJsonSchema, l as DynamicTextJsonSchema, m as LevelBarJsonSchema, n as SliderJsonSchema, o as TextChannelJsonSchema, p as ToggleJsonSchema, q as CabinetJsonSchema, R as RepeaterJsonSchema, r as StationJsonSchema, U as UnitJsonSchema, s as AddedAlarmsJsonSchema, B as BackgroundJsonSchema, t as LineJsonSchema, u as LocalizedTextJsonSchema, v as LocationJsonSchema, w as LogicExpressionJsonSchema, x as LogicExpressionsJsonSchema, y as ScaleJsonSchema, z as TextAttributesJsonSchema, E as TitleJsonSchema, G as AutomaticSemiAutoJsonSchema, H as CommandsOpClJsonSchema, J as CommandsStartStopJsonSchema, K as ControlLockJsonSchema, M as FeedbackOpClJsonSchema, N as FeedbackRunningStoppedJsonSchema, O as OrderOpClJsonSchema, Q as OrderStartStopJsonSchema, W as RemoteLocalJsonSchema, X as TripResetJsonSchema, Y as BreakerJsonSchema, Z as BreakerPmsJsonSchema, _ as GeneratorJsonSchema, $ as GeneratorPmsJsonSchema, a0 as OperationModesJsonSchema, a1 as PriorityDataJsonSchema, a2 as PrioritiesJsonSchema, a3 as ShaftJsonSchema } from './unit.types-BhezeBWA.js';
+import mongoose from 'mongoose';
+import mongooseAutopopulate from 'mongoose-autopopulate';
+import mongoosePaginate from 'mongoose-paginate-v2';
+import mongooseAggregatePaginate from 'mongoose-aggregate-paginate-v2';
+
+type UnitDocument = mongoose.Document & {
+    unit_id: string;
+    unit_enabled: boolean;
+    unit_type: typeof UnitTypes;
+    unit_internal_description: string;
+    unit_cabinet_id?: string;
 };
-type AlarmType = (typeof AlarmTypes)[keyof typeof AlarmTypes];
 
-declare const ChannelBaseTypes: {
-    readonly VIRTUAL_ANALOG: "VirtualAnalog";
-    readonly VIRTUAL_DIGITAL: "VirtualDigital";
-    readonly VIRTUAL_STRING: "VirtualString";
-    readonly WIRED_ANALOG: "WiredAnalog";
-    readonly WIRED_DIGITAL: "WiredDigital";
+type HistoryDocument = mongoose.Document & {
+    channel_tag: string;
+    alarm_timestamp: Date;
+    alarm_priority: typeof AlarmPriorities;
+    alarm_original_state: typeof DiamarAlarmStates;
+    alarm_state: typeof CloudAlarmStates;
+    alarm_type: typeof AlarmTypes;
+    alarm_value?: number;
+    alarm_message?: string;
+    alarm_data?: Object;
 };
-type ChannelBaseType = (typeof ChannelBaseTypes)[keyof typeof ChannelBaseTypes];
-declare const ChannelSpecificTypes: {
-    readonly DIGITAL_INPUT: "DigitalInput";
-    readonly DIGITAL_OUTPUT: "DigitalOutput";
-    readonly ANALOG_INPUT: "AnalogInput";
-    readonly ANALOG_OUTPUT: "AnalogOutput";
-    readonly ANALOG_SOFTWARE: "AnalogSoftware";
-    readonly DIGITAL_SOFTWARE: "DigitalSoftware";
-    readonly VIRTUAL_STRING: "VirtualString";
-    readonly COMMAND: "Command";
-    readonly BROADCAST_COMMAND: "BroadcastCommand";
-    readonly SOFTWARE: "Software";
-    readonly ANALOG_TIMER: "AnalogTimer";
-    readonly SERIAL_DIGITAL_INPUT: "SerialDigitalInput";
-    readonly SERIAL_DIGITAL_OUTPUT: "SerialDigitalOutput";
-    readonly SERIAL_LINE_COMMAND: "SerialLineCommand";
-    readonly SERIAL_ANALOG_INPUT: "SerialAnalogInput";
-    readonly SERIAL_ANALOG_OUTPUT: "SerialAnalogOutput";
+
+type EventDocument = mongoose.Document & {
+    event_message: string;
+    event_source: string;
+    event_user?: string;
+    event_category: typeof EventCategories;
+    event_criticality: typeof EventCriticalities;
+    event_type: string;
+    event_timestamp: Date;
+    event_data?: Object;
 };
-type ChannelSpecificType = (typeof ChannelSpecificTypes)[keyof typeof ChannelSpecificTypes];
 
-declare const EventCategories: {
-    readonly ACCESS_CONTROL: "AccessControl";
-    readonly REQUEST_ERROR: "RequestErrors";
-    readonly OS: "OperatingSystemEvents";
-    readonly CONTROL: "ControlSystemEvents";
-    readonly BACKUP: "BackupAndRestoreEvents";
-    readonly CONFIG_CHANGE: "ConfigurationChanges";
-    readonly LOGS: "AuditLogEvents";
-    readonly POTENTIAL_ATTACK: "PotentialAttackActivity";
+type ChannelDataPointDocument = mongoose.Document & {
+    c: string;
+    t: Date;
+    v: number;
 };
-type EventCategory = (typeof EventCategories)[keyof typeof EventCategories];
-declare const EventCriticalities: {
-    readonly VERBOSE: "Verbose";
-    readonly INFO: "Info";
-    readonly WARNING: "Warning";
-    readonly ERROR: "Error";
-    readonly CRITICAL: "Critical";
+
+type ChannelDataBucketDocument = mongoose.Document & {
+    start_date: Date;
+    end_date: Date;
+    data: {
+        channel_id: string;
+        timestamp: number;
+        value: number;
+    }[];
+    size: number;
+    synced: number;
+    sum: number;
 };
-type EventCriticality = (typeof EventCriticalities)[keyof typeof EventCriticalities];
 
-declare const UnitTypes: {
-    readonly AIM18: "Aim18";
-    readonly DIM36: "Dim36";
-    readonly DIOM24: "Diom24";
-    readonly KLIM: "Klim";
-    readonly LUM: "Lum";
-    readonly PMM: "Pmm";
-    readonly SLIM: "Slim";
-    readonly TIM28: "Tim28";
+type ChannelDocument = mongoose.Document & {
+    channel_tag: string;
+    channel_description: string;
+    channel_unit_id: mongoose.Types.ObjectId;
+    channel_parsed: Object;
+    channel_last_bucket_sync?: Date;
 };
-type UnitType = (typeof UnitTypes)[keyof typeof UnitTypes];
 
-declare const Types: {
-    AlarmTypes: {
-        readonly NORMAL: "Normal";
-        readonly ALARM_OPEN: "AlarmOpen";
-        readonly ALARM_CLOSE: "AlarmClose";
-        readonly ALARM_IFH: "AlarmIfh";
-        readonly ALARM_HH: "AlarmHh";
-        readonly ALARM_H: "AlarmH";
-        readonly ALARM_L: "AlarmL";
-        readonly ALARM_LL: "AlarmLl";
-        readonly ALARM_IFL: "AlarmIfl";
-        readonly ALARM_OFFSCAN: "AlarmOffScan";
-        readonly ALARM_FAIL: "AlarmFail";
-        readonly ALARM_INH: "AlarmInh";
-        readonly ALARM_UNK: "AlarmUnk";
-    };
-    AlarmPriorities: {
-        readonly CRITICAL: "Critical";
-        readonly ALARM: "Alarm";
-        readonly WARNING: "Warning";
-    };
-    CloudAlarmStates: {
-        readonly INACTIVE: "Inactive";
-        readonly ALARM: "Active";
-        readonly ALARM_ACK: "Acknowledged";
-        readonly WARNING: "WarningActive";
-        readonly WARNING_ACK: "WarningAcknowledged";
-        readonly RETURN_NO_ACK: "Unacknowledged";
-        readonly INHIBITED: "Inhibited";
-        readonly OFFSCAN: "Offscan";
-        readonly UNDEFINED: "Undefined";
-    };
-    DiamarAlarmStates: {
-        readonly INACTIVE: "Inactive";
-        readonly ACKNOWLEDGED: "Acknowledged";
-        readonly ACTIVE: "Active";
-        readonly UNACKNOWLEDGED: "Unacknowledged";
-        readonly UNDEFINED: "Undefined";
-    };
-    ChannelBaseTypes: {
-        readonly VIRTUAL_ANALOG: "VirtualAnalog";
-        readonly VIRTUAL_DIGITAL: "VirtualDigital";
-        readonly VIRTUAL_STRING: "VirtualString";
-        readonly WIRED_ANALOG: "WiredAnalog";
-        readonly WIRED_DIGITAL: "WiredDigital";
-    };
-    ChannelSpecificTypes: {
-        readonly DIGITAL_INPUT: "DigitalInput";
-        readonly DIGITAL_OUTPUT: "DigitalOutput";
-        readonly ANALOG_INPUT: "AnalogInput";
-        readonly ANALOG_OUTPUT: "AnalogOutput";
-        readonly ANALOG_SOFTWARE: "AnalogSoftware";
-        readonly DIGITAL_SOFTWARE: "DigitalSoftware";
-        readonly VIRTUAL_STRING: "VirtualString";
-        readonly COMMAND: "Command";
-        readonly BROADCAST_COMMAND: "BroadcastCommand";
-        readonly SOFTWARE: "Software";
-        readonly ANALOG_TIMER: "AnalogTimer";
-        readonly SERIAL_DIGITAL_INPUT: "SerialDigitalInput";
-        readonly SERIAL_DIGITAL_OUTPUT: "SerialDigitalOutput";
-        readonly SERIAL_LINE_COMMAND: "SerialLineCommand";
-        readonly SERIAL_ANALOG_INPUT: "SerialAnalogInput";
-        readonly SERIAL_ANALOG_OUTPUT: "SerialAnalogOutput";
+declare const _default: {
+    Schemas: {
+        Channel: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+            timestamps: {
+                createdAt: true;
+                updatedAt: true;
+            };
+            collection: string;
+            toJSON: {
+                transform: (doc: ChannelDocument, ret: any) => void;
+            };
+        }, {
+            createdAt: NativeDate;
+            updatedAt: NativeDate;
+        } & {
+            channel_tag: string;
+            channel_description: string;
+            channel_unit_id: mongoose.Types.ObjectId;
+            channel_parsed: any;
+            channel_last_bucket_sync?: NativeDate | null | undefined;
+        }, ChannelDocument>;
+        ChannelDataBucket: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+            toJSON: {
+                transform: (doc: ChannelDataBucketDocument, ret: any) => void;
+            };
+            versionKey: false;
+        }, {
+            start_date: NativeDate;
+            end_date: NativeDate;
+            data: mongoose.Types.DocumentArray<{
+                channel_id: string;
+                timestamp: number;
+                value: number;
+            }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, any, {
+                channel_id: string;
+                timestamp: number;
+                value: number;
+            }> & {
+                channel_id: string;
+                timestamp: number;
+                value: number;
+            }>;
+            size: number;
+            synced: number;
+            sum: number;
+        }, ChannelDataBucketDocument>;
+        ChannelDataPoint: mongoose.Schema<ChannelDataPointDocument, mongoose.Model<ChannelDataPointDocument, any, any, any, mongoose.Document<unknown, any, ChannelDataPointDocument, any, {}> & mongoose.Document<unknown, any, any, Record<string, any>, {}> & {
+            c: string;
+            t: Date;
+            v: number;
+        } & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ChannelDataPointDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<ChannelDataPointDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<ChannelDataPointDocument> & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }> & {
+            addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+        };
+        Event: mongoose.Schema<EventDocument, mongoose.Model<EventDocument, any, any, any, mongoose.Document<unknown, any, EventDocument, any, {}> & mongoose.Document<unknown, any, any, Record<string, any>, {}> & {
+            event_message: string;
+            event_source: string;
+            event_user?: string;
+            event_category: typeof EventCategories;
+            event_criticality: typeof EventCriticalities;
+            event_type: string;
+            event_timestamp: Date;
+            event_data?: Object;
+        } & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, EventDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<EventDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<EventDocument> & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }> & {
+            addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+        };
+        History: mongoose.Schema<HistoryDocument, mongoose.Model<HistoryDocument, any, any, any, mongoose.Document<unknown, any, HistoryDocument, any, {}> & mongoose.Document<unknown, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: typeof AlarmPriorities;
+            alarm_original_state: typeof DiamarAlarmStates;
+            alarm_state: typeof CloudAlarmStates;
+            alarm_type: typeof AlarmTypes;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, HistoryDocument, mongoose.Document<unknown, {}, mongoose.FlatRecord<HistoryDocument>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<HistoryDocument> & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }> & {
+            addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+        };
+        Unit: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+            timestamps: true;
+            collection: string;
+            toJSON: {
+                transform: (doc: UnitDocument, ret: any) => void;
+            };
+        }, {
+            createdAt: NativeDate;
+            updatedAt: NativeDate;
+        } & {
+            unit_id: string;
+            unit_enabled: boolean;
+            unit_type: "Aim18" | "Dim36" | "Diom24" | "Klim" | "Lum" | "Pmm" | "Slim" | "Tim28";
+            unit_internal_description: string;
+            unit_cabinet_id?: string | null | undefined;
+        }, UnitDocument>;
     };
-    EventCategories: {
-        readonly ACCESS_CONTROL: "AccessControl";
-        readonly REQUEST_ERROR: "RequestErrors";
-        readonly OS: "OperatingSystemEvents";
-        readonly CONTROL: "ControlSystemEvents";
-        readonly BACKUP: "BackupAndRestoreEvents";
-        readonly CONFIG_CHANGE: "ConfigurationChanges";
-        readonly LOGS: "AuditLogEvents";
-        readonly POTENTIAL_ATTACK: "PotentialAttackActivity";
+    Docs: {
+        ChannelDocs: {
+            components: {
+                schemas: {
+                    Channel: {
+                        type: string;
+                        properties: {
+                            id: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            channel_tag: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            channel_description: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            channel_unit_id: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            channel_parsed: {
+                                type: string;
+                                description: string;
+                                readOnly: boolean;
+                            };
+                        };
+                        required: string[];
+                    };
+                };
+                examples: {
+                    Channel: {
+                        value: {
+                            id: string;
+                            channel_tag: string;
+                            channel_description: string;
+                            channel_type: string;
+                        };
+                    };
+                };
+            };
+        };
+        ChannelDataBucketDocs: {
+            components: {
+                schemas: {
+                    ChannelData: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            id: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            start_date: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            end_date: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            data: {
+                                type: string;
+                                description: string;
+                                items: {
+                                    $ref: string;
+                                };
+                                readOnly: boolean;
+                            };
+                            size: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: number;
+                                readOnly: boolean;
+                            };
+                            synced: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            sum: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: number;
+                                readOnly: boolean;
+                            };
+                        };
+                    };
+                };
+                examples: {
+                    ChannelData: {
+                        id: string;
+                        start_date: string;
+                        end_date: string;
+                        data: {
+                            t: number;
+                            v: number;
+                        }[];
+                        size: number;
+                        synced: string;
+                        sum: number;
+                    };
+                };
+            };
+        };
+        ChannelWithDataDocs: {
+            components: {
+                schemas: {
+                    ChannelWithData: {
+                        allOf: ({
+                            $ref: string;
+                            type?: undefined;
+                            properties?: undefined;
+                        } | {
+                            type: string;
+                            properties: {
+                                channel_latest_value: {
+                                    type: string;
+                                    description: string;
+                                    example: string;
+                                    readOnly: boolean;
+                                };
+                                channel_latest_timestamp: {
+                                    type: string;
+                                    format: string;
+                                    description: string;
+                                    example: number;
+                                    readOnly: boolean;
+                                };
+                                channel_alarm_state: {
+                                    type: string;
+                                    description: string;
+                                    example: string;
+                                    readOnly: boolean;
+                                };
+                            };
+                            $ref?: undefined;
+                        })[];
+                        required: string[];
+                    };
+                };
+                examples: {
+                    ChannelWithData: {
+                        value: {
+                            id: string;
+                            channel_tag: string;
+                            channel_description: string;
+                            channel_type: string;
+                            channel_latest_value: number;
+                            channel_latest_timestamp: number;
+                            channel_alarm_state: string;
+                        };
+                    };
+                };
+            };
+        };
+        ChannelDataPointDocs: {
+            components: {
+                schemas: {
+                    ChannelDataPoint: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            c: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            t: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: number;
+                                readOnly: boolean;
+                            };
+                            v: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: number;
+                                readOnly: boolean;
+                            };
+                        };
+                    };
+                };
+                examples: {
+                    ChannelDataPoint: {
+                        c: string;
+                        t: number;
+                        v: number;
+                    };
+                };
+            };
+        };
+        EventDocs: {
+            components: {
+                schemas: {
+                    Event: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            id: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            event_message: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                            };
+                            event_source: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                            };
+                            event_category: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                enum: string;
+                            };
+                            event_type: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                            };
+                            event_timestamp: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: number;
+                            };
+                            event_data: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                    };
+                };
+                examples: {
+                    Event: {
+                        value: {
+                            id: string;
+                            event_message: string;
+                            event_source: string;
+                            event_category: string;
+                            event_type: string;
+                            event_timestamp: number;
+                            event_data: {
+                                profile: string;
+                                duration: number;
+                                replaced_profile: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        HistoryDocs: {
+            components: {
+                schemas: {
+                    History: {
+                        type: string;
+                        properties: {
+                            id: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            channel_tag: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            alarm_timestamp: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            alarm_priority: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                enum: string;
+                                readOnly: boolean;
+                            };
+                            alarm_original_state: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                enum: string;
+                                readOnly: boolean;
+                            };
+                            alarm_state: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                enum: string;
+                                readOnly: boolean;
+                            };
+                            alarm_type: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                enum: string;
+                                readOnly: boolean;
+                            };
+                            alarm_value: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: number;
+                                readOnly: boolean;
+                            };
+                            alarm_message: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                        };
+                        required: string[];
+                    };
+                };
+                examples: {
+                    History: {
+                        value: {
+                            id: string;
+                            channel_tag: string;
+                            alarm_timestamp: string;
+                            alarm_priority: string;
+                            alarm_original_state: string;
+                            alarm_state: string;
+                            alarm_type: string;
+                            alarm_value: number;
+                            alarm_message: string;
+                        };
+                    };
+                };
+            };
+        };
+        UnitDocs: {
+            components: {
+                schemas: {
+                    Unit: {
+                        type: string;
+                        properties: {
+                            id: {
+                                type: string;
+                                format: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            unit_id: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            unit_internal_description: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            unit_enabled: {
+                                type: string;
+                                description: string;
+                                example: boolean;
+                                readOnly: boolean;
+                            };
+                            unit_type: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                            unit_cabinet_id: {
+                                type: string;
+                                description: string;
+                                example: string;
+                                readOnly: boolean;
+                            };
+                        };
+                        required: string[];
+                    };
+                };
+                examples: {
+                    Unit: {
+                        value: {
+                            id: string;
+                            unit_id: string;
+                            unit_internal_description: string;
+                            unit_enabled: boolean;
+                            unit_type: string;
+                            unit_cabinet_id: string;
+                        };
+                    };
+                };
+            };
+        };
     };
-    EventCriticalities: {
-        readonly VERBOSE: "Verbose";
-        readonly INFO: "Info";
-        readonly WARNING: "Warning";
-        readonly ERROR: "Error";
-        readonly CRITICAL: "Critical";
+    Mimics: {
+        ImageAuxiliaryJson: ImageAuxiliaryJsonSchema;
+        LineAuxiliaryJson: LineAuxiliaryJsonSchema;
+        LinkAuxiliaryJson: LinkAuxiliaryJsonSchema;
+        PolylineAuxiliaryJson: PolylineAuxiliaryJsonSchema;
+        SquareAuxiliaryJson: SquareAuxiliaryJsonSchema;
+        TextAuxiliaryJson: TextAuxiliaryJsonSchema;
+        ChannelJson: ChannelJsonSchema;
+        CompressorJson: CompressorJsonSchema;
+        DamperJson: DamperJsonSchema;
+        DamperAutomatedJson: DamperAutomatedJsonSchema;
+        FanJson: FanJsonSchema;
+        PumpJson: PumpJsonSchema;
+        PumpAutomatedJson: PumpAutomatedJsonSchema;
+        TankJson: TankJsonSchema;
+        ValveJson: ValveJsonSchema;
+        ValveAutomatedJson: ValveAutomatedJsonSchema;
+        AlarmIndicatorJson: AlarmIndicatorJsonSchema;
+        CommandJson: CommandJsonSchema;
+        DialJson: DialJsonSchema;
+        DigitalJson: DigitalJsonSchema;
+        DisplayJson: DisplayJsonSchema;
+        DynamicTextJson: DynamicTextJsonSchema;
+        LevelBarJson: LevelBarJsonSchema;
+        SliderJson: SliderJsonSchema;
+        TextChannelJson: TextChannelJsonSchema;
+        ToggleJson: ToggleJsonSchema;
+        CabinetJson: CabinetJsonSchema;
+        RepeaterJson: RepeaterJsonSchema;
+        StationJson: StationJsonSchema;
+        UnitJson: UnitJsonSchema;
+        AddedAlarmsJson: AddedAlarmsJsonSchema;
+        BackgroundJson: BackgroundJsonSchema;
+        LineJson: LineJsonSchema;
+        LocalizedTextJson: LocalizedTextJsonSchema;
+        LocationJson: LocationJsonSchema;
+        LogicExpressionJson: LogicExpressionJsonSchema;
+        LogicExpressionsJson: LogicExpressionsJsonSchema;
+        ScaleJson: ScaleJsonSchema;
+        TextAttributesJson: TextAttributesJsonSchema;
+        TitleJson: TitleJsonSchema;
+        AutomaticSemiAutoJson: AutomaticSemiAutoJsonSchema;
+        CommandsOpClJson: CommandsOpClJsonSchema;
+        CommandsStartStopJson: CommandsStartStopJsonSchema;
+        ControlLockJson: ControlLockJsonSchema;
+        FeedbackOpClJson: FeedbackOpClJsonSchema;
+        FeedbackRunningStoppedJson: FeedbackRunningStoppedJsonSchema;
+        OrderOpClJson: OrderOpClJsonSchema;
+        OrderStartStopJson: OrderStartStopJsonSchema;
+        RemoteLocalJson: RemoteLocalJsonSchema;
+        TripResetJson: TripResetJsonSchema;
+        BreakerJson: BreakerJsonSchema;
+        BreakerPmsJson: BreakerPmsJsonSchema;
+        GeneratorJson: GeneratorJsonSchema;
+        GeneratorPmsJson: GeneratorPmsJsonSchema;
+        OperationModesJson: OperationModesJsonSchema;
+        PriorityDataJson: PriorityDataJsonSchema;
+        PrioritiesJson: PrioritiesJsonSchema;
+        ShaftJson: ShaftJsonSchema;
     };
-    UnitTypes: {
-        readonly AIM18: "Aim18";
-        readonly DIM36: "Dim36";
-        readonly DIOM24: "Diom24";
-        readonly KLIM: "Klim";
-        readonly LUM: "Lum";
-        readonly PMM: "Pmm";
-        readonly SLIM: "Slim";
-        readonly TIM28: "Tim28";
+    Types: {
+        AlarmTypes: {
+            readonly NORMAL: "Normal";
+            readonly ALARM_OPEN: "AlarmOpen";
+            readonly ALARM_CLOSE: "AlarmClose";
+            readonly ALARM_IFH: "AlarmIfh";
+            readonly ALARM_HH: "AlarmHh";
+            readonly ALARM_H: "AlarmH";
+            readonly ALARM_L: "AlarmL";
+            readonly ALARM_LL: "AlarmLl";
+            readonly ALARM_IFL: "AlarmIfl";
+            readonly ALARM_OFFSCAN: "AlarmOffScan";
+            readonly ALARM_FAIL: "AlarmFail";
+            readonly ALARM_INH: "AlarmInh";
+            readonly ALARM_UNK: "AlarmUnk";
+        };
+        AlarmPriorities: {
+            readonly CRITICAL: "Critical";
+            readonly ALARM: "Alarm";
+            readonly WARNING: "Warning";
+        };
+        CloudAlarmStates: {
+            readonly INACTIVE: "Inactive";
+            readonly ALARM: "Active";
+            readonly ALARM_ACK: "Acknowledged";
+            readonly WARNING: "WarningActive";
+            readonly WARNING_ACK: "WarningAcknowledged";
+            readonly RETURN_NO_ACK: "Unacknowledged";
+            readonly INHIBITED: "Inhibited";
+            readonly OFFSCAN: "Offscan";
+            readonly UNDEFINED: "Undefined";
+        };
+        DiamarAlarmStates: {
+            readonly INACTIVE: "Inactive";
+            readonly ACKNOWLEDGED: "Acknowledged";
+            readonly ACTIVE: "Active";
+            readonly UNACKNOWLEDGED: "Unacknowledged";
+            readonly UNDEFINED: "Undefined";
+        };
+        EventCategories: {
+            readonly ACCESS_CONTROL: "AccessControl";
+            readonly REQUEST_ERROR: "RequestErrors";
+            readonly OS: "OperatingSystemEvents";
+            readonly CONTROL: "ControlSystemEvents";
+            readonly BACKUP: "BackupAndRestoreEvents";
+            readonly CONFIG_CHANGE: "ConfigurationChanges";
+            readonly LOGS: "AuditLogEvents";
+            readonly POTENTIAL_ATTACK: "PotentialAttackActivity";
+        };
+        Mimics: {
+            MimicElementTypes: {
+                readonly IMAGE: "Image";
+                readonly LINE: "Line";
+                readonly SQUARE: "Square";
+                readonly LINK: "Link";
+                readonly POLYLINE: "Polyline";
+                readonly TEXT: "Text";
+                readonly ALARM_INDICATOR: "AlarmIndicator";
+                readonly BREAKER: "Breaker";
+                readonly COMMAND: "Command";
+                readonly COMPRESSOR: "Compressor";
+                readonly DAMPER: "Damper";
+                readonly DIAL: "Dial";
+                readonly DIGITAL: "Digital";
+                readonly DISPLAY: "Display";
+                readonly FAN: "Fan";
+                readonly GENERATOR: "Generator";
+                readonly LEVEL_BAR: "LevelBar";
+                readonly PUMP: "Pump";
+                readonly SHAFT: "Shaft";
+                readonly TEXT_CHANNEL: "TextChannel";
+                readonly DYNAMIC_TEXT: "DynamicText";
+                readonly TANK: "Tank";
+                readonly VALVE: "Valve";
+                readonly SLIDER: "Slider";
+                readonly TOGGLE: "Toggle";
+                readonly UNIT: "Unit";
+                readonly REPEATER: "Repeater";
+                readonly STATION: "Station";
+                readonly CABINET: "Cabinet";
+                readonly BREAKER_PMS: "BreakerPms";
+                readonly GENERATOR_PMS: "GeneratorPms";
+                readonly OPERATION_MODES_PMS: "OperationModesPms";
+                readonly PMS_PRIORITIES: "PmsPriorities";
+                readonly VALVE_AUTOMATED: "ValveAutomated";
+                readonly DAMPER_AUTOMATED: "DamperAutomated";
+                readonly PUMP_AUTOMATED: "PumpAutomated";
+            };
+            ZDepths: {
+                readonly BACKGROUND: "Background";
+                readonly LOW: "Low";
+                readonly NORMAL: "Normal";
+                readonly HIGH: "High";
+            };
+            TitleAligns: {
+                readonly BOTTOM: "Bottom";
+                readonly LEFT: "Left";
+                readonly RIGHT: "Right";
+                readonly TOP: "Top";
+            };
+            DigitalStates: {
+                readonly NO_VALUE: "NoValue";
+                readonly OPEN: "Open";
+                readonly CLOSE: "Close";
+                readonly UNDEFINED: "Undefined";
+            };
+            DigitalAlarmStates: {
+                readonly NO_ALARM: "NoAlarm";
+                readonly ALARM: "Alarm";
+                readonly UNDEFINED: "Undefined";
+            };
+            AlarmStates: {
+                readonly ALARM: 1;
+                readonly WARNING: 2;
+                readonly UNACKNOWLEDGED_ALARM: 3;
+                readonly UNACKNOWLEDGED_WARNING: 4;
+                readonly ACKNOWLEDGED_ALARM: 5;
+                readonly ACKNOWLEDGED_WARNING: 6;
+                readonly INHIBITED: 7;
+                readonly OFF_SCAN: 8;
+                readonly NORMAL: 9;
+                readonly OFFLINE: 10;
+            };
+            ActivationModes: {
+                readonly ALARM: "Alarm";
+                readonly LOGIC: "Logic";
+                readonly VALUE: "Value";
+            };
+            TextAnchorPoints: {
+                readonly LEFT: "Left";
+                readonly CENTER: "Center";
+                readonly RIGHT: "Right";
+            };
+            ValveDesigns: {
+                readonly MECHANIC: "Mechanic";
+                readonly NORMAL: "Normal";
+            };
+            FanDesigns: {
+                readonly NORMAL: "Normal";
+                readonly BLADED: "Bladed";
+            };
+            FanRunStates: {
+                readonly NO_VALUE: "NoValue";
+                readonly UNDEFINED: "Undefined";
+                readonly STOPPED: "Stopped";
+                readonly RUNNING: "Running";
+                readonly RUNNING_FAST: "RunningFast";
+            };
+            FanDirections: {
+                readonly NO_VALUE: "NoValue";
+                readonly UNDEFINED: "Undefined";
+                readonly SUPPLY: "Supply";
+                readonly EXHAUST: "Exhaust";
+            };
+            FanTypes: {
+                readonly SIMPLE: "Simple";
+                readonly SIMPLE_WITH_FAST: "SimpleWithFast";
+                readonly REVERSIBLE: "Reversible";
+                readonly REVERSIBLE_WITH_FAST: "ReversibleWithFast";
+            };
+            LevelBarOrientations: {
+                readonly VERTICAL: "Vertical";
+                readonly HORIZONTAL: "Horizontal";
+            };
+            SliderOrientations: {
+                readonly VERTICAL: "Vertical";
+                readonly HORIZONTAL: "Horizontal";
+            };
+            CompressorDesigns: {
+                readonly CENTRIFUGAL: "Centrifugal";
+                readonly MECHANIC: "Mechanic";
+                readonly NORMAL: "Normal";
+                readonly PISTONS: "Pistons";
+                readonly ROTATORY_SCREW: "RotatoryScrew";
+                readonly SCROLL: "Scroll";
+                readonly VANES: "Vanes";
+            };
+            LedTypes: {
+                readonly CIRCLE: "Circle";
+                readonly SQUARE: "Square";
+            };
+            InfoLocations: {
+                readonly BOTTOM: "Bottom";
+                readonly LEFT: "Left";
+                readonly RIGHT: "Right";
+                readonly TOP: "Top";
+            };
+            MarkTypes: {
+                readonly LARGE_LINE: "LargeLine";
+                readonly SHORT_LINE: "ShortLine";
+                readonly TRIANGLE: "Triangle";
+            };
+            ScalePositions: {
+                readonly LEFT: "Left";
+                readonly RIGHT: "Right";
+            };
+            ValueTypes: {
+                readonly PERCENTAGE: "Percentage";
+                readonly RAW: "Raw";
+            };
+            OperationModeStates: {
+                readonly ACTIVE: 0;
+                readonly INACTIVE: 1;
+                readonly IN_TRANSITION: 2;
+                readonly FAILED: 3;
+            };
+            UnitDesigns: {
+                readonly IMAGE: "Image";
+                readonly MODERN: "Modern";
+            };
+            StationDesigns: {
+                readonly IMAGE: "Image";
+                readonly MONITOR: "Monitor";
+                readonly SCREEN: "Screen";
+            };
+            RepeaterDesigns: {
+                readonly IMAGE: "Image";
+                readonly SLIM: "SLim";
+                readonly DIAMAR_REPEATER: "DiamarRepeater";
+            };
+            CabinetDesigns: {
+                readonly IMAGE: "Image";
+                readonly MODERN: "Modern";
+            };
+            LinkDesigns: {
+                readonly BUTTON: "Button";
+                readonly IMAGE: "Image";
+            };
+            OpClStates: {
+                readonly NO_VALUE: "NoValue";
+                readonly OPEN: "Open";
+                readonly CLOSE: "Close";
+                readonly UNDEFINED: "Undefined";
+            };
+            RunningStoppedStates: {
+                readonly NO_VALUE: "NoValue";
+                readonly RUNNING: "Running";
+                readonly STOPPED: "Stopped";
+                readonly UNDEFINED: "Undefined";
+            };
+        };
     };
+    mongoose: typeof mongoose;
+    mongoosePaginate: typeof mongoosePaginate;
+    mongooseAggregatePaginate: typeof mongooseAggregatePaginate;
+    mongooseAutopopulate: typeof mongooseAutopopulate;
 };
 
-export { type AlarmPriority, type AlarmType, type ChannelBaseType, type ChannelSpecificType, type CloudAlarmState, type DiamarAlarmState, type EventCategory, type EventCriticality, Types, type UnitType };
+export { _default as default };