@sedni/cloud_common 2.1.0 → 3.0.1

package/dist/index.d.cts

@@ -1,105 +1,1406 @@
-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";
-};
-type AlarmType = (typeof AlarmTypes)[keyof typeof AlarmTypes];
+import { c2 as UnitTypes, bp as AlarmPriority, by as DiamarAlarmState, bw as CloudAlarmState, br as AlarmType, c3 as AlarmPriorities, c4 as DiamarAlarmStates, c5 as CloudAlarmStates, c6 as AlarmTypes, c7 as EventCategories, c8 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, a4 as ImageAuxiliaryRequestSchema, a5 as LineAuxiliaryRequestSchema, a6 as LinkAuxiliaryRequestSchema, a7 as PolylineAuxiliaryRequestSchema, a8 as SquareAuxiliaryRequestSchema, a9 as TextAuxiliaryRequestSchema, aa as ChannelRequestSchema, ab as CompressorRequestSchema, ac as DamperRequestSchema, ad as DamperAutomatedRequestSchema, ae as FanRequestSchema, af as PumpRequestSchema, ag as PumpAutomatedRequestSchema, ah as TankRequestSchema, ai as ValveRequestSchema, aj as ValveAutomatedRequestSchema, ak as AlarmIndicatorRequestSchema, al as CommandRequestSchema, am as DialRequestSchema, an as DigitalRequestSchema, ao as DisplayRequestSchema, ap as DynamicTextRequestSchema, aq as LevelBarRequestSchema, ar as SliderRequestSchema, as as TextChannelRequestSchema, at as ToggleRequestSchema, au as CabinetRequestSchema, av as RepeaterRequestSchema, aw as StationRequestSchema, ax as UnitRequestSchema, ay as AutomaticSemiAutoRequestSchema, az as CommandsOpClRequestSchema, aA as CommandsStartStopRequestSchema, aB as ControlLockRequestSchema, aC as FeedbackOpClRequestSchema, aD as FeedbackRunningStoppedRequestSchema, aE as OrderOpClRequestSchema, aF as OrderStartStopRequestSchema, aG as RemoteLocalRequestSchema, aH as TripResetRequestSchema, aI as BreakerRequestSchema, aJ as BreakerPmsRequestSchema, aK as GeneratorRequestSchema, aL as GeneratorPmsRequestSchema, aM as OperationModesRequestSchema, aN as PriorityDataRequestSchema, aO as PrioritiesRequestSchema, aP as ShaftRequestSchema, aQ as ImageAuxiliaryResponseSchema, aR as LineAuxiliaryResponseSchema, aS as LinkAuxiliaryResponseSchema, aT as PolylineAuxiliaryResponseSchema, aU as SquareAuxiliaryResponseSchema, aV as TextAuxiliaryResponseSchema, aW as CompressorResponseSchema, aX as DamperResponseSchema, aY as DamperAutomatedResponseSchema, aZ as FanResponseSchema, a_ as PumpResponseSchema, a$ as PumpAutomatedResponseSchema, b0 as TankResponseSchema, b1 as ValveResponseSchema, b2 as ValveAutomatedResponseSchema, b3 as AlarmIndicatorResponseSchema, b4 as CommandResponseSchema, b5 as DialResponseSchema, b6 as DigitalResponseSchema, b7 as DisplayResponseSchema, b8 as DynamicTextResponseSchema, b9 as LevelBarResponseSchema, ba as SliderResponseSchema, bb as TextChannelResponseSchema, bc as ToggleResponseSchema, bd as CabinetResponseSchema, be as RepeaterResponseSchema, bf as StationResponseSchema, bg as UnitResponseSchema, bh as BreakerResponseSchema, bi as BreakerPmsResponseSchema, bj as GeneratorResponseSchema, bk as GeneratorPmsResponseSchema, bl as OperationModesResponseSchema, bm as PrioritiesResponseSchema, bn as ShaftResponseSchema } from './unit.types-BZWIS1vq.cjs';
+export { bo as ActivationMode, bq as AlarmState, bs as AutoSemiAutoState, bt as CabinetDesign, bu as ChannelBaseType, bv as ChannelSpecificType, bx as CompressorDesign, bz as DigitalAlarmState, bA as DigitalState, bB as EventCategory, bC as EventCriticality, bD as FanDesign, bE as FanDirection, bF as FanRunState, bG as FanType, c9 as InfoLocation, bH as LedType, bI as LevelBarOrientation, bJ as LineRequestSchema, bK as LinkDesign, bL as MarkType, bM as MimicAlarmState, bN as MimicControlState, bO as MimicElementType, bP as OpClState, bQ as OperationModeState, bR as RemoteLocalState, bS as RepeaterDesign, bT as RunningStoppedState, bU as ScalePosition, bV as SliderOrientation, bW as StationDesign, bX as TextAnchorPoint, bY as TitleAlign, bZ as UnitDesign, b_ as UnitType, b$ as ValueType, c0 as ValveDesign, c1 as ZDepth } from './unit.types-BZWIS1vq.cjs';
+import mongoose from 'mongoose';
+import mongooseAggregatePaginate from 'mongoose-aggregate-paginate-v2';
+import mongooseAutopopulate from 'mongoose-autopopulate';
+import mongoosePaginate from 'mongoose-paginate-v2';
 
