/* Options:
Date: 2026-01-25 05:00:25
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: HolePortalZertifikatEigenschaften.*
//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;
}

/**
* A base service to get the properties of a specified portal certificate.
*/
// @Api(Description="A base service to get the properties of a specified portal certificate.")
abstract class HolePortalZertifikatEigenschaftenBase implements IPost
{
    /**
    * The portal certificate.
    */
    // @ApiMember(Description="The portal certificate.", Name="Zertifikat")
    PortalCertificate? zertifikat;

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

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

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

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

/**
* Represent issuer details of a certificate.
*/
// @Api(Description="Represent issuer details of a certificate.")
class Info implements IConvertible
{
    /**
    * The name of the issuer detail.
    */
    // @ApiMember(Description="The name of the issuer detail.")
    String? name;

    /**
    * The value of the issuer detail.
    */
    // @ApiMember(Description="The value of the issuer detail.")
    String? wert;

    Info({this.name,this.wert});
    Info.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

/**
* Represents an issuer of certificates.
*/
// @Api(Description="Represents an issuer of certificates.")
class Issuer implements IConvertible
{
    /**
    * Details about the issuer of certificates.
    */
    // @ApiMember(Description="Details about the issuer of certificates.")
    List<Info>? infos = [];

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

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

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

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

/**
* Represents the subject of the certificate.
*/
// @Api(Description="Represents the subject of the certificate.")
class Subjekt implements IConvertible
{
    /**
    * Details about the subject of the certificate.
    */
    // @ApiMember(Description="Details about the subject of the certificate.")
    List<Info>? infos = [];

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

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

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

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

/**
* Represents a type of Identification characteristic. Identification marker that was specified when the certificate was generated. For portal certificates usually tax number or identification number.
*/
enum Identifikationsmerkmaltyp
{
    Unbekannt,
    Steuernummer,
    Identifikationsnummer,
    BZStNummer,
    Bearbeiternummer,
    Clienterzeugt,
}

/**
* Represents a type of registrar. Contains informatiom on the type of person or organization, for which a certificate is issued. Often 'Person' or 'Organisation'.
*/
enum Registrierertyp
{
    Unbekannt,
    Person,
    Organisation,
    Rechteverwalter,
    BZStInland,
    BZStAusland,
    BZStKevizz,
}

/**
* Represents a type of verification. Contains information on the verification of a person or organisation by an issuer of certificates.
*/
enum VerifikationsartTyp
{
    Unbekannt,
    Postweg,
    Neuerpersonalausweis,
}

/**
* Represents a type of token.Contains information about the type of token used to create a certificate.
*/
enum TokenTyp
{
    Unbekannt,
    Software,
    Stick,
    Karte,
    Ausweis,
}

/**
* Represents the characteristics of a certificate.
*/
// @Api(Description="Represents the characteristics of a certificate.")
class Zertifikateigenschaften implements IConvertible
{
    /**
    * The start validity date of the certificate.
    */
    // @ApiMember(Description="The start validity date of the certificate.")
    DateTime? ausgestelltAm;

    /**
    * The expiry date of the certificate.
    */
    // @ApiMember(Description="The expiry date of the certificate.")
    DateTime? gueltigBis;

    /**
    * The signing algorithm and Object Identifier (for more information on OIDs, please see 'http://www.oid-info.com/')
    */
    // @ApiMember(Description="The signing algorithm and Object Identifier (for more information on OIDs, please see 'http://www.oid-info.com/')")
    String? signaturalgorithmus;

    /**
    * The MD5-hash of the public key.
    */
    // @ApiMember(Description="The MD5-hash of the public key.")
    String? publicKeyMD5;

    /**
    * The SHA1-hash of the public key.
    */
    // @ApiMember(Description="The SHA1-hash of the public key.")
    String? publicKeySHA1;

    /**
    * The key length of the public key in units of bits. For example '2048 bits'
    */
    // @ApiMember(Description="The key length of the public key in units of bits. For example '2048 bits'")
    int? publicKeyBitLength;

