Server

<back to all web services

UpdateNutzeinheit

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

// @DataContract
abstract class Eras2AppServiceModelBase
{
    // @DataMember(Name="UserId")
    String? UserId;

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

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

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

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

class UpdateNutzeinheitResponse implements IConvertible
{
    ResponseStatus? responseStatus;

    UpdateNutzeinheitResponse({this.responseStatus});
    UpdateNutzeinheitResponse.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() => "UpdateNutzeinheitResponse";
    TypeContext? context = _ctx;
}

// @DataContract
class Address implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="Straße")
    String? Stra_e;

    // @DataMember(Name="Straße2")
    String? Stra_e2;

    // @DataMember(Name="Hausnummer")
    String? Hausnummer;

    // @DataMember(Name="Postleitzahl")
    String? Postleitzahl;

    // @DataMember(Name="Ort")
    String? Ort;

    // @DataMember(Name="Postfach")
    String? Postfach;

    // @DataMember(Name="Adresszusatz")
    String? Adresszusatz;

    // @DataMember(Name="Breitengrad")
    double? Breitengrad;

    // @DataMember(Name="Laengengrad")
    double? Laengengrad;

    Address({this.Guid,this.Stra_e,this.Stra_e2,this.Hausnummer,this.Postleitzahl,this.Ort,this.Postfach,this.Adresszusatz,this.Breitengrad,this.Laengengrad});
    Address.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        Stra_e = json['street'];
        Stra_e2 = json['street2'];
        Hausnummer = json['streetNumber'];
        Postleitzahl = json['zipcode'];
        Ort = json['city'];
        Postfach = json['mailbox'];
        Adresszusatz = json['additional'];
        Breitengrad = JsonConverters.toDouble(json['latitude']);
        Laengengrad = JsonConverters.toDouble(json['longitude']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'stra_e': Stra_e,
        'stra_e2': Stra_e2,
        'hausnummer': Hausnummer,
        'postleitzahl': Postleitzahl,
        'ort': Ort,
        'postfach': Postfach,
        'adresszusatz': Adresszusatz,
        'breitengrad': Breitengrad,
        'laengengrad': Laengengrad
    };

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

enum UnitKind
{
    L,
    Kg,
    CBM,
    Stck,
    KWH,
    MWH,
    GWH,
    T,
    RM,
    Einheit,
    Qm,
    GJ,
    MJ,
    Null,
}

enum EstimationKind
{
    Null,
    S1,
    S2,
    S3,
    S4,
    S5,
    N1,
    N2,
}

enum DeviceConsumptionState
{
    Null,
    RMInOrdnung,
    RMFehler,
    RMNichtGepr,
    RMFehlerTausch,
    KeinWohnungszutritt,
    Defekt,
    FalschLaufend,
    Überlauf,
    EichungBeachten,
    ProbeEntnommen,
    ProbeZumLabor,
    ProbePositiv,
    ProbeNegativ,
}

enum DeviceConsumptionOrigin
{
    Unbekannt,
    Manual,
    Emr,
    Walkby,
    Deleted,
}