-declare const ChannelBaseTypes: {
-    readonly VIRTUAL_ANALOG: "VirtualAnalog";
-    readonly VIRTUAL_DIGITAL: "VirtualDigital";
-    readonly VIRTUAL_STRING: "VirtualString";
-    readonly WIRED_ANALOG: "WiredAnalog";
-    readonly WIRED_DIGITAL: "WiredDigital";
-};
-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 ChannelSpecificType = (typeof ChannelSpecificTypes)[keyof typeof ChannelSpecificTypes];
+type UnitDocument = mongoose.Document & {
+    unit_id: string;
+    unit_enabled: boolean;
+    unit_type: typeof UnitTypes;
+    unit_internal_description: string;
+    unit_cabinet_id?: string;
+};
+type UnitModel = mongoose.PaginateModel<UnitDocument> & mongoose.AggregatePaginateModel<UnitDocument>;
+type UnitJSON = {
+    id: string;
+    unit_id: string;
+    unit_enabled: boolean;
+    unit_type: typeof UnitTypes;
+    unit_internal_description: string;
+    unit_cabinet_id?: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+
+type HistoryDocument = mongoose.Document & {
+    channel_tag: string;
+    alarm_timestamp: Date;
+    alarm_priority: AlarmPriority;
+    alarm_original_state: DiamarAlarmState;
+    alarm_state: CloudAlarmState;
+    alarm_type: AlarmType;
+    alarm_value?: number;
+    alarm_message?: string;
+    alarm_data?: Object;
+};
+type HistoryModel = mongoose.PaginateModel<HistoryDocument> & mongoose.AggregatePaginateModel<HistoryDocument>;
+type HistoryJSON = {
+    id: string;
+    channel_tag: string;
+    alarm_timestamp: number;
+    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 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 EventModel = mongoose.PaginateModel<EventDocument> & mongoose.AggregatePaginateModel<EventDocument>;
+type EventJSON = {
+    id: string;
+    event_message: string;
+    event_source: string;
+    event_user?: string;
+    event_category: typeof EventCategories;
+    event_criticality: typeof EventCriticalities;
+    event_type: string;
+    event_timestamp: number;
+    event_data?: Object;
+};
+
+type ChannelDataPointDocument = mongoose.Document & {
+    c: string;
+    t: Date;
+    v: number;
+};
+type ChannelDataPointModel = mongoose.PaginateModel<ChannelDataPointDocument> & mongoose.AggregatePaginateModel<ChannelDataPointDocument>;
+type ChannelDataPointJSON = {
+    id: string;
+    channel_id: string;
+    timestamp: number;
+    value: number;
+};
+
+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 ChannelDataBucketModel = mongoose.PaginateModel<ChannelDataBucketDocument> & mongoose.AggregatePaginateModel<ChannelDataBucketDocument>;
+type ChannelDataBucketJSON = {
+    id: string;
+    start_date: number;
+    end_date: number;
+    data: {
+        channel_id: string;
+        timestamp: number;
+        value: number;
+    }[];
+    size: number;
+    synced: number;
+    sum: number;
+    avg: number;
+};
+
+type ChannelDocument = mongoose.Document & {
+    channel_tag: string;
+    channel_description: string;
+    channel_unit_id: mongoose.Types.ObjectId;
+    channel_parsed: Object;
+};
+type ChannelModel = mongoose.PaginateModel<ChannelDocument> & mongoose.AggregatePaginateModel<ChannelDocument>;
+type ChannelJSON = {
+    id: string;
+    channel_tag: string;
+    channel_description: string;
+    channel_unit_id: string;
+    channel_unit: any;
+    channel_parsed: Object;
+    createdAt: Date;
+    updatedAt: Date;
+};
+
+declare const 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;
+                    };
+                };
+            };
+        };
+    };
+};
 