    /**
    * The issuer of the certificate.
    */
    // @ApiMember(Description="The issuer of the certificate.")
    Issuer? issuer;

    /**
    * The subject of the certificate.
    */
    // @ApiMember(Description="The subject of the certificate.")
    Subjekt? subjekt;

    /**
    * The identification characteristics of the certificate.
    */
    // @ApiMember(Description="The identification characteristics of the certificate.")
    Identifikationsmerkmaltyp? identifikationsmerkmaltyp;

    /**
    * The type of registrar, to which the key is issued.
    */
    // @ApiMember(Description="The type of registrar, to which the key is issued.")
    Registrierertyp? registrierertyp;

    /**
    * The type of verification conducted for the person or organisation, to which the certificate is issued.
    */
    // @ApiMember(Description="The type of verification conducted for the person or organisation, to which the certificate is issued.")
    VerifikationsartTyp? verifikationsart;

    /**
    * The type of token used to create the certificate.
    */
    // @ApiMember(Description="The type of token used to create the certificate.")
    TokenTyp? tokenTyp;

    /**
    * Is the certificate is a test certificate? True if it is a test certificate; otherwise false.
    */
    // @ApiMember(Description="Is the certificate is a test certificate? True if it is a test certificate; otherwise false.")
    bool? testzertifikat;

    Zertifikateigenschaften({this.ausgestelltAm,this.gueltigBis,this.signaturalgorithmus,this.publicKeyMD5,this.publicKeySHA1,this.publicKeyBitLength,this.issuer,this.subjekt,this.identifikationsmerkmaltyp,this.registrierertyp,this.verifikationsart,this.tokenTyp,this.testzertifikat});
    Zertifikateigenschaften.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ausgestelltAm = JsonConverters.fromJson(json['ausgestelltAm'],'DateTime',context!);
        gueltigBis = JsonConverters.fromJson(json['gueltigBis'],'DateTime',context!);
        signaturalgorithmus = json['signaturalgorithmus'];
        publicKeyMD5 = json['publicKeyMD5'];
        publicKeySHA1 = json['publicKeySHA1'];
        publicKeyBitLength = json['publicKeyBitLength'];
        issuer = JsonConverters.fromJson(json['issuer'],'Issuer',context!);
        subjekt = JsonConverters.fromJson(json['subjekt'],'Subjekt',context!);
        identifikationsmerkmaltyp = JsonConverters.fromJson(json['identifikationsmerkmaltyp'],'Identifikationsmerkmaltyp',context!);
        registrierertyp = JsonConverters.fromJson(json['registrierertyp'],'Registrierertyp',context!);
        verifikationsart = JsonConverters.fromJson(json['verifikationsart'],'VerifikationsartTyp',context!);
        tokenTyp = JsonConverters.fromJson(json['tokenTyp'],'TokenTyp',context!);
        testzertifikat = json['testzertifikat'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ausgestelltAm': JsonConverters.toJson(ausgestelltAm,'DateTime',context!),
        'gueltigBis': JsonConverters.toJson(gueltigBis,'DateTime',context!),
        'signaturalgorithmus': signaturalgorithmus,
        'publicKeyMD5': publicKeyMD5,
        'publicKeySHA1': publicKeySHA1,
        'publicKeyBitLength': publicKeyBitLength,
        'issuer': JsonConverters.toJson(issuer,'Issuer',context!),
        'subjekt': JsonConverters.toJson(subjekt,'Subjekt',context!),
        'identifikationsmerkmaltyp': JsonConverters.toJson(identifikationsmerkmaltyp,'Identifikationsmerkmaltyp',context!),
        'registrierertyp': JsonConverters.toJson(registrierertyp,'Registrierertyp',context!),
        'verifikationsart': JsonConverters.toJson(verifikationsart,'VerifikationsartTyp',context!),
        'tokenTyp': JsonConverters.toJson(tokenTyp,'TokenTyp',context!),
        'testzertifikat': testzertifikat
    };

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

/**
* Represents a list of properties for a specified certificate.
*/
// @Api(Description="Represents a list of properties for a specified certificate.")
class EricHoleZertifikatEigenschaften implements IConvertible
{
    /**
    * The properties of the certificate used for signing. These are not available for client-side certificates.
    */
    // @ApiMember(Description="The properties of the certificate used for signing. These are not available for client-side certificates.")
    Zertifikateigenschaften? signaturzertifikateigenschaften;