// @DataContract
class DeviceConsumption implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="Ablesedatum")
    DateTime? Ablesedatum;

    // @DataMember(Name="Faktor")
    double? Faktor;

    // @DataMember(Name="Ablesung")
    double? Ablesung;

    // @DataMember(Name="Verbrauch")
    double? Verbrauch;

    // @DataMember(Name="Aenderungsdatum")
    DateTime? Aenderungsdatum;

    // @DataMember(Name="Schaetzung")
    EstimationKind? Schaetzung;

    // @DataMember(Name="Status")
    DeviceConsumptionState? Status;

    // @DataMember(Name="Anmerkung")
    String? Anmerkung;

    // @DataMember(Name="IstRekonstruiert")
    bool? IstRekonstruiert;

    // @DataMember(Name="Manuell")
    double? Manuell;

    // @DataMember(Name="Herkunft")
    DeviceConsumptionOrigin? Herkunft;

    // @DataMember(Name="Lufttemperatur")
    double? Lufttemperatur;

    // @DataMember(Name="HeizkörperTemperatur")
    double? Heizk_rperTemperatur;

    // @DataMember(Name="LetzterfehlerDatum")
    DateTime? LetzterfehlerDatum;

    // @DataMember(Name="Fehler")
    String? Fehler;

    // @DataMember(Name="Ampullenfarbe")
    String? Ampullenfarbe;

    // @DataMember(Name="AbleseartGuid")
    String? AbleseartGuid;

    DeviceConsumption({this.Guid,this.LastModified,this.Ablesedatum,this.Faktor,this.Ablesung,this.Verbrauch,this.Aenderungsdatum,this.Schaetzung,this.Status,this.Anmerkung,this.IstRekonstruiert,this.Manuell,this.Herkunft,this.Lufttemperatur,this.Heizk_rperTemperatur,this.LetzterfehlerDatum,this.Fehler,this.Ampullenfarbe,this.AbleseartGuid});
    DeviceConsumption.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        Ablesedatum = JsonConverters.fromJson(json['readingDate'],'DateTime',context!);
        Faktor = JsonConverters.toDouble(json['factor']);
        Ablesung = JsonConverters.toDouble(json['reading']);
        Verbrauch = JsonConverters.toDouble(json['consumption']);
        Aenderungsdatum = JsonConverters.fromJson(json['changeDate'],'DateTime',context!);
        Schaetzung = JsonConverters.fromJson(json['estimation'],'EstimationKind',context!);
        Status = JsonConverters.fromJson(json['state'],'DeviceConsumptionState',context!);
        Anmerkung = json['note'];
        IstRekonstruiert = json['isReconstructed'];
        Manuell = JsonConverters.toDouble(json['manual']);
        Herkunft = JsonConverters.fromJson(json['origin'],'DeviceConsumptionOrigin',context!);
        Lufttemperatur = JsonConverters.toDouble(json['airTemperature']);
        Heizk_rperTemperatur = JsonConverters.toDouble(json['radiatorTemperature']);
        LetzterfehlerDatum = JsonConverters.fromJson(json['lastErrorDate'],'DateTime',context!);
        Fehler = json['error'];
        Ampullenfarbe = json['ampouleColour'];
        AbleseartGuid = json['readindKindGuid'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'ablesedatum': JsonConverters.toJson(Ablesedatum,'DateTime',context!),
        'faktor': Faktor,
        'ablesung': Ablesung,
        'verbrauch': Verbrauch,
        'aenderungsdatum': JsonConverters.toJson(Aenderungsdatum,'DateTime',context!),
        'schaetzung': JsonConverters.toJson(Schaetzung,'EstimationKind',context!),
        'status': JsonConverters.toJson(Status,'DeviceConsumptionState',context!),
        'anmerkung': Anmerkung,
        'istRekonstruiert': IstRekonstruiert,
        'manuell': Manuell,
        'herkunft': JsonConverters.toJson(Herkunft,'DeviceConsumptionOrigin',context!),
        'lufttemperatur': Lufttemperatur,
        'heizk_rperTemperatur': Heizk_rperTemperatur,
        'letzterfehlerDatum': JsonConverters.toJson(LetzterfehlerDatum,'DateTime',context!),
        'fehler': Fehler,
        'ampullenfarbe': Ampullenfarbe,
        'ableseartGuid': AbleseartGuid
    };

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

// @DataContract
class Photo implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="Timestamp")
    DateTime? Timestamp;

    Photo({this.Guid,this.Timestamp});
    Photo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        Timestamp = JsonConverters.fromJson(json['recordedDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'timestamp': JsonConverters.toJson(Timestamp,'DateTime',context!)
    };

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

// @DataContract
class DeviceAdditionalArticle implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="Menge")
    double? Menge;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    DeviceAdditionalArticle({this.Guid,this.Menge,this.LastModified});
    DeviceAdditionalArticle.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['additionalArticleGuid'];
        Menge = JsonConverters.toDouble(json['quantity']);
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'menge': Menge,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!)
    };

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