-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 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 EventCriticality = (typeof EventCriticalities)[keyof typeof EventCriticalities];
+declare const Schemas: {
+    Channel: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+        timestamps: {
+            createdAt: true;
+            updatedAt: true;
+        };
+        collection: string;
+        toJSON: {
+            transform: (_doc: ChannelDocument, ret: any) => void;
+        };
+    }, {
+        channel_tag: string;
+        channel_description: string;
+        channel_unit_id: mongoose.Types.ObjectId;
+        channel_parsed: any;
+        channel_last_bucket_sync?: NativeDate | null | undefined;
+        createdAt: NativeDate;
+        updatedAt: NativeDate;
+    }, ChannelDocument, {
+        [path: string]: mongoose.SchemaDefinitionProperty<undefined, any, any>;
+    } | {
+        [x: string]: mongoose.SchemaDefinitionProperty<any, any, ChannelDocument> | undefined;
+    }, {
+        channel_tag: string;
+        channel_description: string;
+        channel_unit_id: mongoose.Types.ObjectId;
+        channel_parsed: any;
+        channel_last_bucket_sync?: NativeDate | null | undefined;
+        createdAt: NativeDate;
+        updatedAt: NativeDate;
+    } & {
+        _id: mongoose.Types.ObjectId;
+    } & {
+        __v: number;
+    }>;
+    ChannelDataBucket: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+        toJSON: {
+            transform: (doc: ChannelDataBucketDocument, ret: any) => void;
+        };
+        versionKey: false;
+    }, {
+        data: mongoose.Types.DocumentArray<{
+            value: number;
+            channel_id: string;
+            timestamp: number;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            value: number;
+            channel_id: string;
+            timestamp: number;
+        }, {}, {}> & {
+            value: number;
+            channel_id: string;
+            timestamp: number;
+        }>;
+        size: number;
+        start_date: NativeDate;
+        end_date: NativeDate;
+        synced: number;
+        sum: number;
+    }, ChannelDataBucketDocument, {
+        [path: string]: mongoose.SchemaDefinitionProperty<undefined, any, any>;
+    } | {
+        [x: string]: mongoose.SchemaDefinitionProperty<any, any, ChannelDataBucketDocument> | undefined;
+    }, {
+        data: mongoose.Types.DocumentArray<{
+            value: number;
+            channel_id: string;
+            timestamp: number;
+        }, mongoose.Types.Subdocument<mongoose.mongo.BSON.ObjectId, unknown, {
+            value: number;
+            channel_id: string;
+            timestamp: number;
+        }, {}, {}> & {
+            value: number;
+            channel_id: string;
+            timestamp: number;
+        }>;
+        size: number;
+        start_date: NativeDate;
+        end_date: NativeDate;
+        synced: number;
+        sum: number;
+    } & {
+        _id: mongoose.Types.ObjectId;
+    } & {
+        __v: number;
+    }>;
+    ChannelDataPoint: mongoose.Schema<ChannelDataPointDocument, mongoose.Model<ChannelDataPointDocument, any, any, any, (mongoose.Document<unknown, any, ChannelDataPointDocument, any, mongoose.DefaultSchemaOptions> & mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+        c: string;
+        t: Date;
+        v: number;
+    } & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    } & {
+        id: string;
+    }) | (mongoose.Document<unknown, any, ChannelDataPointDocument, any, mongoose.DefaultSchemaOptions> & mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+        c: string;
+        t: Date;
+        v: number;
+    } & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }), any, ChannelDataPointDocument>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ChannelDataPointDocument, mongoose.Document<unknown, {}, ChannelDataPointDocument, {
+        id: string;
+    }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+        c: string;
+        t: Date;
+        v: number;
+    } & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }, {
+        _id?: mongoose.SchemaDefinitionProperty<mongoose.Types.ObjectId, ChannelDataPointDocument, mongoose.Document<unknown, {}, ChannelDataPointDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            c: string;
+            t: Date;
+            v: number;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        c?: mongoose.SchemaDefinitionProperty<string, ChannelDataPointDocument, mongoose.Document<unknown, {}, ChannelDataPointDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            c: string;
+            t: Date;
+            v: number;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        t?: mongoose.SchemaDefinitionProperty<Date, ChannelDataPointDocument, mongoose.Document<unknown, {}, ChannelDataPointDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            c: string;
+            t: Date;
+            v: number;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        v?: mongoose.SchemaDefinitionProperty<number, ChannelDataPointDocument, mongoose.Document<unknown, {}, ChannelDataPointDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            c: string;
+            t: Date;
+            v: number;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+    }, ChannelDataPointDocument> & {
+        addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+    };
+    Event: mongoose.Schema<EventDocument, mongoose.Model<EventDocument, any, any, any, (mongoose.Document<unknown, any, EventDocument, any, mongoose.DefaultSchemaOptions> & mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    } & {
+        id: string;
+    }) | (mongoose.Document<unknown, any, EventDocument, any, mongoose.DefaultSchemaOptions> & mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }), any, EventDocument>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+        id: string;
+    }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }, {
+        _id?: mongoose.SchemaDefinitionProperty<mongoose.Types.ObjectId, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_message?: mongoose.SchemaDefinitionProperty<string, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_source?: mongoose.SchemaDefinitionProperty<string, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_user?: mongoose.SchemaDefinitionProperty<string | undefined, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_category?: mongoose.SchemaDefinitionProperty<{
+            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";
+        }, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_criticality?: mongoose.SchemaDefinitionProperty<{
+            readonly VERBOSE: "Verbose";
+            readonly INFO: "Info";
+            readonly WARNING: "Warning";
+            readonly ERROR: "Error";
+            readonly CRITICAL: "Critical";
+        }, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_type?: mongoose.SchemaDefinitionProperty<string, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_timestamp?: mongoose.SchemaDefinitionProperty<Date, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        event_data?: mongoose.SchemaDefinitionProperty<Object | undefined, EventDocument, mongoose.Document<unknown, {}, EventDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, 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: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+    }, EventDocument> & {
+        addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+    };
+    History: mongoose.Schema<HistoryDocument, mongoose.Model<HistoryDocument, any, any, any, (mongoose.Document<unknown, any, HistoryDocument, any, mongoose.DefaultSchemaOptions> & mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+        channel_tag: string;
+        alarm_timestamp: Date;
+        alarm_priority: AlarmPriority;
+        alarm_original_state: DiamarAlarmState;
+        alarm_state: CloudAlarmState;
+        alarm_type: AlarmType;
+        alarm_value?: number;
+        alarm_message?: string;
+        alarm_data?: Object;
+    } & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    } & {
+        id: string;
+    }) | (mongoose.Document<unknown, any, HistoryDocument, any, mongoose.DefaultSchemaOptions> & mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+        channel_tag: string;
+        alarm_timestamp: Date;
+        alarm_priority: AlarmPriority;
+        alarm_original_state: DiamarAlarmState;
+        alarm_state: CloudAlarmState;
+        alarm_type: AlarmType;
+        alarm_value?: number;
+        alarm_message?: string;
+        alarm_data?: Object;
+    } & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }), any, HistoryDocument>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+        id: string;
+    }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+        channel_tag: string;
+        alarm_timestamp: Date;
+        alarm_priority: AlarmPriority;
+        alarm_original_state: DiamarAlarmState;
+        alarm_state: CloudAlarmState;
+        alarm_type: AlarmType;
+        alarm_value?: number;
+        alarm_message?: string;
+        alarm_data?: Object;
+    } & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }, {
+        _id?: mongoose.SchemaDefinitionProperty<mongoose.Types.ObjectId, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        channel_tag?: mongoose.SchemaDefinitionProperty<string, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_timestamp?: mongoose.SchemaDefinitionProperty<Date, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_priority?: mongoose.SchemaDefinitionProperty<AlarmPriority, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_original_state?: mongoose.SchemaDefinitionProperty<DiamarAlarmState, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_state?: mongoose.SchemaDefinitionProperty<CloudAlarmState, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_type?: mongoose.SchemaDefinitionProperty<AlarmType, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_value?: mongoose.SchemaDefinitionProperty<number | undefined, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_message?: mongoose.SchemaDefinitionProperty<string | undefined, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+        alarm_data?: mongoose.SchemaDefinitionProperty<Object | undefined, HistoryDocument, mongoose.Document<unknown, {}, HistoryDocument, {
+            id: string;
+        }, mongoose.DefaultSchemaOptions> & Omit<mongoose.Document<mongoose.Types.ObjectId, any, any, Record<string, any>, {}> & {
+            channel_tag: string;
+            alarm_timestamp: Date;
+            alarm_priority: AlarmPriority;
+            alarm_original_state: DiamarAlarmState;
+            alarm_state: CloudAlarmState;
+            alarm_type: AlarmType;
+            alarm_value?: number;
+            alarm_message?: string;
+            alarm_data?: Object;
+        } & Required<{
+            _id: mongoose.Types.ObjectId;
+        }> & {
+            __v: number;
+        }, "id"> & {
+            id: string;
+        }> | undefined;
+    }, HistoryDocument> & {
+        addTTLIndex?: (expirationTimeInSeconds?: number, ttlField?: string) => void;
+    };
+    Unit: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
+        timestamps: true;
+        collection: string;
+        toJSON: {
+            transform: (doc: UnitDocument, ret: any) => void;
+        };
+    }, {
+        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;
+    } & mongoose.DefaultTimestampProps, UnitDocument, {
+        [path: string]: mongoose.SchemaDefinitionProperty<undefined, any, any>;
+    } | {
+        [x: string]: mongoose.SchemaDefinitionProperty<any, any, UnitDocument> | undefined;
+    }, {
+        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;
+        createdAt: NativeDate;
+        updatedAt: NativeDate;
+    } & {
+        _id: mongoose.Types.ObjectId;
+    } & {
+        __v: number;
+    }>;
+};
 
