/* Options:
Date: 2025-09-14 06:31:45
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.trackunit.com/public

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: CreateAlarm.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

// @DataContract
class TemperatureAlarmLimits implements IConvertible
{
    // @DataMember
    double? temperature1LowerLimit;

    // @DataMember
    double? temperature1UpperLimit;

    // @DataMember
    double? temperature2LowerLimit;

    // @DataMember
    double? temperature2UpperLimit;

    TemperatureAlarmLimits({this.temperature1LowerLimit,this.temperature1UpperLimit,this.temperature2LowerLimit,this.temperature2UpperLimit});
    TemperatureAlarmLimits.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        temperature1LowerLimit = JsonConverters.toDouble(json['temperature1LowerLimit']);
        temperature1UpperLimit = JsonConverters.toDouble(json['temperature1UpperLimit']);
        temperature2LowerLimit = JsonConverters.toDouble(json['temperature2LowerLimit']);
        temperature2UpperLimit = JsonConverters.toDouble(json['temperature2UpperLimit']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'temperature1LowerLimit': temperature1LowerLimit,
        'temperature1UpperLimit': temperature1UpperLimit,
        'temperature2LowerLimit': temperature2LowerLimit,
        'temperature2UpperLimit': temperature2UpperLimit
    };

    getTypeName() => "TemperatureAlarmLimits";
    TypeContext? context = _ctx;
}

// @DataContract
class ADVoltageAlarmLimits implements IConvertible
{
    // @DataMember
    double? adVoltageLowerLimit;

    // @DataMember
    double? adVoltageUpperLimit;

    ADVoltageAlarmLimits({this.adVoltageLowerLimit,this.adVoltageUpperLimit});
    ADVoltageAlarmLimits.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        adVoltageLowerLimit = JsonConverters.toDouble(json['adVoltageLowerLimit']);
        adVoltageUpperLimit = JsonConverters.toDouble(json['adVoltageUpperLimit']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'adVoltageLowerLimit': adVoltageLowerLimit,
        'adVoltageUpperLimit': adVoltageUpperLimit
    };

    getTypeName() => "ADVoltageAlarmLimits";
    TypeContext? context = _ctx;
}

// @DataContract
class Location implements IConvertible
{
    // @DataMember
    double? latitude;

    // @DataMember
    double? longitude;

    Location({this.latitude,this.longitude});
    Location.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        latitude = JsonConverters.toDouble(json['latitude']);
        longitude = JsonConverters.toDouble(json['longitude']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'latitude': latitude,
        'longitude': longitude
    };

    getTypeName() => "Location";
    TypeContext? context = _ctx;
}

// @DataContract
class TimeOfDay implements IConvertible
{
    // @DataMember
    int? hour;

    // @DataMember
    int? minute;

    TimeOfDay({this.hour,this.minute});
    TimeOfDay.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        hour = json['hour'];
        minute = json['minute'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'hour': hour,
        'minute': minute
    };

    getTypeName() => "TimeOfDay";
    TypeContext? context = _ctx;
}

// @DataContract
class CreateAlarmResponse implements IConvertible
{
    // @DataMember
    String? id;

    // @DataMember
    ResponseStatus? responseStatus;

    CreateAlarmResponse({this.id,this.responseStatus});
    CreateAlarmResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
    };

    getTypeName() => "CreateAlarmResponse";
    TypeContext? context = _ctx;
}

// @Route("/CreateAlarm", "GET POST")
// @Route("/Alarm", "POST")
// @DataContract
class CreateAlarm implements IReturn<CreateAlarmResponse>, IConvertible, IPost
{
    // @DataMember
    String? name;

    // @DataMember
    String? type;

    // @DataMember
    bool? enabled;

    // @DataMember
    bool? allUnits;

    // @DataMember
    List<String>? units;

    // @DataMember
    List<String>? groups;

    // @DataMember
    List<String>? emailRecipients;

    // @DataMember
    List<String>? systemRecipients;

    // @DataMember
    List<String>? smsRecipients;

    // @DataMember
    TemperatureAlarmLimits? temperatureLimits;

    // @DataMember
    ADVoltageAlarmLimits? adVoltageLimits;

    // @DataMember
    int? adVoltageInputIndex;

    // @DataMember
    double? threshold;

    // @DataMember
    double? batteryLevel;

    // @DataMember
    Location? location;

    // @DataMember
    double? radius;

    // @DataMember
    int? inputIndex;

    // @DataMember
    double? interval;

    // @DataMember
    String? pointId;

    // @DataMember
    DateTime? expectedArrivalTime;

    // @DataMember
    double? powerLevel;

    // @DataMember
    List<String>? weekdays;

    // @DataMember
    TimeOfDay? timeStart;

    // @DataMember
    TimeOfDay? timeEnd;

    // @DataMember
    String? zoneId;

    CreateAlarm({this.name,this.type,this.enabled,this.allUnits,this.units,this.groups,this.emailRecipients,this.systemRecipients,this.smsRecipients,this.temperatureLimits,this.adVoltageLimits,this.adVoltageInputIndex,this.threshold,this.batteryLevel,this.location,this.radius,this.inputIndex,this.interval,this.pointId,this.expectedArrivalTime,this.powerLevel,this.weekdays,this.timeStart,this.timeEnd,this.zoneId});
    CreateAlarm.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        type = json['type'];
        enabled = json['enabled'];
        allUnits = json['allUnits'];
        units = JsonConverters.fromJson(json['units'],'List<String>',context!);
        groups = JsonConverters.fromJson(json['groups'],'List<String>',context!);
        emailRecipients = JsonConverters.fromJson(json['emailRecipients'],'List<String>',context!);
        systemRecipients = JsonConverters.fromJson(json['systemRecipients'],'List<String>',context!);
        smsRecipients = JsonConverters.fromJson(json['smsRecipients'],'List<String>',context!);
        temperatureLimits = JsonConverters.fromJson(json['temperatureLimits'],'TemperatureAlarmLimits',context!);
        adVoltageLimits = JsonConverters.fromJson(json['adVoltageLimits'],'ADVoltageAlarmLimits',context!);
        adVoltageInputIndex = json['adVoltageInputIndex'];
        threshold = JsonConverters.toDouble(json['threshold']);
        batteryLevel = JsonConverters.toDouble(json['batteryLevel']);
        location = JsonConverters.fromJson(json['location'],'Location',context!);
        radius = JsonConverters.toDouble(json['radius']);
        inputIndex = json['inputIndex'];
        interval = JsonConverters.toDouble(json['interval']);
        pointId = json['pointId'];
        expectedArrivalTime = JsonConverters.fromJson(json['expectedArrivalTime'],'DateTime',context!);
        powerLevel = JsonConverters.toDouble(json['powerLevel']);
        weekdays = JsonConverters.fromJson(json['weekdays'],'List<String>',context!);
        timeStart = JsonConverters.fromJson(json['timeStart'],'TimeOfDay',context!);
        timeEnd = JsonConverters.fromJson(json['timeEnd'],'TimeOfDay',context!);
        zoneId = json['zoneId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'type': type,
        'enabled': enabled,
        'allUnits': allUnits,
        'units': JsonConverters.toJson(units,'List<String>',context!),
        'groups': JsonConverters.toJson(groups,'List<String>',context!),
        'emailRecipients': JsonConverters.toJson(emailRecipients,'List<String>',context!),
        'systemRecipients': JsonConverters.toJson(systemRecipients,'List<String>',context!),
        'smsRecipients': JsonConverters.toJson(smsRecipients,'List<String>',context!),
        'temperatureLimits': JsonConverters.toJson(temperatureLimits,'TemperatureAlarmLimits',context!),
        'adVoltageLimits': JsonConverters.toJson(adVoltageLimits,'ADVoltageAlarmLimits',context!),
        'adVoltageInputIndex': adVoltageInputIndex,
        'threshold': threshold,
        'batteryLevel': batteryLevel,
        'location': JsonConverters.toJson(location,'Location',context!),
        'radius': radius,
        'inputIndex': inputIndex,
        'interval': interval,
        'pointId': pointId,
        'expectedArrivalTime': JsonConverters.toJson(expectedArrivalTime,'DateTime',context!),
        'powerLevel': powerLevel,
        'weekdays': JsonConverters.toJson(weekdays,'List<String>',context!),
        'timeStart': JsonConverters.toJson(timeStart,'TimeOfDay',context!),
        'timeEnd': JsonConverters.toJson(timeEnd,'TimeOfDay',context!),
        'zoneId': zoneId
    };

    createResponse() => CreateAlarmResponse();
    getResponseTypeName() => "CreateAlarmResponse";
    getTypeName() => "CreateAlarm";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.trackunit.com', types: <String, TypeInfo> {
    'TemperatureAlarmLimits': TypeInfo(TypeOf.Class, create:() => TemperatureAlarmLimits()),
    'ADVoltageAlarmLimits': TypeInfo(TypeOf.Class, create:() => ADVoltageAlarmLimits()),
    'Location': TypeInfo(TypeOf.Class, create:() => Location()),
    'TimeOfDay': TypeInfo(TypeOf.Class, create:() => TimeOfDay()),
    'CreateAlarmResponse': TypeInfo(TypeOf.Class, create:() => CreateAlarmResponse()),
    'CreateAlarm': TypeInfo(TypeOf.Class, create:() => CreateAlarm()),
});