// @DataContract
class Device implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="Geraetenummer")
    String? Geraetenummer;

    // @DataMember(Name="Bezeichnung")
    String? Bezeichnung;

    // @DataMember(Name="Beschreibung")
    String? Beschreibung;

    // @DataMember(Name="Einbaudatum")
    DateTime? Einbaudatum;

    // @DataMember(Name="Ausbaudatum")
    DateTime? Ausbaudatum;

    // @DataMember(Name="Eichdatum")
    DateTime? Eichdatum;

    // @DataMember(Name="Einheit")
    UnitKind? Einheit;

    // @DataMember(Name="Memo")
    String? Memo;

    // @DataMember(Name="Abzug")
    bool? Abzug;

    // @DataMember(Name="GrpKennung")
    String? GrpKennung;

    // @DataMember(Name="Dauerschaetzung")
    EstimationKind? Dauerschaetzung;

    // @DataMember(Name="ErstInbetriebnahme")
    DateTime? ErstInbetriebnahme;

    // @DataMember(Name="FirmwareVersion")
    String? FirmwareVersion;

    // @DataMember(Name="RaumGuid")
    String? RaumGuid;

    // @DataMember(Name="LaufendeNummer")
    String? LaufendeNummer;

    // @DataMember(Name="Gemietet")
    bool? Gemietet;

    // @DataMember(Name="Gewartet")
    bool? Gewartet;

    // @DataMember(Name="GeraeteKatalogGuid")
    String? GeraeteKatalogGuid;

    // @DataMember(Name="Verbraeuche")
    List<DeviceConsumption>? Verbraeuche;

    // @DataMember(Name="Fotos")
    List<Photo>? Fotos;

    // @DataMember(Name="ZusatzArtikel")
    List<DeviceAdditionalArticle>? ZusatzArtikel;

    Device({this.Guid,this.LastModified,this.Geraetenummer,this.Bezeichnung,this.Beschreibung,this.Einbaudatum,this.Ausbaudatum,this.Eichdatum,this.Einheit,this.Memo,this.Abzug,this.GrpKennung,this.Dauerschaetzung,this.ErstInbetriebnahme,this.FirmwareVersion,this.RaumGuid,this.LaufendeNummer,this.Gemietet,this.Gewartet,this.GeraeteKatalogGuid,this.Verbraeuche,this.Fotos,this.ZusatzArtikel});
    Device.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        Geraetenummer = json['number'];
        Bezeichnung = json['label'];
        Beschreibung = json['description'];
        Einbaudatum = JsonConverters.fromJson(json['installationDate'],'DateTime',context!);
        Ausbaudatum = JsonConverters.fromJson(json['deinstallationDate'],'DateTime',context!);
        Eichdatum = JsonConverters.fromJson(json['calibrationDate'],'DateTime',context!);
        Einheit = JsonConverters.fromJson(json['unit'],'UnitKind',context!);
        Memo = json['note'];
        Abzug = json['subtraction'];
        GrpKennung = json['groupIdentifier'];
        Dauerschaetzung = JsonConverters.fromJson(json['estimation'],'EstimationKind',context!);
        ErstInbetriebnahme = JsonConverters.fromJson(json['firstActivation'],'DateTime',context!);
        FirmwareVersion = json['firmwareVersion'];
        RaumGuid = json['roomGuid'];
        LaufendeNummer = json['ongoingNumber'];
        Gemietet = json['isLeased'];
        Gewartet = json['isMaintained'];
        GeraeteKatalogGuid = json['deviceCatalogGuid'];
        Verbraeuche = JsonConverters.fromJson(json['deviceConsumptions'],'List<DeviceConsumption>',context!);
        Fotos = JsonConverters.fromJson(json['photos'],'List<Photo>',context!);
        ZusatzArtikel = JsonConverters.fromJson(json['deviceAdditionalArticles'],'List<DeviceAdditionalArticle>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'geraetenummer': Geraetenummer,
        'bezeichnung': Bezeichnung,
        'beschreibung': Beschreibung,
        'einbaudatum': JsonConverters.toJson(Einbaudatum,'DateTime',context!),
        'ausbaudatum': JsonConverters.toJson(Ausbaudatum,'DateTime',context!),
        'eichdatum': JsonConverters.toJson(Eichdatum,'DateTime',context!),
        'einheit': JsonConverters.toJson(Einheit,'UnitKind',context!),
        'memo': Memo,
        'abzug': Abzug,
        'grpKennung': GrpKennung,
        'dauerschaetzung': JsonConverters.toJson(Dauerschaetzung,'EstimationKind',context!),
        'erstInbetriebnahme': JsonConverters.toJson(ErstInbetriebnahme,'DateTime',context!),
        'firmwareVersion': FirmwareVersion,
        'raumGuid': RaumGuid,
        'laufendeNummer': LaufendeNummer,
        'gemietet': Gemietet,
        'gewartet': Gewartet,
        'geraeteKatalogGuid': GeraeteKatalogGuid,
        'verbraeuche': JsonConverters.toJson(Verbraeuche,'List<DeviceConsumption>',context!),
        'fotos': JsonConverters.toJson(Fotos,'List<Photo>',context!),
        'zusatzArtikel': JsonConverters.toJson(ZusatzArtikel,'List<DeviceAdditionalArticle>',context!)
    };

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

