/* Options:
Date: 2026-06-01 15:36:38
Version: 8.22
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://imzagerservices.eyyubiye.bel.tr

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

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

enum EYPGuvenlikKodu
{
    YOK,
    TSD,
    HZO,
    OZL,
    GZL,
    CGZ,
    KSO,
}

enum EYPIvedilik
{
    NRM,
    ACL,
    GNL,
    IVD,
    CIV,
}

enum EYPDagitimTuru
{
    GRG,
    BLG,
}

class EYPKonulmamisEk implements IConvertible
{
    String? EkId;

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

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

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

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

enum EYPKisiType
{
    GercekSahis,
    TuzelSahis,
    KurumKurulus,
}

class EYPKisi implements IConvertible
{
    String? IlkAdi;
    String? Soyadi;
    String? IkinciAdi;
    String? Unvan;
    String? OnEk;

    EYPKisi({this.IlkAdi,this.Soyadi,this.IkinciAdi,this.Unvan,this.OnEk});
    EYPKisi.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        IlkAdi = json['IlkAdi'];
        Soyadi = json['Soyadi'];
        IkinciAdi = json['IkinciAdi'];
        Unvan = json['Unvan'];
        OnEk = json['OnEk'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'IlkAdi': IlkAdi,
        'Soyadi': Soyadi,
        'IkinciAdi': IkinciAdi,
        'Unvan': Unvan,
        'OnEk': OnEk
    };

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

class EYPIletisimBilgisi implements IConvertible
{
    String? Telefon;
    String? TelefonDiger;
    String? EPosta;
    String? Faks;
    String? WebAdresi;
    String? Adres;
    String? Il;
    String? Ilce;
    String? Ulke;
    String? KepAdresi;

    EYPIletisimBilgisi({this.Telefon,this.TelefonDiger,this.EPosta,this.Faks,this.WebAdresi,this.Adres,this.Il,this.Ilce,this.Ulke,this.KepAdresi});
    EYPIletisimBilgisi.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Telefon = json['Telefon'];
        TelefonDiger = json['TelefonDiger'];
        EPosta = json['EPosta'];
        Faks = json['Faks'];
        WebAdresi = json['WebAdresi'];
        Adres = json['Adres'];
        Il = json['Il'];
        Ilce = json['Ilce'];
        Ulke = json['Ulke'];
        KepAdresi = json['KepAdresi'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Telefon': Telefon,
        'TelefonDiger': TelefonDiger,
        'EPosta': EPosta,
        'Faks': Faks,
        'WebAdresi': WebAdresi,
        'Adres': Adres,
        'Il': Il,
        'Ilce': Ilce,
        'Ulke': Ulke,
        'KepAdresi': KepAdresi
    };

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

class EYPGercekSahis implements IConvertible
{
    EYPKisi? Kisi;
    String? TCKN;
    String? Gorev;
    EYPIletisimBilgisi? IletisimBilgisi;

    EYPGercekSahis({this.Kisi,this.TCKN,this.Gorev,this.IletisimBilgisi});
    EYPGercekSahis.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Kisi = JsonConverters.fromJson(json['Kisi'],'EYPKisi',context!);
        TCKN = json['TCKN'];
        Gorev = json['Gorev'];
        IletisimBilgisi = JsonConverters.fromJson(json['IletisimBilgisi'],'EYPIletisimBilgisi',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Kisi': JsonConverters.toJson(Kisi,'EYPKisi',context!),
        'TCKN': TCKN,
        'Gorev': Gorev,
        'IletisimBilgisi': JsonConverters.toJson(IletisimBilgisi,'EYPIletisimBilgisi',context!)
    };

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

class EYPTuzelSahis implements IConvertible
{
    String? Id;
    String? Adi;
    EYPIletisimBilgisi? IletisimBilgisi;

    EYPTuzelSahis({this.Id,this.Adi,this.IletisimBilgisi});
    EYPTuzelSahis.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Adi': Adi,
        'IletisimBilgisi': JsonConverters.toJson(IletisimBilgisi,'EYPIletisimBilgisi',context!)
    };

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

class EYPKurumKurulus implements IConvertible
{
    String? KKK;
    String? Adi;
    String? BirimKKK;
    EYPIletisimBilgisi? IletisimBilgisi;

    EYPKurumKurulus({this.KKK,this.Adi,this.BirimKKK,this.IletisimBilgisi});
    EYPKurumKurulus.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        KKK = json['KKK'];
        Adi = json['Adi'];
        BirimKKK = json['BirimKKK'];
        IletisimBilgisi = JsonConverters.fromJson(json['IletisimBilgisi'],'EYPIletisimBilgisi',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'KKK': KKK,
        'Adi': Adi,
        'BirimKKK': BirimKKK,
        'IletisimBilgisi': JsonConverters.toJson(IletisimBilgisi,'EYPIletisimBilgisi',context!)
    };

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

class EYPDagitim implements IConvertible
{
    EYPIvedilik? Ivedilik;
    EYPDagitimTuru? DagitimTuru;
    String? Miat;
    List<EYPKonulmamisEk>? KonulmamisEkListesi;
    EYPKisiType? DagitimTipi;
    EYPGercekSahis? GercekSahis;
    EYPTuzelSahis? TuzelSahis;
    EYPKurumKurulus? KurumKurulus;

    EYPDagitim({this.Ivedilik,this.DagitimTuru,this.Miat,this.KonulmamisEkListesi,this.DagitimTipi,this.GercekSahis,this.TuzelSahis,this.KurumKurulus});
    EYPDagitim.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Ivedilik = JsonConverters.fromJson(json['Ivedilik'],'EYPIvedilik',context!);
        DagitimTuru = JsonConverters.fromJson(json['DagitimTuru'],'EYPDagitimTuru',context!);
        Miat = json['Miat'];
        KonulmamisEkListesi = JsonConverters.fromJson(json['KonulmamisEkListesi'],'List<EYPKonulmamisEk>',context!);
        DagitimTipi = JsonConverters.fromJson(json['DagitimTipi'],'EYPKisiType',context!);
        GercekSahis = JsonConverters.fromJson(json['GercekSahis'],'EYPGercekSahis',context!);
        TuzelSahis = JsonConverters.fromJson(json['TuzelSahis'],'EYPTuzelSahis',context!);
        KurumKurulus = JsonConverters.fromJson(json['KurumKurulus'],'EYPKurumKurulus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Ivedilik': JsonConverters.toJson(Ivedilik,'EYPIvedilik',context!),
        'DagitimTuru': JsonConverters.toJson(DagitimTuru,'EYPDagitimTuru',context!),
        'Miat': Miat,
        'KonulmamisEkListesi': JsonConverters.toJson(KonulmamisEkListesi,'List<EYPKonulmamisEk>',context!),
        'DagitimTipi': JsonConverters.toJson(DagitimTipi,'EYPKisiType',context!),
        'GercekSahis': JsonConverters.toJson(GercekSahis,'EYPGercekSahis',context!),
        'TuzelSahis': JsonConverters.toJson(TuzelSahis,'EYPTuzelSahis',context!),
        'KurumKurulus': JsonConverters.toJson(KurumKurulus,'EYPKurumKurulus',context!)
    };

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

enum EYPEkTuru
{
    DED,
    HRF,
    FZK,
}

class EYPEkOzet implements IConvertible
{
    String? OzetAlgoritmasi;
    Uint8List? OzetDegeri;

    EYPEkOzet({this.OzetAlgoritmasi,this.OzetDegeri});
    EYPEkOzet.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

enum EYPEkOzetModu
{
    Yok,
    SHA1,
    SHA512,
    RIPEMD160,
    SHA256,
}

class EYPEk implements IConvertible
{
    String? Id;
    String? BelgeNo;
    EYPEkTuru? EkTuru;
    String? DosyaAdi;
    String? MimeTuru;
    String? Ad;
    String? SiraNo;
    String? Aciklama;
    String? Referans;
    bool? ImzaliMi;
    bool? ImzaliMiBelirliMi;
    EYPEkOzet? Ozet;
    Uint8List? Icerik;
    EYPEkOzetModu? OzetModu;
    String? OzetId;

    EYPEk({this.Id,this.BelgeNo,this.EkTuru,this.DosyaAdi,this.MimeTuru,this.Ad,this.SiraNo,this.Aciklama,this.Referans,this.ImzaliMi,this.ImzaliMiBelirliMi,this.Ozet,this.Icerik,this.OzetModu,this.OzetId});
    EYPEk.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        BelgeNo = json['BelgeNo'];
        EkTuru = JsonConverters.fromJson(json['EkTuru'],'EYPEkTuru',context!);
        DosyaAdi = json['DosyaAdi'];
        MimeTuru = json['MimeTuru'];
        Ad = json['Ad'];
        SiraNo = json['SiraNo'];
        Aciklama = json['Aciklama'];
        Referans = json['Referans'];
        ImzaliMi = json['ImzaliMi'];
        ImzaliMiBelirliMi = json['ImzaliMiBelirliMi'];
        Ozet = JsonConverters.fromJson(json['Ozet'],'EYPEkOzet',context!);
        Icerik = JsonConverters.fromJson(json['Icerik'],'Uint8List',context!);
        OzetModu = JsonConverters.fromJson(json['OzetModu'],'EYPEkOzetModu',context!);
        OzetId = json['OzetId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'BelgeNo': BelgeNo,
        'EkTuru': JsonConverters.toJson(EkTuru,'EYPEkTuru',context!),
        'DosyaAdi': DosyaAdi,
        'MimeTuru': MimeTuru,
        'Ad': Ad,
        'SiraNo': SiraNo,
        'Aciklama': Aciklama,
        'Referans': Referans,
        'ImzaliMi': ImzaliMi,
        'ImzaliMiBelirliMi': ImzaliMiBelirliMi,
        'Ozet': JsonConverters.toJson(Ozet,'EYPEkOzet',context!),
        'Icerik': JsonConverters.toJson(Icerik,'Uint8List',context!),
        'OzetModu': JsonConverters.toJson(OzetModu,'EYPEkOzetModu',context!),
        'OzetId': OzetId
    };

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

class EYPIlgi implements IConvertible
{
    String? Id;
    String? BelgeNo;
    DateTime? Tarih;
    bool? TarihBelirliMi;
    String? Etiket;
    String? EkId;
    String? Ad;
    String? Aciklama;
    String? OzId;
    bool? EYazismaIdMi;
    bool? EYazismaIdBelirliMi;

    EYPIlgi({this.Id,this.BelgeNo,this.Tarih,this.TarihBelirliMi,this.Etiket,this.EkId,this.Ad,this.Aciklama,this.OzId,this.EYazismaIdMi,this.EYazismaIdBelirliMi});
    EYPIlgi.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        BelgeNo = json['BelgeNo'];
        Tarih = JsonConverters.fromJson(json['Tarih'],'DateTime',context!);
        TarihBelirliMi = json['TarihBelirliMi'];
        Etiket = json['Etiket'];
        EkId = json['EkId'];
        Ad = json['Ad'];
        Aciklama = json['Aciklama'];
        OzId = json['OzId'];
        EYazismaIdMi = json['EYazismaIdMi'];
        EYazismaIdBelirliMi = json['EYazismaIdBelirliMi'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'BelgeNo': BelgeNo,
        'Tarih': JsonConverters.toJson(Tarih,'DateTime',context!),
        'TarihBelirliMi': TarihBelirliMi,
        'Etiket': Etiket,
        'EkId': EkId,
        'Ad': Ad,
        'Aciklama': Aciklama,
        'OzId': OzId,
        'EYazismaIdMi': EYazismaIdMi,
        'EYazismaIdBelirliMi': EYazismaIdBelirliMi
    };

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

class EYPOlusturan implements IConvertible
{
    EYPKisiType? OlusturanTipi;
    EYPGercekSahis? GercekSahis;
    EYPTuzelSahis? TuzelSahis;
    EYPKurumKurulus? KurumKurulus;

    EYPOlusturan({this.OlusturanTipi,this.GercekSahis,this.TuzelSahis,this.KurumKurulus});
    EYPOlusturan.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        OlusturanTipi = JsonConverters.fromJson(json['OlusturanTipi'],'EYPKisiType',context!);
        GercekSahis = JsonConverters.fromJson(json['GercekSahis'],'EYPGercekSahis',context!);
        TuzelSahis = JsonConverters.fromJson(json['TuzelSahis'],'EYPTuzelSahis',context!);
        KurumKurulus = JsonConverters.fromJson(json['KurumKurulus'],'EYPKurumKurulus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'OlusturanTipi': JsonConverters.toJson(OlusturanTipi,'EYPKisiType',context!),
        'GercekSahis': JsonConverters.toJson(GercekSahis,'EYPGercekSahis',context!),
        'TuzelSahis': JsonConverters.toJson(TuzelSahis,'EYPTuzelSahis',context!),
        'KurumKurulus': JsonConverters.toJson(KurumKurulus,'EYPKurumKurulus',context!)
    };

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

class EYPIlgili implements IConvertible
{
    EYPKisiType? IlgiliTipi;
    EYPGercekSahis? GercekSahis;
    EYPTuzelSahis? TuzelSahis;
    EYPKurumKurulus? KurumKurulus;

    EYPIlgili({this.IlgiliTipi,this.GercekSahis,this.TuzelSahis,this.KurumKurulus});
    EYPIlgili.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        IlgiliTipi = JsonConverters.fromJson(json['IlgiliTipi'],'EYPKisiType',context!);
        GercekSahis = JsonConverters.fromJson(json['GercekSahis'],'EYPGercekSahis',context!);
        TuzelSahis = JsonConverters.fromJson(json['TuzelSahis'],'EYPTuzelSahis',context!);
        KurumKurulus = JsonConverters.fromJson(json['KurumKurulus'],'EYPKurumKurulus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'IlgiliTipi': JsonConverters.toJson(IlgiliTipi,'EYPKisiType',context!),
        'GercekSahis': JsonConverters.toJson(GercekSahis,'EYPGercekSahis',context!),
        'TuzelSahis': JsonConverters.toJson(TuzelSahis,'EYPTuzelSahis',context!),
        'KurumKurulus': JsonConverters.toJson(KurumKurulus,'EYPKurumKurulus',context!)
    };

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

class EYPImza implements IConvertible
{
    EYPGercekSahis? Imzalayan;
    EYPGercekSahis? YetkiDevreden;
    EYPGercekSahis? VekaletVeren;
    String? Makam;
    String? Amac;
    String? Aciklama;
    DateTime? Tarih;
    String? TCYK;
    bool? TarihBelirli;

    EYPImza({this.Imzalayan,this.YetkiDevreden,this.VekaletVeren,this.Makam,this.Amac,this.Aciklama,this.Tarih,this.TCYK,this.TarihBelirli});
    EYPImza.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Imzalayan = JsonConverters.fromJson(json['Imzalayan'],'EYPGercekSahis',context!);
        YetkiDevreden = JsonConverters.fromJson(json['YetkiDevreden'],'EYPGercekSahis',context!);
        VekaletVeren = JsonConverters.fromJson(json['VekaletVeren'],'EYPGercekSahis',context!);
        Makam = json['Makam'];
        Amac = json['Amac'];
        Aciklama = json['Aciklama'];
        Tarih = JsonConverters.fromJson(json['Tarih'],'DateTime',context!);
        TCYK = json['TCYK'];
        TarihBelirli = json['TarihBelirli'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Imzalayan': JsonConverters.toJson(Imzalayan,'EYPGercekSahis',context!),
        'YetkiDevreden': JsonConverters.toJson(YetkiDevreden,'EYPGercekSahis',context!),
        'VekaletVeren': JsonConverters.toJson(VekaletVeren,'EYPGercekSahis',context!),
        'Makam': Makam,
        'Amac': Amac,
        'Aciklama': Aciklama,
        'Tarih': JsonConverters.toJson(Tarih,'DateTime',context!),
        'TCYK': TCYK,
        'TarihBelirli': TarihBelirli
    };

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

class AnaSdp implements IConvertible
{
    String? Kod;
    String? Ad;
    String? Aciklama;

    AnaSdp({this.Kod,this.Ad,this.Aciklama});
    AnaSdp.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Kod = json['Kod'];
        Ad = json['Ad'];
        Aciklama = json['Aciklama'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Kod': Kod,
        'Ad': Ad,
        'Aciklama': Aciklama
    };

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

class SdpListesi implements IConvertible
{
    String? Kod;
    String? Ad;
    String? Aciklama;

    SdpListesi({this.Kod,this.Ad,this.Aciklama});
    SdpListesi.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Kod = json['Kod'];
        Ad = json['Ad'];
        Aciklama = json['Aciklama'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Kod': Kod,
        'Ad': Ad,
        'Aciklama': Aciklama
    };

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

class DigerSdpler implements IConvertible
{
    List<SdpListesi>? SdpListesi;

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

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

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

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

class SdpBilgisi implements IConvertible
{
    AnaSdp? AnaSdp;
    DigerSdpler? DigerSdpler;

    SdpBilgisi({this.AnaSdp,this.DigerSdpler});
    SdpBilgisi.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class Heysk implements IConvertible
{
    int? Kod;
    String? Ad;
    String? Tanim;

    Heysk({this.Kod,this.Ad,this.Tanim});
    Heysk.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Kod = json['Kod'];
        Ad = json['Ad'];
        Tanim = json['Tanim'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Kod': Kod,
        'Ad': Ad,
        'Tanim': Tanim
    };

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

class VerifyDocumentDetails implements IConvertible
{
    Uint8List? DocumentContent;
    String? DocumentName;
    String? DocumentType;
    String? DocumentKey;

    VerifyDocumentDetails({this.DocumentContent,this.DocumentName,this.DocumentType,this.DocumentKey});
    VerifyDocumentDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class TSValidationResultItem implements IConvertible
{
    String? ID;
    String? Message;
    String? Result;
    bool? Successed;
    List<TSValidationResultItem>? Child;

    TSValidationResultItem({this.ID,this.Message,this.Result,this.Successed,this.Child});
    TSValidationResultItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        Message = json['Message'];
        Result = json['Result'];
        Successed = json['Successed'];
        Child = JsonConverters.fromJson(json['Child'],'List<TSValidationResultItem>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Message': Message,
        'Result': Result,
        'Successed': Successed,
        'Child': JsonConverters.toJson(Child,'List<TSValidationResultItem>',context!)
    };

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

class SgValidationResultItem implements IConvertible
{
    String? ID;
    String? Message;
    String? Result;
    bool? Successed;
    SgValidationResultItem? Child;

    SgValidationResultItem({this.ID,this.Message,this.Result,this.Successed,this.Child});
    SgValidationResultItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        Message = json['Message'];
        Result = json['Result'];
        Successed = json['Successed'];
        Child = JsonConverters.fromJson(json['Child'],'SgValidationResultItem',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Message': Message,
        'Result': Result,
        'Successed': Successed,
        'Child': JsonConverters.toJson(Child,'SgValidationResultItem',context!)
    };

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

class CertValidationResultItem implements IConvertible
{
    String? ID;
    String? Message;
    String? Result;
    bool? Successed;
    CertValidationResultItem? Child;

    CertValidationResultItem({this.ID,this.Message,this.Result,this.Successed,this.Child});
    CertValidationResultItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ID = json['ID'];
        Message = json['Message'];
        Result = json['Result'];
        Successed = json['Successed'];
        Child = JsonConverters.fromJson(json['Child'],'CertValidationResultItem',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ID': ID,
        'Message': Message,
        'Result': Result,
        'Successed': Successed,
        'Child': JsonConverters.toJson(Child,'CertValidationResultItem',context!)
    };

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

class VerifySignerDetails implements IConvertible
{
    String? Cert_SubjectCN;
    String? ID;
    X509Certificate2? SignerCertificate;
    String? SignType;
    String? SignAlgorithm;
    String? HashAlgorithm;
    bool? SignStatusIsValid;
    String? CertStatusValue;
    DateTime? SigningTime;
    bool? IsTimeStampExist;
    VerifySignerDetails? NextSigner;
    List<VerifySignerDetails>? CounterSigners;
    List<TSValidationResultItem>? TimeStampDetails;
    List<SgValidationResultItem>? SignValidationDetails;
    List<CertValidationResultItem>? CertValidationDetails;
    String? Cert_SubjectSN;
    String? Cert_Issuer;
    DateTime? Cert_ValidFrom;
    DateTime? Cert_ValidTo;
    String? CertBase64;
    String? SigningLocation;
    String? SigningReason;

    VerifySignerDetails({this.Cert_SubjectCN,this.ID,this.SignerCertificate,this.SignType,this.SignAlgorithm,this.HashAlgorithm,this.SignStatusIsValid,this.CertStatusValue,this.SigningTime,this.IsTimeStampExist,this.NextSigner,this.CounterSigners,this.TimeStampDetails,this.SignValidationDetails,this.CertValidationDetails,this.Cert_SubjectSN,this.Cert_Issuer,this.Cert_ValidFrom,this.Cert_ValidTo,this.CertBase64,this.SigningLocation,this.SigningReason});
    VerifySignerDetails.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Cert_SubjectCN = json['Cert_SubjectCN'];
        ID = json['ID'];
        SignerCertificate = JsonConverters.fromJson(json['SignerCertificate'],'X509Certificate2',context!);
        SignType = json['SignType'];
        SignAlgorithm = json['SignAlgorithm'];
        HashAlgorithm = json['HashAlgorithm'];
        SignStatusIsValid = json['SignStatusIsValid'];
        CertStatusValue = json['CertStatusValue'];
        SigningTime = JsonConverters.fromJson(json['SigningTime'],'DateTime',context!);
        IsTimeStampExist = json['IsTimeStampExist'];
        NextSigner = JsonConverters.fromJson(json['NextSigner'],'VerifySignerDetails',context!);
        CounterSigners = JsonConverters.fromJson(json['CounterSigners'],'List<VerifySignerDetails>',context!);
        TimeStampDetails = JsonConverters.fromJson(json['TimeStampDetails'],'List<TSValidationResultItem>',context!);
        SignValidationDetails = JsonConverters.fromJson(json['SignValidationDetails'],'List<SgValidationResultItem>',context!);
        CertValidationDetails = JsonConverters.fromJson(json['CertValidationDetails'],'List<CertValidationResultItem>',context!);
        Cert_SubjectSN = json['Cert_SubjectSN'];
        Cert_Issuer = json['Cert_Issuer'];
        Cert_ValidFrom = JsonConverters.fromJson(json['Cert_ValidFrom'],'DateTime',context!);
        Cert_ValidTo = JsonConverters.fromJson(json['Cert_ValidTo'],'DateTime',context!);
        CertBase64 = json['CertBase64'];
        SigningLocation = json['SigningLocation'];
        SigningReason = json['SigningReason'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Cert_SubjectCN': Cert_SubjectCN,
        'ID': ID,
        'SignerCertificate': JsonConverters.toJson(SignerCertificate,'X509Certificate2',context!),
        'SignType': SignType,
        'SignAlgorithm': SignAlgorithm,
        'HashAlgorithm': HashAlgorithm,
        'SignStatusIsValid': SignStatusIsValid,
        'CertStatusValue': CertStatusValue,
        'SigningTime': JsonConverters.toJson(SigningTime,'DateTime',context!),
        'IsTimeStampExist': IsTimeStampExist,
        'NextSigner': JsonConverters.toJson(NextSigner,'VerifySignerDetails',context!),
        'CounterSigners': JsonConverters.toJson(CounterSigners,'List<VerifySignerDetails>',context!),
        'TimeStampDetails': JsonConverters.toJson(TimeStampDetails,'List<TSValidationResultItem>',context!),
        'SignValidationDetails': JsonConverters.toJson(SignValidationDetails,'List<SgValidationResultItem>',context!),
        'CertValidationDetails': JsonConverters.toJson(CertValidationDetails,'List<CertValidationResultItem>',context!),
        'Cert_SubjectSN': Cert_SubjectSN,
        'Cert_Issuer': Cert_Issuer,
        'Cert_ValidFrom': JsonConverters.toJson(Cert_ValidFrom,'DateTime',context!),
        'Cert_ValidTo': JsonConverters.toJson(Cert_ValidTo,'DateTime',context!),
        'CertBase64': CertBase64,
        'SigningLocation': SigningLocation,
        'SigningReason': SigningReason
    };

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

class VerifyResult implements IConvertible
{
    bool? Result;
    String? ErrorMesage;
    bool? IsValid;
    List<VerifyDocumentDetails>? DocumentDetails;
    List<VerifySignerDetails>? Signers;

    VerifyResult({this.Result,this.ErrorMesage,this.IsValid,this.DocumentDetails,this.Signers});
    VerifyResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Result = json['Result'];
        ErrorMesage = json['ErrorMesage'];
        IsValid = json['IsValid'];
        DocumentDetails = JsonConverters.fromJson(json['DocumentDetails'],'List<VerifyDocumentDetails>',context!);
        Signers = JsonConverters.fromJson(json['Signers'],'List<VerifySignerDetails>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Result': Result,
        'ErrorMesage': ErrorMesage,
        'IsValid': IsValid,
        'DocumentDetails': JsonConverters.toJson(DocumentDetails,'List<VerifyDocumentDetails>',context!),
        'Signers': JsonConverters.toJson(Signers,'List<VerifySignerDetails>',context!)
    };

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

class EYPHedef implements IConvertible
{
    EYPKisiType? HedefTipi;
    EYPGercekSahis? GercekSahis;
    EYPTuzelSahis? TuzelSahis;
    EYPKurumKurulus? KurumKurulus;

    EYPHedef({this.HedefTipi,this.GercekSahis,this.TuzelSahis,this.KurumKurulus});
    EYPHedef.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        HedefTipi = JsonConverters.fromJson(json['HedefTipi'],'EYPKisiType',context!);
        GercekSahis = JsonConverters.fromJson(json['GercekSahis'],'EYPGercekSahis',context!);
        TuzelSahis = JsonConverters.fromJson(json['TuzelSahis'],'EYPTuzelSahis',context!);
        KurumKurulus = JsonConverters.fromJson(json['KurumKurulus'],'EYPKurumKurulus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'HedefTipi': JsonConverters.toJson(HedefTipi,'EYPKisiType',context!),
        'GercekSahis': JsonConverters.toJson(GercekSahis,'EYPGercekSahis',context!),
        'TuzelSahis': JsonConverters.toJson(TuzelSahis,'EYPTuzelSahis',context!),
        'KurumKurulus': JsonConverters.toJson(KurumKurulus,'EYPKurumKurulus',context!)
    };

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

class EYPDigestMethod implements IConvertible
{
    List<XmlNode>? Any;
    String? Algorithm;

    EYPDigestMethod({this.Any,this.Algorithm});
    EYPDigestMethod.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class EYPReference implements IConvertible
{
    EYPDigestMethod? DigestMethod;
    EYPDigestMethod? DigestMethod1;
    Uint8List? DigestValue;
    Uint8List? DigestValue1;
    String? Id;
    String? URI;
    String? Type;

    EYPReference({this.DigestMethod,this.DigestMethod1,this.DigestValue,this.DigestValue1,this.Id,this.URI,this.Type});
    EYPReference.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        DigestMethod = JsonConverters.fromJson(json['DigestMethod'],'EYPDigestMethod',context!);
        DigestMethod1 = JsonConverters.fromJson(json['DigestMethod1'],'EYPDigestMethod',context!);
        DigestValue = JsonConverters.fromJson(json['DigestValue'],'Uint8List',context!);
        DigestValue1 = JsonConverters.fromJson(json['DigestValue1'],'Uint8List',context!);
        Id = json['Id'];
        URI = json['URI'];
        Type = json['Type'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'DigestMethod': JsonConverters.toJson(DigestMethod,'EYPDigestMethod',context!),
        'DigestMethod1': JsonConverters.toJson(DigestMethod1,'EYPDigestMethod',context!),
        'DigestValue': JsonConverters.toJson(DigestValue,'Uint8List',context!),
        'DigestValue1': JsonConverters.toJson(DigestValue1,'Uint8List',context!),
        'Id': Id,
        'URI': URI,
        'Type': Type
    };

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

class NihaiUstveri implements IConvertible
{
    List<EYPImza>? Imzalar;
    DateTime? Tarih;
    String? BelgeNo;

    NihaiUstveri({this.Imzalar,this.Tarih,this.BelgeNo});
    NihaiUstveri.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Imzalar = JsonConverters.fromJson(json['Imzalar'],'List<EYPImza>',context!);
        Tarih = JsonConverters.fromJson(json['Tarih'],'DateTime',context!);
        BelgeNo = json['BelgeNo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Imzalar': JsonConverters.toJson(Imzalar,'List<EYPImza>',context!),
        'Tarih': JsonConverters.toJson(Tarih,'DateTime',context!),
        'BelgeNo': BelgeNo
    };

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

class ParafOzeti implements IConvertible
{
    List<EYPReference>? Ozetler;

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

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

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

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

enum MessageTypes
{
    Unknown,
    Error,
    Warning,
    Info,
}

class MessageDto implements IConvertible
{
    MessageTypes? MessageType;
    String? URI;
    String? Message;

    MessageDto({this.MessageType,this.URI,this.Message});
    MessageDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'MessageType': JsonConverters.toJson(MessageType,'MessageTypes',context!),
        'URI': URI,
        'Message': Message
    };

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

class DaBEYPPackage implements IConvertible
{
    String? BelgeNo;
    String? BelgeId;
    List<EYPImza>? Imzalar;
    List<EYPHedef>? Hedefler;
    Uint8List? BelgeImzaXML;
    Uint8List? Muhur;
    List<EYPReference>? NihaiOzetler;
    Uint8List? NihaiOzet;
    List<EYPReference>? PaketOzetleri;
    bool? PaketOzetiDogrulamasi;
    bool? NihaiOzetDogrulamasi;
    bool? ParafOzetiDogrulamasi;
    List<EYPDagitim>? Dagitimlar;
    String? Dil;
    DateTime? GuvenlikGecerlilikTarihi;
    EYPGuvenlikKodu? GuvenlikKodu;
    List<EYPIlgi>? Ilgiler;
    List<EYPIlgili>? Ilgililer;
    String? Konu;
    String? MimeTuru;
    EYPOlusturan? Olusturan;
    DateTime? Tarih;
    Uint8List? UstveriXML;
    Uint8List? UstYaziPDF;
    Uint8List? BelgeHedefXML;
    List<EYPEk>? Ekler;
    Uint8List? Imza;
    Uint8List? PaketOzeti;
    bool? ImzaKontrol;
    VerifyResult? EYPDogrulamaSonuc;
    SdpBilgisi? SdpBilgisi;
    NihaiUstveri? NihaiUstveri;
    ParafOzeti? ParafOzeti;
    List<Heysk>? HeyskListesi;
    String? PaketVersiyonu;
    bool? Result;
    bool? IsValid;
    String? ErrorMessage;
    List<MessageDto>? Messages;

    DaBEYPPackage({this.BelgeNo,this.BelgeId,this.Imzalar,this.Hedefler,this.BelgeImzaXML,this.Muhur,this.NihaiOzetler,this.NihaiOzet,this.PaketOzetleri,this.PaketOzetiDogrulamasi,this.NihaiOzetDogrulamasi,this.ParafOzetiDogrulamasi,this.Dagitimlar,this.Dil,this.GuvenlikGecerlilikTarihi,this.GuvenlikKodu,this.Ilgiler,this.Ilgililer,this.Konu,this.MimeTuru,this.Olusturan,this.Tarih,this.UstveriXML,this.UstYaziPDF,this.BelgeHedefXML,this.Ekler,this.Imza,this.PaketOzeti,this.ImzaKontrol,this.EYPDogrulamaSonuc,this.SdpBilgisi,this.NihaiUstveri,this.ParafOzeti,this.HeyskListesi,this.PaketVersiyonu,this.Result,this.IsValid,this.ErrorMessage,this.Messages});
    DaBEYPPackage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        BelgeNo = json['BelgeNo'];
        BelgeId = json['BelgeId'];
        Imzalar = JsonConverters.fromJson(json['Imzalar'],'List<EYPImza>',context!);
        Hedefler = JsonConverters.fromJson(json['Hedefler'],'List<EYPHedef>',context!);
        BelgeImzaXML = JsonConverters.fromJson(json['BelgeImzaXML'],'Uint8List',context!);
        Muhur = JsonConverters.fromJson(json['Muhur'],'Uint8List',context!);
        NihaiOzetler = JsonConverters.fromJson(json['NihaiOzetler'],'List<EYPReference>',context!);
        NihaiOzet = JsonConverters.fromJson(json['NihaiOzet'],'Uint8List',context!);
        PaketOzetleri = JsonConverters.fromJson(json['PaketOzetleri'],'List<EYPReference>',context!);
        PaketOzetiDogrulamasi = json['PaketOzetiDogrulamasi'];
        NihaiOzetDogrulamasi = json['NihaiOzetDogrulamasi'];
        ParafOzetiDogrulamasi = json['ParafOzetiDogrulamasi'];
        Dagitimlar = JsonConverters.fromJson(json['Dagitimlar'],'List<EYPDagitim>',context!);
        Dil = json['Dil'];
        GuvenlikGecerlilikTarihi = JsonConverters.fromJson(json['GuvenlikGecerlilikTarihi'],'DateTime',context!);
        GuvenlikKodu = JsonConverters.fromJson(json['GuvenlikKodu'],'EYPGuvenlikKodu',context!);
        Ilgiler = JsonConverters.fromJson(json['Ilgiler'],'List<EYPIlgi>',context!);
        Ilgililer = JsonConverters.fromJson(json['Ilgililer'],'List<EYPIlgili>',context!);
        Konu = json['Konu'];
        MimeTuru = json['MimeTuru'];
        Olusturan = JsonConverters.fromJson(json['Olusturan'],'EYPOlusturan',context!);
        Tarih = JsonConverters.fromJson(json['Tarih'],'DateTime',context!);
        UstveriXML = JsonConverters.fromJson(json['UstveriXML'],'Uint8List',context!);
        UstYaziPDF = JsonConverters.fromJson(json['UstYaziPDF'],'Uint8List',context!);
        BelgeHedefXML = JsonConverters.fromJson(json['BelgeHedefXML'],'Uint8List',context!);
        Ekler = JsonConverters.fromJson(json['Ekler'],'List<EYPEk>',context!);
        Imza = JsonConverters.fromJson(json['Imza'],'Uint8List',context!);
        PaketOzeti = JsonConverters.fromJson(json['PaketOzeti'],'Uint8List',context!);
        ImzaKontrol = json['ImzaKontrol'];
        EYPDogrulamaSonuc = JsonConverters.fromJson(json['EYPDogrulamaSonuc'],'VerifyResult',context!);
        SdpBilgisi = JsonConverters.fromJson(json['SdpBilgisi'],'SdpBilgisi',context!);
        NihaiUstveri = JsonConverters.fromJson(json['NihaiUstveri'],'NihaiUstveri',context!);
        ParafOzeti = JsonConverters.fromJson(json['ParafOzeti'],'ParafOzeti',context!);
        HeyskListesi = JsonConverters.fromJson(json['HeyskListesi'],'List<Heysk>',context!);
        PaketVersiyonu = json['PaketVersiyonu'];
        Result = json['Result'];
        IsValid = json['IsValid'];
        ErrorMessage = json['ErrorMessage'];
        Messages = JsonConverters.fromJson(json['Messages'],'List<MessageDto>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'BelgeNo': BelgeNo,
        'BelgeId': BelgeId,
        'Imzalar': JsonConverters.toJson(Imzalar,'List<EYPImza>',context!),
        'Hedefler': JsonConverters.toJson(Hedefler,'List<EYPHedef>',context!),
        'BelgeImzaXML': JsonConverters.toJson(BelgeImzaXML,'Uint8List',context!),
        'Muhur': JsonConverters.toJson(Muhur,'Uint8List',context!),
        'NihaiOzetler': JsonConverters.toJson(NihaiOzetler,'List<EYPReference>',context!),
        'NihaiOzet': JsonConverters.toJson(NihaiOzet,'Uint8List',context!),
        'PaketOzetleri': JsonConverters.toJson(PaketOzetleri,'List<EYPReference>',context!),
        'PaketOzetiDogrulamasi': PaketOzetiDogrulamasi,
        'NihaiOzetDogrulamasi': NihaiOzetDogrulamasi,
        'ParafOzetiDogrulamasi': ParafOzetiDogrulamasi,
        'Dagitimlar': JsonConverters.toJson(Dagitimlar,'List<EYPDagitim>',context!),
        'Dil': Dil,
        'GuvenlikGecerlilikTarihi': JsonConverters.toJson(GuvenlikGecerlilikTarihi,'DateTime',context!),
        'GuvenlikKodu': JsonConverters.toJson(GuvenlikKodu,'EYPGuvenlikKodu',context!),
        'Ilgiler': JsonConverters.toJson(Ilgiler,'List<EYPIlgi>',context!),
        'Ilgililer': JsonConverters.toJson(Ilgililer,'List<EYPIlgili>',context!),
        'Konu': Konu,
        'MimeTuru': MimeTuru,
        'Olusturan': JsonConverters.toJson(Olusturan,'EYPOlusturan',context!),
        'Tarih': JsonConverters.toJson(Tarih,'DateTime',context!),
        'UstveriXML': JsonConverters.toJson(UstveriXML,'Uint8List',context!),
        'UstYaziPDF': JsonConverters.toJson(UstYaziPDF,'Uint8List',context!),
        'BelgeHedefXML': JsonConverters.toJson(BelgeHedefXML,'Uint8List',context!),
        'Ekler': JsonConverters.toJson(Ekler,'List<EYPEk>',context!),
        'Imza': JsonConverters.toJson(Imza,'Uint8List',context!),
        'PaketOzeti': JsonConverters.toJson(PaketOzeti,'Uint8List',context!),
        'ImzaKontrol': ImzaKontrol,
        'EYPDogrulamaSonuc': JsonConverters.toJson(EYPDogrulamaSonuc,'VerifyResult',context!),
        'SdpBilgisi': JsonConverters.toJson(SdpBilgisi,'SdpBilgisi',context!),
        'NihaiUstveri': JsonConverters.toJson(NihaiUstveri,'NihaiUstveri',context!),
        'ParafOzeti': JsonConverters.toJson(ParafOzeti,'ParafOzeti',context!),
        'HeyskListesi': JsonConverters.toJson(HeyskListesi,'List<Heysk>',context!),
        'PaketVersiyonu': PaketVersiyonu,
        'Result': Result,
        'IsValid': IsValid,
        'ErrorMessage': ErrorMessage,
        'Messages': JsonConverters.toJson(Messages,'List<MessageDto>',context!)
    };

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

class BaseResponse implements IConvertible
{
    bool? ServiceSuccessResult;
    String? ErrorMesage;

    BaseResponse({this.ServiceSuccessResult,this.ErrorMesage});
    BaseResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ServiceSuccessResult': ServiceSuccessResult,
        'ErrorMesage': ErrorMesage
    };

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

class VerifyEYPPackageWithDocumentIdResponse extends BaseResponse implements IConvertible
{
    DaBEYPPackage? Result;

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

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

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

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

// @Route("/VerifyEYPPackageWithDocumentId/")
class VerifyEYPPackageWithDocumentId implements IReturn<VerifyEYPPackageWithDocumentIdResponse>, IConvertible, IPost
{
    String? ClientKey;
    String? AuthorizationID;
    int? DocumentId;

    VerifyEYPPackageWithDocumentId({this.ClientKey,this.AuthorizationID,this.DocumentId});
    VerifyEYPPackageWithDocumentId.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ClientKey = json['ClientKey'];
        AuthorizationID = json['AuthorizationID'];
        DocumentId = json['DocumentId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ClientKey': ClientKey,
        'AuthorizationID': AuthorizationID,
        'DocumentId': DocumentId
    };

    createResponse() => VerifyEYPPackageWithDocumentIdResponse();
    getResponseTypeName() => "VerifyEYPPackageWithDocumentIdResponse";
    getTypeName() => "VerifyEYPPackageWithDocumentId";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'imzagerservices.eyyubiye.bel.tr', types: <String, TypeInfo> {
    'EYPGuvenlikKodu': TypeInfo(TypeOf.Enum, enumValues:EYPGuvenlikKodu.values),
    'EYPIvedilik': TypeInfo(TypeOf.Enum, enumValues:EYPIvedilik.values),
    'EYPDagitimTuru': TypeInfo(TypeOf.Enum, enumValues:EYPDagitimTuru.values),
    'EYPKonulmamisEk': TypeInfo(TypeOf.Class, create:() => EYPKonulmamisEk()),
    'EYPKisiType': TypeInfo(TypeOf.Enum, enumValues:EYPKisiType.values),
    'EYPKisi': TypeInfo(TypeOf.Class, create:() => EYPKisi()),
    'EYPIletisimBilgisi': TypeInfo(TypeOf.Class, create:() => EYPIletisimBilgisi()),
    'EYPGercekSahis': TypeInfo(TypeOf.Class, create:() => EYPGercekSahis()),
    'EYPTuzelSahis': TypeInfo(TypeOf.Class, create:() => EYPTuzelSahis()),
    'EYPKurumKurulus': TypeInfo(TypeOf.Class, create:() => EYPKurumKurulus()),
    'EYPDagitim': TypeInfo(TypeOf.Class, create:() => EYPDagitim()),
    'List<EYPKonulmamisEk>': TypeInfo(TypeOf.Class, create:() => <EYPKonulmamisEk>[]),
    'EYPEkTuru': TypeInfo(TypeOf.Enum, enumValues:EYPEkTuru.values),
    'EYPEkOzet': TypeInfo(TypeOf.Class, create:() => EYPEkOzet()),
    'Uint8List': TypeInfo(TypeOf.Class, create:() => Uint8List(0)),
    'EYPEkOzetModu': TypeInfo(TypeOf.Enum, enumValues:EYPEkOzetModu.values),
    'EYPEk': TypeInfo(TypeOf.Class, create:() => EYPEk()),
    'EYPIlgi': TypeInfo(TypeOf.Class, create:() => EYPIlgi()),
    'EYPOlusturan': TypeInfo(TypeOf.Class, create:() => EYPOlusturan()),
    'EYPIlgili': TypeInfo(TypeOf.Class, create:() => EYPIlgili()),
    'EYPImza': TypeInfo(TypeOf.Class, create:() => EYPImza()),
    'AnaSdp': TypeInfo(TypeOf.Class, create:() => AnaSdp()),
    'SdpListesi': TypeInfo(TypeOf.Class, create:() => SdpListesi()),
    'DigerSdpler': TypeInfo(TypeOf.Class, create:() => DigerSdpler()),
    'List<SdpListesi>': TypeInfo(TypeOf.Class, create:() => <SdpListesi>[]),
    'SdpBilgisi': TypeInfo(TypeOf.Class, create:() => SdpBilgisi()),
    'Heysk': TypeInfo(TypeOf.Class, create:() => Heysk()),
    'VerifyDocumentDetails': TypeInfo(TypeOf.Class, create:() => VerifyDocumentDetails()),
    'TSValidationResultItem': TypeInfo(TypeOf.Class, create:() => TSValidationResultItem()),
    'List<TSValidationResultItem>': TypeInfo(TypeOf.Class, create:() => <TSValidationResultItem>[]),
    'SgValidationResultItem': TypeInfo(TypeOf.Class, create:() => SgValidationResultItem()),
    'CertValidationResultItem': TypeInfo(TypeOf.Class, create:() => CertValidationResultItem()),
    'VerifySignerDetails': TypeInfo(TypeOf.Class, create:() => VerifySignerDetails()),
    'X509Certificate2': TypeInfo(TypeOf.Class, create:() => X509Certificate2()),
    'List<VerifySignerDetails>': TypeInfo(TypeOf.Class, create:() => <VerifySignerDetails>[]),
    'List<SgValidationResultItem>': TypeInfo(TypeOf.Class, create:() => <SgValidationResultItem>[]),
    'List<CertValidationResultItem>': TypeInfo(TypeOf.Class, create:() => <CertValidationResultItem>[]),
    'VerifyResult': TypeInfo(TypeOf.Class, create:() => VerifyResult()),
    'List<VerifyDocumentDetails>': TypeInfo(TypeOf.Class, create:() => <VerifyDocumentDetails>[]),
    'EYPHedef': TypeInfo(TypeOf.Class, create:() => EYPHedef()),
    'EYPDigestMethod': TypeInfo(TypeOf.Class, create:() => EYPDigestMethod()),
    'List<XmlNode>': TypeInfo(TypeOf.Class, create:() => <XmlNode>[]),
    'XmlNode': TypeInfo(TypeOf.Class, create:() => XmlNode()),
    'EYPReference': TypeInfo(TypeOf.Class, create:() => EYPReference()),
    'NihaiUstveri': TypeInfo(TypeOf.Class, create:() => NihaiUstveri()),
    'List<EYPImza>': TypeInfo(TypeOf.Class, create:() => <EYPImza>[]),
    'ParafOzeti': TypeInfo(TypeOf.Class, create:() => ParafOzeti()),
    'List<EYPReference>': TypeInfo(TypeOf.Class, create:() => <EYPReference>[]),
    'MessageTypes': TypeInfo(TypeOf.Enum, enumValues:MessageTypes.values),
    'MessageDto': TypeInfo(TypeOf.Class, create:() => MessageDto()),
    'DaBEYPPackage': TypeInfo(TypeOf.Class, create:() => DaBEYPPackage()),
    'List<EYPHedef>': TypeInfo(TypeOf.Class, create:() => <EYPHedef>[]),
    'List<EYPDagitim>': TypeInfo(TypeOf.Class, create:() => <EYPDagitim>[]),
    'List<EYPIlgi>': TypeInfo(TypeOf.Class, create:() => <EYPIlgi>[]),
    'List<EYPIlgili>': TypeInfo(TypeOf.Class, create:() => <EYPIlgili>[]),
    'List<EYPEk>': TypeInfo(TypeOf.Class, create:() => <EYPEk>[]),
    'List<Heysk>': TypeInfo(TypeOf.Class, create:() => <Heysk>[]),
    'List<MessageDto>': TypeInfo(TypeOf.Class, create:() => <MessageDto>[]),
    'BaseResponse': TypeInfo(TypeOf.Class, create:() => BaseResponse()),
    'VerifyEYPPackageWithDocumentIdResponse': TypeInfo(TypeOf.Class, create:() => VerifyEYPPackageWithDocumentIdResponse()),
    'VerifyEYPPackageWithDocumentId': TypeInfo(TypeOf.Class, create:() => VerifyEYPPackageWithDocumentId()),
});