/* Options:
Date: 2026-10-20 20:12:59
Version: 8.22
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://eca-abrechnungsservice-servdesk.eras-online.de

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

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

class Pagination implements IConvertible
{
    int? limit;
    int? total;
    int? offset;

    Pagination({this.limit,this.total,this.offset});
    Pagination.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'limit': limit,
        'total': total,
        'offset': offset
    };

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

class History implements IConvertible
{
    String? time;
    String? value;

    History({this.time,this.value});
    History.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class CompactProfile implements IConvertible
{
    List<History>? history;

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

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

    Map<String, dynamic> toJson() => {
        'history': JsonConverters.toJson(history,'List<History>',context!)
    };

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

class MbusBodyDataRecords implements IConvertible
{
    String? vifUnit;
    String? vifQuantity;
    double? valueScaled;
    String? vifExponent;
    String? valueString;
    String? value;
    String? difFunctionString;
    String? storageNo;
    CompactProfile? compactProfile;

    MbusBodyDataRecords({this.vifUnit,this.vifQuantity,this.valueScaled,this.vifExponent,this.valueString,this.value,this.difFunctionString,this.storageNo,this.compactProfile});
    MbusBodyDataRecords.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        vifUnit = json['vifUnit'];
        vifQuantity = json['vifQuantity'];
        valueScaled = JsonConverters.toDouble(json['valueScaled']);
        vifExponent = json['vifExponent'];
        valueString = json['valueString'];
        value = json['value'];
        difFunctionString = json['difFunctionString'];
        storageNo = json['storageNo'];
        compactProfile = JsonConverters.fromJson(json['compactProfile'],'CompactProfile',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'vifUnit': vifUnit,
        'vifQuantity': vifQuantity,
        'valueScaled': valueScaled,
        'vifExponent': vifExponent,
        'valueString': valueString,
        'value': value,
        'difFunctionString': difFunctionString,
        'storageNo': storageNo,
        'compactProfile': JsonConverters.toJson(compactProfile,'CompactProfile',context!)
    };

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

class MbusBody implements IConvertible
{
    List<MbusBodyDataRecords>? dataRecords;

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

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

    Map<String, dynamic> toJson() => {
        'dataRecords': JsonConverters.toJson(dataRecords,'List<MbusBodyDataRecords>',context!)
    };

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

class Header implements IConvertible
{
    int? idString;
    String? deviceString;

    Header({this.idString,this.deviceString});
    Header.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class DeviceMbusData implements IConvertible
{
    int? idString;
    String? deviceString;
    MbusBody? body;
    Header? header;

    DeviceMbusData({this.idString,this.deviceString,this.body,this.header});
    DeviceMbusData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        idString = json['idString'];
        deviceString = json['deviceString'];
        body = JsonConverters.fromJson(json['body'],'MbusBody',context!);
        header = JsonConverters.fromJson(json['header'],'Header',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'idString': idString,
        'deviceString': deviceString,
        'body': JsonConverters.toJson(body,'MbusBody',context!),
        'header': JsonConverters.toJson(header,'Header',context!)
    };

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

class DeviceData implements IConvertible
{
    DeviceMbusData? mbus;

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

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

    Map<String, dynamic> toJson() => {
        'mbus': JsonConverters.toJson(mbus,'DeviceMbusData',context!)
    };

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

class LobaroData implements IConvertible
{
    int? id;
    int? deviceId;
    DateTime? createdAt;
    DateTime? updatedAt;
    DeviceData? data;

    LobaroData({this.id,this.deviceId,this.createdAt,this.updatedAt,this.data});
    LobaroData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        deviceId = json['deviceId'];
        createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
        updatedAt = JsonConverters.fromJson(json['updatedAt'],'DateTime',context!);
        data = JsonConverters.fromJson(json['data'],'DeviceData',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'deviceId': deviceId,
        'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
        'updatedAt': JsonConverters.toJson(updatedAt,'DateTime',context!),
        'data': JsonConverters.toJson(data,'DeviceData',context!)
    };

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

class GetLobaroDefaultDeviceParsedDataResponse implements IConvertible
{
    ResponseStatus? responseStatus;

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

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

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

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

// @Route("/api/v1/external/lobaro", "POST")
class GetLobaroDefaultDeviceParsedData implements IReturn<GetLobaroDefaultDeviceParsedDataResponse>, IConvertible, IPost
{
    // @ApiMember(IsRequired=true, ParameterType="body")
    Pagination? pagination;

    // @ApiMember(IsRequired=true, ParameterType="body")
    List<LobaroData>? data;

    GetLobaroDefaultDeviceParsedData({this.pagination,this.data});
    GetLobaroDefaultDeviceParsedData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pagination = JsonConverters.fromJson(json['pagination'],'Pagination',context!);
        data = JsonConverters.fromJson(json['data'],'List<LobaroData>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pagination': JsonConverters.toJson(pagination,'Pagination',context!),
        'data': JsonConverters.toJson(data,'List<LobaroData>',context!)
    };

    createResponse() => GetLobaroDefaultDeviceParsedDataResponse();
    getResponseTypeName() => "GetLobaroDefaultDeviceParsedDataResponse";
    getTypeName() => "GetLobaroDefaultDeviceParsedData";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'eca_abrechnungsservice_servdesk.eras_online.de', types: <String, TypeInfo> {
    'Pagination': TypeInfo(TypeOf.Class, create:() => Pagination()),
    'History': TypeInfo(TypeOf.Class, create:() => History()),
    'CompactProfile': TypeInfo(TypeOf.Class, create:() => CompactProfile()),
    'List<History>': TypeInfo(TypeOf.Class, create:() => <History>[]),
    'MbusBodyDataRecords': TypeInfo(TypeOf.Class, create:() => MbusBodyDataRecords()),
    'MbusBody': TypeInfo(TypeOf.Class, create:() => MbusBody()),
    'List<MbusBodyDataRecords>': TypeInfo(TypeOf.Class, create:() => <MbusBodyDataRecords>[]),
    'Header': TypeInfo(TypeOf.Class, create:() => Header()),
    'DeviceMbusData': TypeInfo(TypeOf.Class, create:() => DeviceMbusData()),
    'DeviceData': TypeInfo(TypeOf.Class, create:() => DeviceData()),
    'LobaroData': TypeInfo(TypeOf.Class, create:() => LobaroData()),
    'GetLobaroDefaultDeviceParsedDataResponse': TypeInfo(TypeOf.Class, create:() => GetLobaroDefaultDeviceParsedDataResponse()),
    'GetLobaroDefaultDeviceParsedData': TypeInfo(TypeOf.Class, create:() => GetLobaroDefaultDeviceParsedData()),
    'List<LobaroData>': TypeInfo(TypeOf.Class, create:() => <LobaroData>[]),
});