enum NutzerKind
{
    Leerstand,
    Gewerblich,
    Privat,
    AllgemeineNutzung,
}

// @DataContract
class NutzerCommunication implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="Adresse")
    String? Adresse;

    // @DataMember(Name="Anmerkung")
    String? Anmerkung;

    // @DataMember(Name="KommunikationsFunktionGuid")
    String? KommunikationsFunktionGuid;

    NutzerCommunication({this.Guid,this.LastModified,this.Adresse,this.Anmerkung,this.KommunikationsFunktionGuid});
    NutzerCommunication.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        Adresse = json['address'];
        Anmerkung = json['note'];
        KommunikationsFunktionGuid = json['communicationFeatureGuid'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'adresse': Adresse,
        'anmerkung': Anmerkung,
        'kommunikationsFunktionGuid': KommunikationsFunktionGuid
    };

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

// @DataContract
class NutzerPersonen implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="Personen")
    int? Personen;

    // @DataMember(Name="Von")
    DateTime? Von;

    // @DataMember(Name="Bis")
    DateTime? Bis;

    NutzerPersonen({this.Guid,this.LastModified,this.Personen,this.Von,this.Bis});
    NutzerPersonen.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        Personen = json['numberOfPeople'];
        Von = JsonConverters.fromJson(json['rangeFrom'],'DateTime',context!);
        Bis = JsonConverters.fromJson(json['rangeTo'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'personen': Personen,
        'von': JsonConverters.toJson(Von,'DateTime',context!),
        'bis': JsonConverters.toJson(Bis,'DateTime',context!)
    };

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

// @DataContract
class NutzerCoOwnership implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="ShareValue")
    double? ShareValue;

    // @DataMember(Name="Von")
    DateTime? Von;

    // @DataMember(Name="Bis")
    DateTime? Bis;

    NutzerCoOwnership({this.Guid,this.LastModified,this.ShareValue,this.Von,this.Bis});
    NutzerCoOwnership.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        ShareValue = JsonConverters.toDouble(json['shareValue']);
        Von = JsonConverters.fromJson(json['rangeFrom'],'DateTime',context!);
        Bis = JsonConverters.fromJson(json['rangeTo'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'shareValue': ShareValue,
        'von': JsonConverters.toJson(Von,'DateTime',context!),
        'bis': JsonConverters.toJson(Bis,'DateTime',context!)
    };

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

// @DataContract
class NutzerQuadratmeter implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="Quadratmeter_Hzg")
    double? Quadratmeter_Hzg;

    // @DataMember(Name="Quadratmeter_Ww")
    double? Quadratmeter_Ww;

    // @DataMember(Name="Quadratmeter_Nk")
    double? Quadratmeter_Nk;

    // @DataMember(Name="Von")
    DateTime? Von;

    // @DataMember(Name="Bis")
    DateTime? Bis;

    NutzerQuadratmeter({this.Guid,this.LastModified,this.Quadratmeter_Hzg,this.Quadratmeter_Ww,this.Quadratmeter_Nk,this.Von,this.Bis});
    NutzerQuadratmeter.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        Quadratmeter_Hzg = JsonConverters.toDouble(json['squareMeters_Hzg']);
        Quadratmeter_Ww = JsonConverters.toDouble(json['squareMeters_Ww']);
        Quadratmeter_Nk = JsonConverters.toDouble(json['squareMeters_Nk']);
        Von = JsonConverters.fromJson(json['rangeFrom'],'DateTime',context!);
        Bis = JsonConverters.fromJson(json['rangeTo'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'quadratmeter_Hzg': Quadratmeter_Hzg,
        'quadratmeter_Ww': Quadratmeter_Ww,
        'quadratmeter_Nk': Quadratmeter_Nk,
        'von': JsonConverters.toJson(Von,'DateTime',context!),
        'bis': JsonConverters.toJson(Bis,'DateTime',context!)
    };

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

// @DataContract
class Nutzer implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="ArtDerNutzung")
    NutzerKind? ArtDerNutzung;

    // @DataMember(Name="Einzug")
    DateTime? Einzug;

    // @DataMember(Name="Auszug")
    DateTime? Auszug;

    // @DataMember(Name="Name1")
    String? Name1;

    // @DataMember(Name="Name2")
    String? Name2;

    // @DataMember(Name="Name3")
    String? Name3;

    // @DataMember(Name="Name4")
    String? Name4;

    // @DataMember(Name="Anmerkung")
    String? Anmerkung;

    // @DataMember(Name="NaechsterTermin")
    DateTime? NaechsterTermin;

    // @DataMember(Name="Anrede")
    String? Anrede;

    // @DataMember(Name="Titel")
    String? Titel;

    // @DataMember(Name="NutzerKommunikationen")
    List<NutzerCommunication>? NutzerKommunikationen;

    // @DataMember(Name="NutzerPersonen")
    List<NutzerPersonen>? NutzerPersonen;

    // @DataMember(Name="NutzerCoOwnership")
    List<NutzerCoOwnership>? NutzerCoOwnership;

    // @DataMember(Name="NutzerQuadratmeter")
    List<NutzerQuadratmeter>? NutzerQuadratmeter;

    Nutzer({this.Guid,this.LastModified,this.ArtDerNutzung,this.Einzug,this.Auszug,this.Name1,this.Name2,this.Name3,this.Name4,this.Anmerkung,this.NaechsterTermin,this.Anrede,this.Titel,this.NutzerKommunikationen,this.NutzerPersonen,this.NutzerCoOwnership,this.NutzerQuadratmeter});
    Nutzer.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        ArtDerNutzung = JsonConverters.fromJson(json['kind'],'NutzerKind',context!);
        Einzug = JsonConverters.fromJson(json['moveInDate'],'DateTime',context!);
        Auszug = JsonConverters.fromJson(json['moveOutDate'],'DateTime',context!);
        Name1 = json['name1'];
        Name2 = json['name2'];
        Name3 = json['name3'];
        Name4 = json['name4'];
        Anmerkung = json['note'];
        NaechsterTermin = JsonConverters.fromJson(json['nextAppointmentDate'],'DateTime',context!);
        Anrede = json['salutation'];
        Titel = json['title'];
        NutzerKommunikationen = JsonConverters.fromJson(json['nutzerCommunications'],'List<NutzerCommunication>',context!);
        NutzerPersonen = JsonConverters.fromJson(json['nutzerPersonen'],'List<NutzerPersonen>',context!);
        NutzerCoOwnership = JsonConverters.fromJson(json['nutzerCoOwnership'],'List<NutzerCoOwnership>',context!);
        NutzerQuadratmeter = JsonConverters.fromJson(json['nutzerQuadratmeter'],'List<NutzerQuadratmeter>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'artDerNutzung': JsonConverters.toJson(ArtDerNutzung,'NutzerKind',context!),
        'einzug': JsonConverters.toJson(Einzug,'DateTime',context!),
        'auszug': JsonConverters.toJson(Auszug,'DateTime',context!),
        'name1': Name1,
        'name2': Name2,
        'name3': Name3,
        'name4': Name4,
        'anmerkung': Anmerkung,
        'naechsterTermin': JsonConverters.toJson(NaechsterTermin,'DateTime',context!),
        'anrede': Anrede,
        'titel': Titel,
        'nutzerKommunikationen': JsonConverters.toJson(NutzerKommunikationen,'List<NutzerCommunication>',context!),
        'nutzerPersonen': JsonConverters.toJson(NutzerPersonen,'List<NutzerPersonen>',context!),
        'nutzerCoOwnership': JsonConverters.toJson(NutzerCoOwnership,'List<NutzerCoOwnership>',context!),
        'nutzerQuadratmeter': JsonConverters.toJson(NutzerQuadratmeter,'List<NutzerQuadratmeter>',context!)
    };

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