-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 UnitType = (typeof UnitTypes)[keyof typeof UnitTypes];
+declare const 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;
+};
+
+declare const MimicsRequest: {
+    ImageAuxiliaryRequest: ImageAuxiliaryRequestSchema;
+    LineAuxiliaryRequest: LineAuxiliaryRequestSchema;
+    LinkAuxiliaryRequest: LinkAuxiliaryRequestSchema;
+    PolylineAuxiliaryRequest: PolylineAuxiliaryRequestSchema;
+    SquareAuxiliaryRequest: SquareAuxiliaryRequestSchema;
+    TextAuxiliaryRequest: TextAuxiliaryRequestSchema;
+    ChannelRequest: ChannelRequestSchema;
+    CompressorRequest: CompressorRequestSchema;
+    DamperRequest: DamperRequestSchema;
+    DamperAutomatedRequest: DamperAutomatedRequestSchema;
+    FanRequest: FanRequestSchema;
+    PumpRequest: PumpRequestSchema;
+    PumpAutomatedRequest: PumpAutomatedRequestSchema;
+    TankRequest: TankRequestSchema;
+    ValveRequest: ValveRequestSchema;
+    ValveAutomatedRequest: ValveAutomatedRequestSchema;
+    AlarmIndicatorRequest: AlarmIndicatorRequestSchema;
+    CommandRequest: CommandRequestSchema;
+    DialRequest: DialRequestSchema;
+    DigitalRequest: DigitalRequestSchema;
+    DisplayRequest: DisplayRequestSchema;
+    DynamicTextRequest: DynamicTextRequestSchema;
+    LevelBarRequest: LevelBarRequestSchema;
+    SliderRequest: SliderRequestSchema;
+    TextChannelRequest: TextChannelRequestSchema;
+    ToggleRequest: ToggleRequestSchema;
+    CabinetRequest: CabinetRequestSchema;
+    RepeaterRequest: RepeaterRequestSchema;
+    StationRequest: StationRequestSchema;
+    UnitRequest: UnitRequestSchema;
+    AutomaticSemiAutoRequest: AutomaticSemiAutoRequestSchema;
+    CommandsOpClRequest: CommandsOpClRequestSchema;
+    CommandsStartStopRequest: CommandsStartStopRequestSchema;
+    ControlLockRequest: ControlLockRequestSchema;
+    FeedbackOpClRequest: FeedbackOpClRequestSchema;
+    FeedbackRunningStoppedRequest: FeedbackRunningStoppedRequestSchema;
+    OrderOpClRequest: OrderOpClRequestSchema;
+    OrderStartStopRequest: OrderStartStopRequestSchema;
+    RemoteLocalRequest: RemoteLocalRequestSchema;
+    TripResetRequest: TripResetRequestSchema;
+    BreakerRequest: BreakerRequestSchema;
+    BreakerPmsRequest: BreakerPmsRequestSchema;
+    GeneratorRequest: GeneratorRequestSchema;
+    GeneratorPmsRequest: GeneratorPmsRequestSchema;
+    OperationModesRequest: OperationModesRequestSchema;
+    PriorityDataRequest: PriorityDataRequestSchema;
+    PrioritiesRequest: PrioritiesRequestSchema;
+    ShaftRequest: ShaftRequestSchema;
+};
+
+declare const MimicsResponse: {
+    ImageAuxiliaryResponse: ImageAuxiliaryResponseSchema;
+    LineAuxiliaryResponse: LineAuxiliaryResponseSchema;
+    LinkAuxiliaryResponse: LinkAuxiliaryResponseSchema;
+    PolylineAuxiliaryResponse: PolylineAuxiliaryResponseSchema;
+    SquareAuxiliaryResponse: SquareAuxiliaryResponseSchema;
+    TextAuxiliaryResponse: TextAuxiliaryResponseSchema;
+    CompressorResponse: CompressorResponseSchema;
+    DamperResponse: DamperResponseSchema;
+    DamperAutomatedResponse: DamperAutomatedResponseSchema;
+    FanResponse: FanResponseSchema;
+    PumpResponse: PumpResponseSchema;
+    PumpAutomatedResponse: PumpAutomatedResponseSchema;
+    TankResponse: TankResponseSchema;
+    ValveResponse: ValveResponseSchema;
+    ValveAutomatedResponse: ValveAutomatedResponseSchema;
+    AlarmIndicatorResponse: AlarmIndicatorResponseSchema;
+    CommandResponse: CommandResponseSchema;
+    DialResponse: DialResponseSchema;
+    DigitalResponse: DigitalResponseSchema;
+    DisplayResponse: DisplayResponseSchema;
+    DynamicTextResponse: DynamicTextResponseSchema;
+    LevelBarResponse: LevelBarResponseSchema;
+    SliderResponse: SliderResponseSchema;
+    TextChannelResponse: TextChannelResponseSchema;
+    ToggleResponse: ToggleResponseSchema;
+    CabinetResponse: CabinetResponseSchema;
+    RepeaterResponse: RepeaterResponseSchema;
+    StationResponse: StationResponseSchema;
+    UnitResponse: UnitResponseSchema;
+    BreakerResponse: BreakerResponseSchema;
+    BreakerPmsResponse: BreakerPmsResponseSchema;
+    GeneratorResponse: GeneratorResponseSchema;
+    GeneratorPmsResponse: GeneratorPmsResponseSchema;
+    OperationModesResponse: OperationModesResponseSchema;
+    PrioritiesResponse: PrioritiesResponseSchema;
+    ShaftResponse: ShaftResponseSchema;
+};
 
 declare const Types: {
     AlarmTypes: {
@@ -192,6 +1493,236 @@ declare const Types: {
         readonly SLIM: "Slim";
         readonly TIM28: "Tim28";
     };
+    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;
+        };
+        MimicAlarmStates: {
+            ALARM: string;
+            WARNING: string;
+            UNACKNOWLEDGED_ALARM: string;
+            UNACKNOWLEDGED_WARNING: string;
+            ACKNOWLEDGED_ALARM: string;
+            ACKNOWLEDGED_WARNING: string;
+            INHIBITED: string;
+            OFF_SCAN: string;
+            NORMAL: string;
+            OFFLINE: string;
+        };
+        MimicControlStates: {
+            NO_VALUE: string;
+            LOCAL: string;
+            AUTOMATIC: string;
+            SEMI_AUTOMATIC: string;
+            UNDEFINED: string;
+        };
+        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";
+        };
+        AutoSemiAutoStates: {
+            readonly NO_VALUE: "NoValue";
+            readonly AUTOMATIC: "Automatic";
+            readonly SEMI_AUTOMATIC: "SemiAuto";
+            readonly UNDEFINED: "Undefined";
+        };
+        RemoteLocalStates: {
+            readonly NO_VALUE: "NoValue";
+            readonly REMOTE: "Remote";
+            readonly LOCAL: "Local";
+            readonly UNDEFINED: "Undefined";
+        };
+    };
+};
+
+declare const _default: {
+    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 { AddedAlarmsJsonSchema, AlarmIndicatorJsonSchema, AlarmIndicatorRequestSchema, AlarmIndicatorResponseSchema, AlarmPriority, AlarmType, AutomaticSemiAutoJsonSchema, AutomaticSemiAutoRequestSchema, BackgroundJsonSchema, BreakerJsonSchema, BreakerPmsJsonSchema, BreakerPmsRequestSchema, BreakerPmsResponseSchema, BreakerRequestSchema, BreakerResponseSchema, CabinetJsonSchema, CabinetRequestSchema, CabinetResponseSchema, type ChannelDataBucketDocument, type ChannelDataBucketJSON, type ChannelDataBucketModel, type ChannelDataPointDocument, type ChannelDataPointJSON, type ChannelDataPointModel, type ChannelDocument, type ChannelJSON, ChannelJsonSchema, type ChannelModel, CloudAlarmState, CommandJsonSchema, CommandRequestSchema, CommandResponseSchema, CommandsOpClJsonSchema, CommandsOpClRequestSchema, CommandsStartStopJsonSchema, CommandsStartStopRequestSchema, CompressorJsonSchema, CompressorRequestSchema, CompressorResponseSchema, ControlLockJsonSchema, ControlLockRequestSchema, DamperAutomatedJsonSchema, DamperAutomatedRequestSchema, DamperAutomatedResponseSchema, DamperJsonSchema, DamperRequestSchema, DamperResponseSchema, DialJsonSchema, DialRequestSchema, DialResponseSchema, DiamarAlarmState, DigitalJsonSchema, DigitalRequestSchema, DigitalResponseSchema, DisplayJsonSchema, DisplayRequestSchema, DisplayResponseSchema, Docs, DynamicTextJsonSchema, DynamicTextRequestSchema, DynamicTextResponseSchema, type EventDocument, type EventJSON, type EventModel, FanJsonSchema, FanRequestSchema, FanResponseSchema, FeedbackOpClJsonSchema, FeedbackOpClRequestSchema, FeedbackRunningStoppedJsonSchema, FeedbackRunningStoppedRequestSchema, GeneratorJsonSchema, GeneratorPmsJsonSchema, GeneratorPmsRequestSchema, GeneratorPmsResponseSchema, GeneratorRequestSchema, GeneratorResponseSchema, type HistoryDocument, type HistoryJSON, type HistoryModel, ImageAuxiliaryJsonSchema, ImageAuxiliaryRequestSchema, ImageAuxiliaryResponseSchema, LevelBarJsonSchema, LevelBarRequestSchema, LevelBarResponseSchema, LineAuxiliaryJsonSchema, LineAuxiliaryRequestSchema, LineAuxiliaryResponseSchema, LineJsonSchema, LinkAuxiliaryJsonSchema, LinkAuxiliaryRequestSchema, LinkAuxiliaryResponseSchema, LocalizedTextJsonSchema, LocationJsonSchema, LogicExpressionJsonSchema, LogicExpressionsJsonSchema, Mimics, MimicsRequest, MimicsResponse, OperationModesJsonSchema, OperationModesRequestSchema, OperationModesResponseSchema, OrderOpClJsonSchema, OrderOpClRequestSchema, OrderStartStopJsonSchema, OrderStartStopRequestSchema, PolylineAuxiliaryJsonSchema, PolylineAuxiliaryRequestSchema, PolylineAuxiliaryResponseSchema, PrioritiesJsonSchema, PrioritiesRequestSchema, PrioritiesResponseSchema, PriorityDataJsonSchema, PriorityDataRequestSchema, PumpAutomatedJsonSchema, PumpAutomatedRequestSchema, PumpAutomatedResponseSchema, PumpJsonSchema, PumpRequestSchema, PumpResponseSchema, RemoteLocalJsonSchema, RemoteLocalRequestSchema, RepeaterJsonSchema, RepeaterRequestSchema, RepeaterResponseSchema, ScaleJsonSchema, Schemas, ShaftJsonSchema, ShaftRequestSchema, ShaftResponseSchema, SliderJsonSchema, SliderRequestSchema, SliderResponseSchema, SquareAuxiliaryJsonSchema, SquareAuxiliaryRequestSchema, SquareAuxiliaryResponseSchema, StationJsonSchema, StationRequestSchema, StationResponseSchema, TankJsonSchema, TankRequestSchema, TankResponseSchema, TextAttributesJsonSchema, TextAuxiliaryJsonSchema, TextAuxiliaryRequestSchema, TextAuxiliaryResponseSchema, TextChannelJsonSchema, TextChannelRequestSchema, TextChannelResponseSchema, TitleJsonSchema, ToggleJsonSchema, ToggleRequestSchema, ToggleResponseSchema, TripResetJsonSchema, TripResetRequestSchema, Types, type UnitDocument, type UnitJSON, UnitJsonSchema, type UnitModel, UnitRequestSchema, UnitResponseSchema, ValveAutomatedJsonSchema, ValveAutomatedRequestSchema, ValveAutomatedResponseSchema, ValveJsonSchema, ValveRequestSchema, ValveResponseSchema, _default as default };