/* Options:
Date: 2026-01-25 18:51:36
Version: 8.90
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://taxfiling.staging.pwc.de

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

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

/**
* Represents a base class for a file with raw data.
*/
// @Api(Description="Represents a base class for a file with raw data.")
abstract class FileBase
{
    /**
    * The raw data content of the file in bytes.
    */
    // @ApiMember(Description="The raw data content of the file in bytes.", Name="Content")
    Uint8List? content;

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

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

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

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

/**
* Represents a portal certificate that is protected by a password.
*/
// @Api(Description="Represents a portal certificate that is protected by a password.")
class PortalCertificate extends FileBase implements ISecuredCertificate, IConvertible
{
    /**
    * The file name of the certificate.
    */
    // @ApiMember(Description="The file name of the certificate.")
    // @StringLength(128)
    String? name;

    /**
    * The password to protect the certificate from unauthorized access.
    */
    // @StringLength(255)
    // @ApiMember(Description="The password to protect the certificate from unauthorized access.")
    String? pin;

    /**
    * The description of the certificate.
    */
    // @StringLength(2147483647)
    // @ApiMember(Description="The description of the certificate.")
    String? description;

    /**
    * Tags that can be used to label or identify the certificate.
    */
    // @ApiMember(Description="Tags that can be used to label or identify the certificate.")
    List<String>? tags = [];

    PortalCertificate({this.name,this.pin,this.description,this.tags});
    PortalCertificate.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        name = json['name'];
        pin = json['pin'];
        description = json['description'];
        tags = JsonConverters.fromJson(json['tags'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'name': name,
        'pin': pin,
        'description': description,
        'tags': JsonConverters.toJson(tags,'List<String>',context!)
    });

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

class Base64EingabeData implements IHasIndex, IConvertible
{
    String? id;
    String? base64Eingabe;
    int? index;

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

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

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

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

/**
* A base service to decrypt data using a specified portal certificate.
*/
// @Api(Description="A base service to decrypt data using a specified portal certificate.")
abstract class DekodiereDatenBase implements IPost
{
    /**
    * The authentification certificate.
    */
    // @ApiMember(Description="The authentification certificate.")
    PortalCertificate? zertifikat;

    /**
    * The base-64-encrypted data that is retrieved with the 'ElsterDatenabholung' operation.It is usually located under the element /Elster/DatenTeil/Nutzdatenblock/Nutzdaten/Datenabholung/Abholung/Datenpaket of the ELSTER document.
    */
    // @ApiMember(Description="The base-64-encrypted data that is retrieved with the 'ElsterDatenabholung' operation.It is usually located under the element /Elster/DatenTeil/Nutzdatenblock/Nutzdaten/Datenabholung/Abholung/Datenpaket of the ELSTER document.")
    Base64EingabeData? data;

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

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

    Map<String, dynamic> toJson() => {
        'zertifikat': JsonConverters.toJson(zertifikat,'PortalCertificate',context!),
        'data': JsonConverters.toJson(data,'Base64EingabeData',context!)
    };

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

abstract class IHasIndex
{
    int? index;
}

abstract class ISecuredCertificate
{
    String? pin;
}

/**
* 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 a decoded value.
*/
// @Api(Description="Represents a type that encapsulates a decoded value.")
class DekodiereDatenResponse extends EricFehlerCodeResponse implements IConvertible
{
    /**
    * The decoded value.
    */
    // @ApiMember(Description="The decoded value.")
    String? rueckgabe;

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

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

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

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

/**
* An asynchronous service to decrypt a batch of data using a specified portal certificate.
*/
// @Route("/DekodiereDatenAsync", "POST")
// @Api(Description="An asynchronous service to decrypt a batch of data using a specified portal certificate.")
class DekodiereDatenAsync extends DekodiereDatenBase implements IReturn<DekodiereDatenResponse>, IConvertible, IPost
{
    DekodiereDatenAsync();
    DekodiereDatenAsync.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() => DekodiereDatenResponse();
    getResponseTypeName() => "DekodiereDatenResponse";
    getTypeName() => "DekodiereDatenAsync";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'taxfiling.staging.pwc.de', types: <String, TypeInfo> {
    'FileBase': TypeInfo(TypeOf.AbstractClass),
    'Uint8List': TypeInfo(TypeOf.Class, create:() => Uint8List(0)),
    'PortalCertificate': TypeInfo(TypeOf.Class, create:() => PortalCertificate()),
    'Base64EingabeData': TypeInfo(TypeOf.Class, create:() => Base64EingabeData()),
    'DekodiereDatenBase': TypeInfo(TypeOf.AbstractClass),
    'IHasIndex': TypeInfo(TypeOf.Interface),
    'ISecuredCertificate': TypeInfo(TypeOf.Interface),
    'EricFehlerCodeResponse': TypeInfo(TypeOf.Class, create:() => EricFehlerCodeResponse()),
    'EricFehlerCode': TypeInfo(TypeOf.Class, create:() => EricFehlerCode()),
    'DekodiereDatenResponse': TypeInfo(TypeOf.Class, create:() => DekodiereDatenResponse()),
    'DekodiereDatenAsync': TypeInfo(TypeOf.Class, create:() => DekodiereDatenAsync()),
});