/* Options:
Date: 2026-04-05 19:47:29
Version: 8.52
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://monitoring.ox2.com/BazeField.Services/api

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

import 'package:servicestack/servicestack.dart';

class AlarmCode implements IConvertible
{
    int? eventNumber;
    int? parameter1;
    String? vendorEventType;

    AlarmCode({this.eventNumber,this.parameter1,this.vendorEventType});
    AlarmCode.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        eventNumber = json['eventNumber'];
        parameter1 = json['parameter1'];
        vendorEventType = json['vendorEventType'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'eventNumber': eventNumber,
        'parameter1': parameter1,
        'vendorEventType': vendorEventType
    };

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

class Alarm implements IConvertible
{
    int? id;
    int? code;
    AlarmCode? alarmCode;
    String? name;
    int? brakePrg;
    bool? canTriggerAllocation;
    String? description;
    String? remarks;
    String? resetPrg;
    bool? isOkAlarm;
    Map<String,String?>? meta;
    int? alarmType;
    String? type;

    Alarm({this.id,this.code,this.alarmCode,this.name,this.brakePrg,this.canTriggerAllocation,this.description,this.remarks,this.resetPrg,this.isOkAlarm,this.meta,this.alarmType,this.type});
    Alarm.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        code = json['code'];
        alarmCode = JsonConverters.fromJson(json['alarmCode'],'AlarmCode',context!);
        name = json['name'];
        brakePrg = json['brakePrg'];
        canTriggerAllocation = json['canTriggerAllocation'];
        description = json['description'];
        remarks = json['remarks'];
        resetPrg = json['resetPrg'];
        isOkAlarm = json['isOkAlarm'];
        meta = JsonConverters.toStringMap(json['meta']);
        alarmType = json['alarmType'];
        type = json['type'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'code': code,
        'alarmCode': JsonConverters.toJson(alarmCode,'AlarmCode',context!),
        'name': name,
        'brakePrg': brakePrg,
        'canTriggerAllocation': canTriggerAllocation,
        'description': description,
        'remarks': remarks,
        'resetPrg': resetPrg,
        'isOkAlarm': isOkAlarm,
        'meta': meta,
        'alarmType': alarmType,
        'type': type
    };

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

enum CommentType
{
    Turbine,
    Allocation,
    Alarm,
}

enum LabelType
{
    Allocation,
    Other,
    Alarm,
    Case,
}

class Label implements IConvertible
{
    int? id;
    String? name;
    String? color;
    LabelType? type;

    Label({this.id,this.name,this.color,this.type});
    Label.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'color': color,
        'type': JsonConverters.toJson(type,'LabelType',context!)
    };

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

class Comment implements IConvertible
{
    int? id;
    int? turbineId;
    String? turbineName;
    DateTime? timeStamp;
    String? text;
    String? createdBy;
    double? createdById;
    DateTime? lastModified;
    CommentType? type;
    bool? External;
    bool? sticky;
    int? allocationId;
    int? alarmLogId;
    int? alarmId;
    int? commandId;
    String? relatedInfo;
    bool? cleared;
    List<Label>? labels;
    String? objectId;
    DateTime? relatedStart;
    DateTime? relatedEnd;

    Comment({this.id,this.turbineId,this.turbineName,this.timeStamp,this.text,this.createdBy,this.createdById,this.lastModified,this.type,this.External,this.sticky,this.allocationId,this.alarmLogId,this.alarmId,this.commandId,this.relatedInfo,this.cleared,this.labels,this.objectId,this.relatedStart,this.relatedEnd});
    Comment.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        turbineId = json['turbineId'];
        turbineName = json['turbineName'];
        timeStamp = JsonConverters.fromJson(json['timeStamp'],'DateTime',context!);
        text = json['text'];
        createdBy = json['createdBy'];
        createdById = JsonConverters.toDouble(json['createdById']);
        lastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        type = JsonConverters.fromJson(json['type'],'CommentType',context!);
        External = json['external'];
        sticky = json['sticky'];
        allocationId = json['allocationId'];
        alarmLogId = json['alarmLogId'];
        alarmId = json['alarmId'];
        commandId = json['commandId'];
        relatedInfo = json['relatedInfo'];
        cleared = json['cleared'];
        labels = JsonConverters.fromJson(json['labels'],'List<Label>',context!);
        objectId = json['objectId'];
        relatedStart = JsonConverters.fromJson(json['relatedStart'],'DateTime',context!);
        relatedEnd = JsonConverters.fromJson(json['relatedEnd'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'turbineId': turbineId,
        'turbineName': turbineName,
        'timeStamp': JsonConverters.toJson(timeStamp,'DateTime',context!),
        'text': text,
        'createdBy': createdBy,
        'createdById': createdById,
        'lastModified': JsonConverters.toJson(lastModified,'DateTime',context!),
        'type': JsonConverters.toJson(type,'CommentType',context!),
        'external': External,
        'sticky': sticky,
        'allocationId': allocationId,
        'alarmLogId': alarmLogId,
        'alarmId': alarmId,
        'commandId': commandId,
        'relatedInfo': relatedInfo,
        'cleared': cleared,
        'labels': JsonConverters.toJson(labels,'List<Label>',context!),
        'objectId': objectId,
        'relatedStart': JsonConverters.toJson(relatedStart,'DateTime',context!),
        'relatedEnd': JsonConverters.toJson(relatedEnd,'DateTime',context!)
    };

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

class TriggerAlarm implements IConvertible
{
    Alarm? alarm;
    DateTime? start;
    DateTime? end;
    int? logId;
    String? sfId;

    TriggerAlarm({this.alarm,this.start,this.end,this.logId,this.sfId});
    TriggerAlarm.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        alarm = JsonConverters.fromJson(json['alarm'],'Alarm',context!);
        start = JsonConverters.fromJson(json['start'],'DateTime',context!);
        end = JsonConverters.fromJson(json['end'],'DateTime',context!);
        logId = json['logId'];
        sfId = json['sfId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'alarm': JsonConverters.toJson(alarm,'Alarm',context!),
        'start': JsonConverters.toJson(start,'DateTime',context!),
        'end': JsonConverters.toJson(end,'DateTime',context!),
        'logId': logId,
        'sfId': sfId
    };

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

class AllocationCategory implements IConvertible
{
    int? id;
    String? name;
    String? acronym;
    String? color;
    bool? uncategorized;
    bool? available;
    int? typeId;
    String? group;
    int? sortIndex;
    int? priority;
    bool? enabled;
    int? performance;
    int? excluded;
    int? parentCategoryId;
    String? parentCategoryName;
    String? code;
    String? variantAlias;
    Map<String,String?>? attributes;

    AllocationCategory({this.id,this.name,this.acronym,this.color,this.uncategorized,this.available,this.typeId,this.group,this.sortIndex,this.priority,this.enabled,this.performance,this.excluded,this.parentCategoryId,this.parentCategoryName,this.code,this.variantAlias,this.attributes});
    AllocationCategory.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        acronym = json['acronym'];
        color = json['color'];
        uncategorized = json['uncategorized'];
        available = json['available'];
        typeId = json['typeId'];
        group = json['group'];
        sortIndex = json['sortIndex'];
        priority = json['priority'];
        enabled = json['enabled'];
        performance = json['performance'];
        excluded = json['excluded'];
        parentCategoryId = json['parentCategoryId'];
        parentCategoryName = json['parentCategoryName'];
        code = json['code'];
        variantAlias = json['variantAlias'];
        attributes = JsonConverters.toStringMap(json['attributes']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'acronym': acronym,
        'color': color,
        'uncategorized': uncategorized,
        'available': available,
        'typeId': typeId,
        'group': group,
        'sortIndex': sortIndex,
        'priority': priority,
        'enabled': enabled,
        'performance': performance,
        'excluded': excluded,
        'parentCategoryId': parentCategoryId,
        'parentCategoryName': parentCategoryName,
        'code': code,
        'variantAlias': variantAlias,
        'attributes': attributes
    };

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

class AllocationType implements IConvertible
{
    int? id;
    String? name;
    String? acronym;
    String? version;
    String? description;
    int? sortOrder;
    int? linkedTypeId;
    bool? subType;
    String? groupName;
    bool? defaultVisible;
    int? domainId;
    bool? disabled;
    String? matrix;
    bool? certified;
    int? allocationTypeClassId;
    int? variantOfAbstractTypeId;

    AllocationType({this.id,this.name,this.acronym,this.version,this.description,this.sortOrder,this.linkedTypeId,this.subType,this.groupName,this.defaultVisible,this.domainId,this.disabled,this.matrix,this.certified,this.allocationTypeClassId,this.variantOfAbstractTypeId});
    AllocationType.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        acronym = json['acronym'];
        version = json['version'];
        description = json['description'];
        sortOrder = json['sortOrder'];
        linkedTypeId = json['linkedTypeId'];
        subType = json['subType'];
        groupName = json['groupName'];
        defaultVisible = json['defaultVisible'];
        domainId = json['domainId'];
        disabled = json['disabled'];
        matrix = json['matrix'];
        certified = json['certified'];
        allocationTypeClassId = json['allocationTypeClassId'];
        variantOfAbstractTypeId = json['variantOfAbstractTypeId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'acronym': acronym,
        'version': version,
        'description': description,
        'sortOrder': sortOrder,
        'linkedTypeId': linkedTypeId,
        'subType': subType,
        'groupName': groupName,
        'defaultVisible': defaultVisible,
        'domainId': domainId,
        'disabled': disabled,
        'matrix': matrix,
        'certified': certified,
        'allocationTypeClassId': allocationTypeClassId,
        'variantOfAbstractTypeId': variantOfAbstractTypeId
    };

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

class AllocationCategoryWithType extends AllocationCategory implements IConvertible
{
    AllocationType? allocationType;

    AllocationCategoryWithType({this.allocationType});
    AllocationCategoryWithType.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'allocationType': JsonConverters.toJson(allocationType,'AllocationType',context!)
    });

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

class AllocationPropertyValue implements IConvertible
{
    String? name;
    String? displayName;
    double? value;
    double? limitedValue;
    String? unit;
    bool? isOverride;
    String? description;

    AllocationPropertyValue({this.name,this.displayName,this.value,this.limitedValue,this.unit,this.isOverride,this.description});
    AllocationPropertyValue.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        displayName = json['displayName'];
        value = JsonConverters.toDouble(json['value']);
        limitedValue = JsonConverters.toDouble(json['limitedValue']);
        unit = json['unit'];
        isOverride = json['isOverride'];
        description = json['description'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'displayName': displayName,
        'value': value,
        'limitedValue': limitedValue,
        'unit': unit,
        'isOverride': isOverride,
        'description': description
    };

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

class AllocationCategory implements IConvertible
{
    int? id;
    String? name;
    String? color;
    bool? uncategorized;
    bool? available;
    int? priority;
    int? performance;
    int? excluded;
    int? parentCategoryId;
    int? typeId;
    String? typeName;
    String? code;

    AllocationCategory({this.id,this.name,this.color,this.uncategorized,this.available,this.priority,this.performance,this.excluded,this.parentCategoryId,this.typeId,this.typeName,this.code});
    AllocationCategory.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        color = json['color'];
        uncategorized = json['uncategorized'];
        available = json['available'];
        priority = json['priority'];
        performance = json['performance'];
        excluded = json['excluded'];
        parentCategoryId = json['parentCategoryId'];
        typeId = json['typeId'];
        typeName = json['typeName'];
        code = json['code'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'color': color,
        'uncategorized': uncategorized,
        'available': available,
        'priority': priority,
        'performance': performance,
        'excluded': excluded,
        'parentCategoryId': parentCategoryId,
        'typeId': typeId,
        'typeName': typeName,
        'code': code
    };

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

class Allocation implements IConvertible
{
    int? id;
    int? turbineId;
    String? objectId;
    String? turbineName;
    String? turbineTitle;
    int? sourceId;
    String? sourceName;
    String? rootCause;
    TriggerAlarm? triggeredByAlarm;
    AllocationCategoryWithType? category;
    List<AllocationCategoryWithType>? categories;
    DateTime? start;
    DateTime? end;
    DateTime? start_Local;
    DateTime? end_Local;
    Duration? duration;
    DateTime? lastModified;
    bool? isUnclassified;
    bool? manualOverrideLoss;
    DateTime? responseTime;
    double? lostProduction;
    double? lostProdutionFiltered;
    double? lostMoney;
    double? lostMoneyFiltered;
    List<AllocationPropertyValue>? properties;
    bool? finished;
    bool? manual;
    bool? overridden;
    bool? reallocated;
    bool? pending;
    String? changeLog;
    Comment? lastComment;
    String? exported;
    List<Label>? labels;
    bool? suspect;
    bool? uncertain;
    int? eventId;
    bool? hasEvent;
    bool? holdCategory;
    bool? approved;
    String? sfId;
    String? firstAlarmSfId;
    int? rootCauseAlarmId;

    Allocation({this.id,this.turbineId,this.objectId,this.turbineName,this.turbineTitle,this.sourceId,this.sourceName,this.rootCause,this.triggeredByAlarm,this.category,this.categories,this.start,this.end,this.start_Local,this.end_Local,this.duration,this.lastModified,this.isUnclassified,this.manualOverrideLoss,this.responseTime,this.lostProduction,this.lostProdutionFiltered,this.lostMoney,this.lostMoneyFiltered,this.properties,this.finished,this.manual,this.overridden,this.reallocated,this.pending,this.changeLog,this.lastComment,this.exported,this.labels,this.suspect,this.uncertain,this.eventId,this.hasEvent,this.holdCategory,this.approved,this.sfId,this.firstAlarmSfId,this.rootCauseAlarmId});
    Allocation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        turbineId = json['turbineId'];
        objectId = json['objectId'];
        turbineName = json['turbineName'];
        turbineTitle = json['turbineTitle'];
        sourceId = json['sourceId'];
        sourceName = json['sourceName'];
        rootCause = json['rootCause'];
        triggeredByAlarm = JsonConverters.fromJson(json['triggeredByAlarm'],'TriggerAlarm',context!);
        category = JsonConverters.fromJson(json['category'],'AllocationCategoryWithType',context!);
        categories = JsonConverters.fromJson(json['categories'],'List<AllocationCategoryWithType>',context!);
        start = JsonConverters.fromJson(json['start'],'DateTime',context!);
        end = JsonConverters.fromJson(json['end'],'DateTime',context!);
        start_Local = JsonConverters.fromJson(json['start_Local'],'DateTime',context!);
        end_Local = JsonConverters.fromJson(json['end_Local'],'DateTime',context!);
        duration = JsonConverters.fromJson(json['duration'],'Duration',context!);
        lastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        isUnclassified = json['isUnclassified'];
        manualOverrideLoss = json['manualOverrideLoss'];
        responseTime = JsonConverters.fromJson(json['responseTime'],'DateTime',context!);
        lostProduction = JsonConverters.toDouble(json['lostProduction']);
        lostProdutionFiltered = JsonConverters.toDouble(json['lostProdutionFiltered']);
        lostMoney = JsonConverters.toDouble(json['lostMoney']);
        lostMoneyFiltered = JsonConverters.toDouble(json['lostMoneyFiltered']);
        properties = JsonConverters.fromJson(json['properties'],'List<AllocationPropertyValue>',context!);
        finished = json['finished'];
        manual = json['manual'];
        overridden = json['overridden'];
        reallocated = json['reallocated'];
        pending = json['pending'];
        changeLog = json['changeLog'];
        lastComment = JsonConverters.fromJson(json['lastComment'],'Comment',context!);
        exported = json['exported'];
        labels = JsonConverters.fromJson(json['labels'],'List<Label>',context!);
        suspect = json['suspect'];
        uncertain = json['uncertain'];
        eventId = json['eventId'];
        hasEvent = json['hasEvent'];
        holdCategory = json['holdCategory'];
        approved = json['approved'];
        sfId = json['sfId'];
        firstAlarmSfId = json['firstAlarmSfId'];
        rootCauseAlarmId = json['rootCauseAlarmId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'turbineId': turbineId,
        'objectId': objectId,
        'turbineName': turbineName,
        'turbineTitle': turbineTitle,
        'sourceId': sourceId,
        'sourceName': sourceName,
        'rootCause': rootCause,
        'triggeredByAlarm': JsonConverters.toJson(triggeredByAlarm,'TriggerAlarm',context!),
        'category': JsonConverters.toJson(category,'AllocationCategoryWithType',context!),
        'categories': JsonConverters.toJson(categories,'List<AllocationCategoryWithType>',context!),
        'start': JsonConverters.toJson(start,'DateTime',context!),
        'end': JsonConverters.toJson(end,'DateTime',context!),
        'start_Local': JsonConverters.toJson(start_Local,'DateTime',context!),
        'end_Local': JsonConverters.toJson(end_Local,'DateTime',context!),
        'duration': JsonConverters.toJson(duration,'Duration',context!),
        'lastModified': JsonConverters.toJson(lastModified,'DateTime',context!),
        'isUnclassified': isUnclassified,
        'manualOverrideLoss': manualOverrideLoss,
        'responseTime': JsonConverters.toJson(responseTime,'DateTime',context!),
        'lostProduction': lostProduction,
        'lostProdutionFiltered': lostProdutionFiltered,
        'lostMoney': lostMoney,
        'lostMoneyFiltered': lostMoneyFiltered,
        'properties': JsonConverters.toJson(properties,'List<AllocationPropertyValue>',context!),
        'finished': finished,
        'manual': manual,
        'overridden': overridden,
        'reallocated': reallocated,
        'pending': pending,
        'changeLog': changeLog,
        'lastComment': JsonConverters.toJson(lastComment,'Comment',context!),
        'exported': exported,
        'labels': JsonConverters.toJson(labels,'List<Label>',context!),
        'suspect': suspect,
        'uncertain': uncertain,
        'eventId': eventId,
        'hasEvent': hasEvent,
        'holdCategory': holdCategory,
        'approved': approved,
        'sfId': sfId,
        'firstAlarmSfId': firstAlarmSfId,
        'rootCauseAlarmId': rootCauseAlarmId
    };

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

// @Route("/allocations/{Id}", "GET")
class GetAllocation implements IReturn<Allocation>, IConvertible, IGet
{
    int? id;

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

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

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

    createResponse() => Allocation();
    getResponseTypeName() => "Allocation";
    getTypeName() => "GetAllocation";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'monitoring.ox2.com', types: <String, TypeInfo> {
    'AlarmCode': TypeInfo(TypeOf.Class, create:() => AlarmCode()),
    'Alarm': TypeInfo(TypeOf.Class, create:() => Alarm()),
    'CommentType': TypeInfo(TypeOf.Enum, enumValues:CommentType.values),
    'LabelType': TypeInfo(TypeOf.Enum, enumValues:LabelType.values),
    'Label': TypeInfo(TypeOf.Class, create:() => Label()),
    'Comment': TypeInfo(TypeOf.Class, create:() => Comment()),
    'List<Label>': TypeInfo(TypeOf.Class, create:() => <Label>[]),
    'TriggerAlarm': TypeInfo(TypeOf.Class, create:() => TriggerAlarm()),
    'AllocationCategory': TypeInfo(TypeOf.Class, create:() => AllocationCategory()),
    'AllocationType': TypeInfo(TypeOf.Class, create:() => AllocationType()),
    'AllocationCategoryWithType': TypeInfo(TypeOf.Class, create:() => AllocationCategoryWithType()),
    'AllocationPropertyValue': TypeInfo(TypeOf.Class, create:() => AllocationPropertyValue()),
    'Allocation': TypeInfo(TypeOf.Class, create:() => Allocation()),
    'List<AllocationCategoryWithType>': TypeInfo(TypeOf.Class, create:() => <AllocationCategoryWithType>[]),
    'List<AllocationPropertyValue>': TypeInfo(TypeOf.Class, create:() => <AllocationPropertyValue>[]),
    'GetAllocation': TypeInfo(TypeOf.Class, create:() => GetAllocation()),
});