class Nutzeinheit implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="LastModified")
    DateTime? LastModified;

    // @DataMember(Name="NeNummerInt")
    String? NeNummerInt;

    // @DataMember(Name="Lage")
    String? Lage;

    // @DataMember(Name="BegeReihenfolge")
    String? BegeReihenfolge;

    // @DataMember(Name="Anmerkung")
    String? Anmerkung;

    // @DataMember(Name="AbrechnungseinheitGuid")
    String? AbrechnungseinheitGuid;

    // @DataMember(Name="Adresse")
    Address? Adresse;

    // @DataMember(Name="Geraete")
    List<Device>? Geraete;

    // @DataMember(Name="Nutzer")
    List<Nutzer>? Nutzer;

    // @DataMember(Name="Fotos")
    List<Photo>? Fotos;

    Nutzeinheit({this.Guid,this.LastModified,this.NeNummerInt,this.Lage,this.BegeReihenfolge,this.Anmerkung,this.AbrechnungseinheitGuid,this.Adresse,this.Geraete,this.Nutzer,this.Fotos});
    Nutzeinheit.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
        NeNummerInt = json['number'];
        Lage = json['location'];
        BegeReihenfolge = json['walkSequence'];
        Anmerkung = json['note'];
        AbrechnungseinheitGuid = json['abrechnungseinheitGuid'];
        Adresse = JsonConverters.fromJson(json['address'],'Address',context!);
        Geraete = JsonConverters.fromJson(json['devices'],'List<Device>',context!);
        Nutzer = JsonConverters.fromJson(json['nutzer'],'List<Nutzer>',context!);
        Fotos = JsonConverters.fromJson(json['photos'],'List<Photo>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
        'neNummerInt': NeNummerInt,
        'lage': Lage,
        'begeReihenfolge': BegeReihenfolge,
        'anmerkung': Anmerkung,
        'abrechnungseinheitGuid': AbrechnungseinheitGuid,
        'adresse': JsonConverters.toJson(Adresse,'Address',context!),
        'geraete': JsonConverters.toJson(Geraete,'List<Device>',context!),
        'nutzer': JsonConverters.toJson(Nutzer,'List<Nutzer>',context!),
        'fotos': JsonConverters.toJson(Fotos,'List<Photo>',context!)
    };

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

