/* Options:
Date: 2026-02-04 14:00:41
Version: 8.90
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://taxfiling.pwc.de

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: HoleClientSideZertifikatEigenschaften.*
//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 information about a file or directory.
*/
// @Api(Description="Represents information about a file or directory.")
class FileMetadata implements IFileMetadata, IConvertible
{
    /**
    * The name of the file.For files, gets the name of the file.For directories, gets the name of the last directory in the hierarchy if a hierarchy exists; otherwise, the name of the directory.
    */
    // @ApiMember(Description="The name of the file.\nFor files, gets the name of the file.\nFor directories, gets the name of the last directory in the hierarchy if a hierarchy exists; otherwise, the name of the directory.")
    String? name;

    /**
    * The full path of the directory or file.
    */
    // @ApiMember(Description="The full path of the directory or file.")
    String? fullName;

    /**
    * The time the current file or directory was last accessed.
    */
    // @ApiMember(Description="The time the current file or directory was last accessed.")
    DateTime? lastAccessTime;

    /**
    * The name of the file.
    */
    // @ApiMember(Description="The name of the file.")
    DateTime? lastAccessTimeUtc;

    /**
    * The time when the current file or directory was last written to.
    */
    // @ApiMember(Description="The time when the current file or directory was last written to.")
    DateTime? lastWriteTime;

    /**
    * The time, in coordinated universal time (UTC), when the current file or directory was last written to.
    */
    // @ApiMember(Description="The time, in coordinated universal time (UTC), when the current file or directory was last written to.")
    DateTime? lastWriteTimeUtc;

    /**
    * The size, in bytes, of the current file.
    */
    // @ApiMember(Description="The size, in bytes, of the current file.")
    int? length;

    /**
    * The size, in bytes, of the current file.
    */
    // @ApiMember(Description="The size, in bytes, of the current file.")
    int? userId;

    /**
    * The file group id.
    */
    // @ApiMember(Description="The file group id.")
    int? groupId;

    /**
    * A value that indicates whether the others can read from this file.
    */
    // @ApiMember(Description="A value that indicates whether the others can read from this file.")
    bool? othersCanRead;

    /**
    * A value that indicates whether the group members can execute this file.
    */
    // @ApiMember(Description="A value that indicates whether the group members can execute this file.")
    bool? groupCanExecute;

    /**
    * A value that indicates whether the group members can write into this file.
    */
    // @ApiMember(Description="A value that indicates whether the group members can write into this file.")
    bool? groupCanWrite;

    /**
    * A value that indicates whether the group members can read from this file.
    */
    // @ApiMember(Description="A value that indicates whether the group members can read from this file.")
    bool? groupCanRead;

    /**
    * A value that indicates whether the owner can execute this file.
    */
    // @ApiMember(Description="A value that indicates whether the owner can execute this file.")
    bool? ownerCanExecute;

    /**
    * A value that indicates whether the owner can write into this file.
    */
    // @ApiMember(Description="A value that indicates whether the owner can write into this file.")
    bool? ownerCanWrite;

    /**
    * A value that indicates whether the owner can read from this file.
    */
    // @ApiMember(Description="A value that indicates whether the owner can read from this file.")
    bool? ownerCanRead;

    /**
    * A value that indicates whether others can read from this file.
    */
    // @ApiMember(Description="A value that indicates whether others can read from this file.")
    bool? othersCanExecute;

    /**
    * A value that indicates whether others can write into this file.
    */
    // @ApiMember(Description="A value that indicates whether others can write into this file.")
    bool? othersCanWrite;

    /**
    * Extensions to the file attributes.
    */
    // @ApiMember(Description="Extensions to the file attributes.")
    Map<String,String?>? extensions = {};

    FileMetadata({this.name,this.fullName,this.lastAccessTime,this.lastAccessTimeUtc,this.lastWriteTime,this.lastWriteTimeUtc,this.length,this.userId,this.groupId,this.othersCanRead,this.groupCanExecute,this.groupCanWrite,this.groupCanRead,this.ownerCanExecute,this.ownerCanWrite,this.ownerCanRead,this.othersCanExecute,this.othersCanWrite,this.extensions});
    FileMetadata.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        fullName = json['fullName'];
        lastAccessTime = JsonConverters.fromJson(json['lastAccessTime'],'DateTime',context!);
        lastAccessTimeUtc = JsonConverters.fromJson(json['lastAccessTimeUtc'],'DateTime',context!);
        lastWriteTime = JsonConverters.fromJson(json['lastWriteTime'],'DateTime',context!);
        lastWriteTimeUtc = JsonConverters.fromJson(json['lastWriteTimeUtc'],'DateTime',context!);
        length = json['length'];
        userId = json['userId'];
        groupId = json['groupId'];
        othersCanRead = json['othersCanRead'];
        groupCanExecute = json['groupCanExecute'];
        groupCanWrite = json['groupCanWrite'];
        groupCanRead = json['groupCanRead'];
        ownerCanExecute = json['ownerCanExecute'];
        ownerCanWrite = json['ownerCanWrite'];
        ownerCanRead = json['ownerCanRead'];
        othersCanExecute = json['othersCanExecute'];
        othersCanWrite = json['othersCanWrite'];
        extensions = JsonConverters.toStringMap(json['extensions']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'fullName': fullName,
        'lastAccessTime': JsonConverters.toJson(lastAccessTime,'DateTime',context!),
        'lastAccessTimeUtc': JsonConverters.toJson(lastAccessTimeUtc,'DateTime',context!),
        'lastWriteTime': JsonConverters.toJson(lastWriteTime,'DateTime',context!),
        'lastWriteTimeUtc': JsonConverters.toJson(lastWriteTimeUtc,'DateTime',context!),
        'length': length,
        'userId': userId,
        'groupId': groupId,
        'othersCanRead': othersCanRead,
        'groupCanExecute': groupCanExecute,
        'groupCanWrite': groupCanWrite,
        'groupCanRead': groupCanRead,
        'ownerCanExecute': ownerCanExecute,
        'ownerCanWrite': ownerCanWrite,
        'ownerCanRead': ownerCanRead,
        'othersCanExecute': othersCanExecute,
        'othersCanWrite': othersCanWrite,
        'extensions': extensions
    };

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

/**
* Represents a generic file that contains raw data content in bytes
*/
// @Api(Description="Represents a generic file that contains raw data content in bytes")
class BinaryFile extends FileBase implements IConvertible
{
    /**
    * The attributes of the file.
    */
    // @ApiMember(Description="The attributes of the file.")
    FileMetadata? metadata;