    /**
    * The properties of certificates used for encryption.
    */
    // @ApiMember(Description="The properties of certificates used for encryption.")
    Zertifikateigenschaften? verschluesselungszertifikateigenschaften;

    EricHoleZertifikatEigenschaften({this.signaturzertifikateigenschaften,this.verschluesselungszertifikateigenschaften});
    EricHoleZertifikatEigenschaften.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'signaturzertifikateigenschaften': JsonConverters.toJson(signaturzertifikateigenschaften,'Zertifikateigenschaften',context!),
        'verschluesselungszertifikateigenschaften': JsonConverters.toJson(verschluesselungszertifikateigenschaften,'Zertifikateigenschaften',context!)
    };

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

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 the return values of the ERiC API function, which retrieves the details of a certificate.
*/
// @Api(Description="Represents a type that encapsulates the return values of the ERiC API function, which retrieves the details of a certificate.")
class HoleZertifikatEigenschaftenResponse extends EricFehlerCodeResponse implements IConvertible
{
    /**
    * The list of test fiscal authoririties.
    */
    // @ApiMember(Description="The list of test fiscal authoririties.")
    EricHoleZertifikatEigenschaften? rueckgabe;

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

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

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

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

/**
* A synchronous service to get the properties of a specified portal certificate.
*/
// @Route("/HolePortalZertifikatEigenschaften", "POST")
// @Api(Description="A synchronous service to get the properties of a specified portal certificate.")
class HolePortalZertifikatEigenschaften extends HolePortalZertifikatEigenschaftenBase implements IReturn<HoleZertifikatEigenschaftenResponse>, IConvertible, IPost
{
    HolePortalZertifikatEigenschaften();
    HolePortalZertifikatEigenschaften.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() => HoleZertifikatEigenschaftenResponse();
    getResponseTypeName() => "HoleZertifikatEigenschaftenResponse";
    getTypeName() => "HolePortalZertifikatEigenschaften";
    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()),
    'HolePortalZertifikatEigenschaftenBase': TypeInfo(TypeOf.AbstractClass),
    'Info': TypeInfo(TypeOf.Class, create:() => Info()),
    'Issuer': TypeInfo(TypeOf.Class, create:() => Issuer()),
    'List<Info>': TypeInfo(TypeOf.Class, create:() => <Info>[]),
    'Subjekt': TypeInfo(TypeOf.Class, create:() => Subjekt()),
    'Identifikationsmerkmaltyp': TypeInfo(TypeOf.Enum, enumValues:Identifikationsmerkmaltyp.values),
    'Registrierertyp': TypeInfo(TypeOf.Enum, enumValues:Registrierertyp.values),
    'VerifikationsartTyp': TypeInfo(TypeOf.Enum, enumValues:VerifikationsartTyp.values),
    'TokenTyp': TypeInfo(TypeOf.Enum, enumValues:TokenTyp.values),
    'Zertifikateigenschaften': TypeInfo(TypeOf.Class, create:() => Zertifikateigenschaften()),
    'EricHoleZertifikatEigenschaften': TypeInfo(TypeOf.Class, create:() => EricHoleZertifikatEigenschaften()),
    'ISecuredCertificate': TypeInfo(TypeOf.Interface),
    'EricFehlerCodeResponse': TypeInfo(TypeOf.Class, create:() => EricFehlerCodeResponse()),
    'EricFehlerCode': TypeInfo(TypeOf.Class, create:() => EricFehlerCode()),
    'HoleZertifikatEigenschaftenResponse': TypeInfo(TypeOf.Class, create:() => HoleZertifikatEigenschaftenResponse()),
    'HolePortalZertifikatEigenschaften': TypeInfo(TypeOf.Class, create:() => HolePortalZertifikatEigenschaften()),
});