/* Options:
Date: 2025-04-04 16:29:00
Version: 8.52
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://taxfiling.pwc.de

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

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

/**
* A base service to retrieve the list of all product and file versions of used ERiC-libraries.
*/
// @Api(Description="A base service to retrieve the list of all product and file versions of used ERiC-libraries.")
abstract class VersionCheckBase implements IGet
{
    VersionCheckBase();
    VersionCheckBase.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "VersionCheckBase";
    TypeContext? context = _ctx;
}

/**
* Represent a version of the internally used test module.
*/
// @Api(Description="Represent a version of the internally used test module.")
class PruefModul implements IConvertible
{
    /**
    * The tax data type version of the test module.
    */
    // @ApiMember(Description="The tax data type version of the test module.")
    String? datenartVersion;

    /**
    * The label of the test module.
    */
    // @ApiMember(Description="The label of the test module.")
    String? label;

    /**
    * The runtime of the test module.
    */
    // @ApiMember(Description="The runtime of the test module.")
    String? runtime;

    PruefModul({this.datenartVersion,this.label,this.runtime});
    PruefModul.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'datenartVersion': datenartVersion,
        'label': label,
        'runtime': runtime
    };

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

/**
* Represents Represents an ERiC dynamic library.
*/
// @Api(Description="Represents Represents an ERiC dynamic library.")
class Bibliothek implements IConvertible
{
    /**
    * The name of the library.
    */
    // @ApiMember(Description="The name of the library.")
    String? name;

    /**
    * The product version of the library.
    */
    // @ApiMember(Description="The product version of the library.")
    String? produktversion;

    /**
    * The file version of the library.
    */
    // @ApiMember(Description="The file version of the library.")
    String? dateiversion;

    /**
    * The list of test modules of the library.
    */
    // @ApiMember(Description="The list of test modules of the library.")
    List<PruefModul>? pruefModulen = [];

    Bibliothek({this.name,this.produktversion,this.dateiversion,this.pruefModulen});
    Bibliothek.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        produktversion = json['produktversion'];
        dateiversion = json['dateiversion'];
        pruefModulen = JsonConverters.fromJson(json['pruefModulen'],'List<PruefModul>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'produktversion': produktversion,
        'dateiversion': dateiversion,
        'pruefModulen': JsonConverters.toJson(pruefModulen,'List<PruefModul>',context!)
    };

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

/**
* Represents a structure that encapsulates a list of ERiC dynamic libraries.
*/
// @Api(Description="Represents a structure that encapsulates a list of ERiC dynamic libraries.")
class EricVersion implements IConvertible
{
    /**
    * The list of available ERiC dynamic libraries.
    */
    // @ApiMember(Description="The list of available ERiC dynamic libraries.")
    List<Bibliothek>? bibliotheken = [];

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

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

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

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

/**
* Represent a base response that encapsulate any ERiC API function return value.
*/
// @Api(Description="Represent a base response that encapsulate any ERiC API function return value.")
class EricFehlerCodeResponse extends ServiceReponseBase implements IConvertible
{
    /**
    * The status code that the ERiC API function returns.
    */
    // @ApiMember(Description="The status code that the ERiC API function returns.")
    EricFehlerCode? statusCode;

    /**
    * The status message that the ERiC API function returns.
    */
    // @ApiMember(Description="The status message that the ERiC API function returns.")
    String? statusText;

    EricFehlerCodeResponse({this.statusCode,this.statusText});
    EricFehlerCodeResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

/**
* Represents a type that encapsulates the versions of ERiC library components.
*/
// @Api(Description="Represents a type that encapsulates the versions of ERiC library components.")
class EricVersionResponse extends EricFehlerCodeResponse implements IConvertible
{
    /**
    * The version of an ERiC library component.
    */
    // @ApiMember(Description="The version of an ERiC library component.")
    EricVersion? rueckgabe;

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

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

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

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

/**
* An asynchronous service to retrieve the list of all product and file versions of used ERiC-libraries.
*/
// @Route("/VersionCheckAsync", "GET")
// @Api(Description="An asynchronous service to retrieve the list of all product and file versions of used ERiC-libraries.")
class VersionCheckAsync extends VersionCheckBase implements IReturn<EricVersionResponse>, IConvertible, IGet
{
    VersionCheckAsync();
    VersionCheckAsync.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    createResponse() => EricVersionResponse();
    getResponseTypeName() => "EricVersionResponse";
    getTypeName() => "VersionCheckAsync";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'taxfiling.pwc.de', types: <String, TypeInfo> {
    'VersionCheckBase': TypeInfo(TypeOf.AbstractClass),
    'PruefModul': TypeInfo(TypeOf.Class, create:() => PruefModul()),
    'Bibliothek': TypeInfo(TypeOf.Class, create:() => Bibliothek()),
    'List<PruefModul>': TypeInfo(TypeOf.Class, create:() => <PruefModul>[]),
    'EricVersion': TypeInfo(TypeOf.Class, create:() => EricVersion()),
    'List<Bibliothek>': TypeInfo(TypeOf.Class, create:() => <Bibliothek>[]),
    'EricFehlerCodeResponse': TypeInfo(TypeOf.Class, create:() => EricFehlerCodeResponse()),
    'EricFehlerCode': TypeInfo(TypeOf.Class, create:() => EricFehlerCode()),
    'EricVersionResponse': TypeInfo(TypeOf.Class, create:() => EricVersionResponse()),
    'VersionCheckAsync': TypeInfo(TypeOf.Class, create:() => VersionCheckAsync()),
});