    /**
    * The name of the file without information on its directory path.
    */
    // @ApiMember(Description="The name of the file without information on its directory path.")
    String? name;

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

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

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

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

/**
* Represents a client-side generated certificate that is protected by a password.
*/
// @Api(Description="Represents a client-side generated certificate that is protected by a password.")
class ClientSideCertificate implements ISecuredCertificate, IConvertible
{
    /**
    * The friendly name of the certificate.
    */
    // @ApiMember(Description="The friendly name of the certificate.", IsRequired=true)
    String? name;

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

    /**
    * The file that contains the private key. Access is protected by the PIN.
    */
    // @ApiMember(Description="The file that contains the private key. Access is protected by the PIN.", IsRequired=true)
    BinaryFile? privateKeyFile;

    /**
    * The file that contains the certificate data and public key.
    */
    // @ApiMember(Description="The file that contains the certificate data and public key.", IsRequired=true)
    BinaryFile? publicKeyFile;

    /**
    * Contains the checksum of the files PublicKeyFile and PrivateKeyFile.
    */
    // @ApiMember(Description="Contains the checksum of the files PublicKeyFile and PrivateKeyFile.", IsRequired=true)
    BinaryFile? checksumFile;

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

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

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

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

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

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

/**
* A base service to get the properties of a specified client-side certificate.
*/
// @Api(Description="A base service to get the properties of a specified client-side certificate.")
abstract class HoleClientSideZertifikatEigenschaftenBase implements IPost
{
    /**
    * The client-side certificate. Access is protected by a PIN.
    */
    // @ApiMember(Description="The client-side certificate. Access is protected by a PIN.", Name="Zertifikat")
    ClientSideCertificate? zertifikat;

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

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

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

    getTypeName() => "HoleClientSideZertifikatEigenschaftenBase";
    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;
}

abstract class IFileMetadata
{
    String? name;
    String? fullName;
    DateTime? lastAccessTime;
    DateTime? lastAccessTimeUtc;
    DateTime? lastWriteTime;
    DateTime? lastWriteTimeUtc;
    int? length;
    int? userId;
    int? groupId;
    bool? groupCanExecute;
    bool? groupCanWrite;
    bool? groupCanRead;
    bool? ownerCanRead;
    bool? ownerCanExecute;
    bool? ownerCanWrite;
    bool? othersCanRead;
    bool? othersCanExecute;
    bool? othersCanWrite;
    Map<String,String?>? extensions;
}

/**
* 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 specified  client-side certificate.
*/
// @Route("/HoleClientSideZertifikatEigenschaften", "POST")
// @Api(Description="A synchronous service to get the properties of specified  client-side certificate.")
class HoleClientSideZertifikatEigenschaften extends HoleClientSideZertifikatEigenschaftenBase implements IReturn<HoleZertifikatEigenschaftenResponse>, IConvertible, IPost
{
    HoleClientSideZertifikatEigenschaften();
    HoleClientSideZertifikatEigenschaften.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() => "HoleClientSideZertifikatEigenschaften";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'taxfiling.pwc.de', types: <String, TypeInfo> {
    'FileBase': TypeInfo(TypeOf.AbstractClass),
    'Uint8List': TypeInfo(TypeOf.Class, create:() => Uint8List(0)),
    'FileMetadata': TypeInfo(TypeOf.Class, create:() => FileMetadata()),
    'BinaryFile': TypeInfo(TypeOf.Class, create:() => BinaryFile()),
    'ClientSideCertificate': TypeInfo(TypeOf.Class, create:() => ClientSideCertificate()),
    'HoleClientSideZertifikatEigenschaftenBase': 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),
    'IFileMetadata': TypeInfo(TypeOf.Interface),
    'EricFehlerCodeResponse': TypeInfo(TypeOf.Class, create:() => EricFehlerCodeResponse()),
    'EricFehlerCode': TypeInfo(TypeOf.Class, create:() => EricFehlerCode()),
    'HoleZertifikatEigenschaftenResponse': TypeInfo(TypeOf.Class, create:() => HoleZertifikatEigenschaftenResponse()),
    'HoleClientSideZertifikatEigenschaften': TypeInfo(TypeOf.Class, create:() => HoleClientSideZertifikatEigenschaften()),
});