// @DataContract
class UpdateNutzeinheit extends Eras2AppServiceModelBase implements IConvertible
{
    // @DataMember(Name="Nutzeinheit")
    Nutzeinheit? Nutzeinheit;

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

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

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

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

TypeContext _ctx = TypeContext(library: 'stage_servamw.eras_online.de', types: <String, TypeInfo> {
    'Eras2AppServiceModelBase': TypeInfo(TypeOf.AbstractClass),
    'UpdateNutzeinheitResponse': TypeInfo(TypeOf.Class, create:() => UpdateNutzeinheitResponse()),
    'Address': TypeInfo(TypeOf.Class, create:() => Address()),
    'UnitKind': TypeInfo(TypeOf.Enum, enumValues:UnitKind.values),
    'EstimationKind': TypeInfo(TypeOf.Enum, enumValues:EstimationKind.values),
    'DeviceConsumptionState': TypeInfo(TypeOf.Enum, enumValues:DeviceConsumptionState.values),
    'DeviceConsumptionOrigin': TypeInfo(TypeOf.Enum, enumValues:DeviceConsumptionOrigin.values),
    'DeviceConsumption': TypeInfo(TypeOf.Class, create:() => DeviceConsumption()),
    'Photo': TypeInfo(TypeOf.Class, create:() => Photo()),
    'DeviceAdditionalArticle': TypeInfo(TypeOf.Class, create:() => DeviceAdditionalArticle()),
    'Device': TypeInfo(TypeOf.Class, create:() => Device()),
    'List<DeviceConsumption>': TypeInfo(TypeOf.Class, create:() => <DeviceConsumption>[]),
    'List<Photo>': TypeInfo(TypeOf.Class, create:() => <Photo>[]),
    'List<DeviceAdditionalArticle>': TypeInfo(TypeOf.Class, create:() => <DeviceAdditionalArticle>[]),
    'NutzerKind': TypeInfo(TypeOf.Enum, enumValues:NutzerKind.values),
    'NutzerCommunication': TypeInfo(TypeOf.Class, create:() => NutzerCommunication()),
    'NutzerPersonen': TypeInfo(TypeOf.Class, create:() => NutzerPersonen()),
    'NutzerCoOwnership': TypeInfo(TypeOf.Class, create:() => NutzerCoOwnership()),
    'NutzerQuadratmeter': TypeInfo(TypeOf.Class, create:() => NutzerQuadratmeter()),
    'Nutzer': TypeInfo(TypeOf.Class, create:() => Nutzer()),
    'List<NutzerCommunication>': TypeInfo(TypeOf.Class, create:() => <NutzerCommunication>[]),
    'List<NutzerPersonen>': TypeInfo(TypeOf.Class, create:() => <NutzerPersonen>[]),
    'List<NutzerCoOwnership>': TypeInfo(TypeOf.Class, create:() => <NutzerCoOwnership>[]),
    'List<NutzerQuadratmeter>': TypeInfo(TypeOf.Class, create:() => <NutzerQuadratmeter>[]),
    'Nutzeinheit': TypeInfo(TypeOf.Class, create:() => Nutzeinheit()),
    'List<Device>': TypeInfo(TypeOf.Class, create:() => <Device>[]),
    'List<Nutzer>': TypeInfo(TypeOf.Class, create:() => <Nutzer>[]),
    'UpdateNutzeinheit': TypeInfo(TypeOf.Class, create:() => UpdateNutzeinheit()),
});

Dart UpdateNutzeinheit DTOs

PUT /App/{UserId}/Nutzeinheit HTTP/1.1 
Host: stage-servamw.eras-online.de 
Accept: application/json
Content-Type: application/json
Content-Length: length

{"Nutzeinheit":{"Guid":"00000000000000000000000000000000","LastModified":"0001-01-01T00:00:00.0000000Z","NeNummerInt":"String","Lage":"String","BegeReihenfolge":"String","Anmerkung":"String","AbrechnungseinheitGuid":"00000000000000000000000000000000","Adresse":{"Guid":"00000000000000000000000000000000","Straße":"String","Straße2":"String","Hausnummer":"String","Postleitzahl":"String","Ort":"String","Postfach":"String","Adresszusatz":"String","Breitengrad":0,"Laengengrad":0}},"UserId":"00000000000000000000000000000000"}

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: length

{"responseStatus":{"errorCode":"String","message":"String","stackTrace":"String","errors":[{"errorCode":"String","fieldName":"String","message":"String","meta":{"String":"String"}}],"meta":{"String":"String"}}}