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

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

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

class RemMsgEvidence implements IConvertible
{
    int? RemMessageEvidenceId;
    int? RemId;
    int? EvidenceTypeId;
    int? EvidenceCodeId;
    String? EvidenceRemSubject;
    String? EvidenceMessageID;
    DateTime? EvidenceDate;

    RemMsgEvidence({this.RemMessageEvidenceId,this.RemId,this.EvidenceTypeId,this.EvidenceCodeId,this.EvidenceRemSubject,this.EvidenceMessageID,this.EvidenceDate});
    RemMsgEvidence.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RemMessageEvidenceId = json['RemMessageEvidenceId'];
        RemId = json['RemId'];
        EvidenceTypeId = json['EvidenceTypeId'];
        EvidenceCodeId = json['EvidenceCodeId'];
        EvidenceRemSubject = json['EvidenceRemSubject'];
        EvidenceMessageID = json['EvidenceMessageID'];
        EvidenceDate = JsonConverters.fromJson(json['EvidenceDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RemMessageEvidenceId': RemMessageEvidenceId,
        'RemId': RemId,
        'EvidenceTypeId': EvidenceTypeId,
        'EvidenceCodeId': EvidenceCodeId,
        'EvidenceRemSubject': EvidenceRemSubject,
        'EvidenceMessageID': EvidenceMessageID,
        'EvidenceDate': JsonConverters.toJson(EvidenceDate,'DateTime',context!)
    };

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

class RemMsgDelivery implements IConvertible
{
    int? RemDeliveryId;
    int? RemId;
    String? AddressType;
    String? RemDisplayName;
    String? RemAddress;
    String? Status;
    int? RemSPId;
    int? SystemAcceptance;
    DateTime? SystemAcceptanceDate;
    int? RecipientAcceptance;
    DateTime? RecipientAcceptanceDate;
    int? Delivered;
    DateTime? DeliveredDate;
    int? Read;
    DateTime? ReadDate;

    RemMsgDelivery({this.RemDeliveryId,this.RemId,this.AddressType,this.RemDisplayName,this.RemAddress,this.Status,this.RemSPId,this.SystemAcceptance,this.SystemAcceptanceDate,this.RecipientAcceptance,this.RecipientAcceptanceDate,this.Delivered,this.DeliveredDate,this.Read,this.ReadDate});
    RemMsgDelivery.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RemDeliveryId = json['RemDeliveryId'];
        RemId = json['RemId'];
        AddressType = json['AddressType'];
        RemDisplayName = json['RemDisplayName'];
        RemAddress = json['RemAddress'];
        Status = json['Status'];
        RemSPId = json['RemSPId'];
        SystemAcceptance = json['SystemAcceptance'];
        SystemAcceptanceDate = JsonConverters.fromJson(json['SystemAcceptanceDate'],'DateTime',context!);
        RecipientAcceptance = json['RecipientAcceptance'];
        RecipientAcceptanceDate = JsonConverters.fromJson(json['RecipientAcceptanceDate'],'DateTime',context!);
        Delivered = json['Delivered'];
        DeliveredDate = JsonConverters.fromJson(json['DeliveredDate'],'DateTime',context!);
        Read = json['Read'];
        ReadDate = JsonConverters.fromJson(json['ReadDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RemDeliveryId': RemDeliveryId,
        'RemId': RemId,
        'AddressType': AddressType,
        'RemDisplayName': RemDisplayName,
        'RemAddress': RemAddress,
        'Status': Status,
        'RemSPId': RemSPId,
        'SystemAcceptance': SystemAcceptance,
        'SystemAcceptanceDate': JsonConverters.toJson(SystemAcceptanceDate,'DateTime',context!),
        'RecipientAcceptance': RecipientAcceptance,
        'RecipientAcceptanceDate': JsonConverters.toJson(RecipientAcceptanceDate,'DateTime',context!),
        'Delivered': Delivered,
        'DeliveredDate': JsonConverters.toJson(DeliveredDate,'DateTime',context!),
        'Read': Read,
        'ReadDate': JsonConverters.toJson(ReadDate,'DateTime',context!)
    };

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

class ViewedRemMessage implements IConvertible
{
    int? kepId;
    String? kepCC;
    String? kepEventCode;
    String? kepEvidenceType;
    String? kepFrom;
    String? kepIleti;
    String? kepMessageID;
    String? kepMsgType;
    DateTime? kepReceivedDate;
    bool? kepReceivedDateSpecified;
    DateTime? kepSendDate;
    bool? kepSendDateSpecified;
    String? kepSubject;
    String? kepTo;
    String? kepTRgunSayac;
    String? kepTRIletiID;
    String? kepTRIletiTip;
    String? kepUAMessageIdentifier;
    String? status;
    List<RemMsgEvidence>? kepDelilListesi;
    List<RemMsgDelivery>? kepTeslimalListesi;

    ViewedRemMessage({this.kepId,this.kepCC,this.kepEventCode,this.kepEvidenceType,this.kepFrom,this.kepIleti,this.kepMessageID,this.kepMsgType,this.kepReceivedDate,this.kepReceivedDateSpecified,this.kepSendDate,this.kepSendDateSpecified,this.kepSubject,this.kepTo,this.kepTRgunSayac,this.kepTRIletiID,this.kepTRIletiTip,this.kepUAMessageIdentifier,this.status,this.kepDelilListesi,this.kepTeslimalListesi});
    ViewedRemMessage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        kepId = json['kepId'];
        kepCC = json['kepCC'];
        kepEventCode = json['kepEventCode'];
        kepEvidenceType = json['kepEvidenceType'];
        kepFrom = json['kepFrom'];
        kepIleti = json['kepIleti'];
        kepMessageID = json['kepMessageID'];
        kepMsgType = json['kepMsgType'];
        kepReceivedDate = JsonConverters.fromJson(json['kepReceivedDate'],'DateTime',context!);
        kepReceivedDateSpecified = json['kepReceivedDateSpecified'];
        kepSendDate = JsonConverters.fromJson(json['kepSendDate'],'DateTime',context!);
        kepSendDateSpecified = json['kepSendDateSpecified'];
        kepSubject = json['kepSubject'];
        kepTo = json['kepTo'];
        kepTRgunSayac = json['kepTRgunSayac'];
        kepTRIletiID = json['kepTRIletiID'];
        kepTRIletiTip = json['kepTRIletiTip'];
        kepUAMessageIdentifier = json['kepUAMessageIdentifier'];
        status = json['status'];
        kepDelilListesi = JsonConverters.fromJson(json['kepDelilListesi'],'List<RemMsgEvidence>',context!);
        kepTeslimalListesi = JsonConverters.fromJson(json['kepTeslimalListesi'],'List<RemMsgDelivery>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'kepId': kepId,
        'kepCC': kepCC,
        'kepEventCode': kepEventCode,
        'kepEvidenceType': kepEvidenceType,
        'kepFrom': kepFrom,
        'kepIleti': kepIleti,
        'kepMessageID': kepMessageID,
        'kepMsgType': kepMsgType,
        'kepReceivedDate': JsonConverters.toJson(kepReceivedDate,'DateTime',context!),
        'kepReceivedDateSpecified': kepReceivedDateSpecified,
        'kepSendDate': JsonConverters.toJson(kepSendDate,'DateTime',context!),
        'kepSendDateSpecified': kepSendDateSpecified,
        'kepSubject': kepSubject,
        'kepTo': kepTo,
        'kepTRgunSayac': kepTRgunSayac,
        'kepTRIletiID': kepTRIletiID,
        'kepTRIletiTip': kepTRIletiTip,
        'kepUAMessageIdentifier': kepUAMessageIdentifier,
        'status': status,
        'kepDelilListesi': JsonConverters.toJson(kepDelilListesi,'List<RemMsgEvidence>',context!),
        'kepTeslimalListesi': JsonConverters.toJson(kepTeslimalListesi,'List<RemMsgDelivery>',context!)
    };

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

class RemDelivery implements IConvertible
{
    String? AddressType;
    String? RemAddress;
    String? Status;

    RemDelivery({this.AddressType,this.RemAddress,this.Status});
    RemDelivery.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'AddressType': AddressType,
        'RemAddress': RemAddress,
        'Status': Status
    };

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

class RemEvidence implements IConvertible
{
    String? EvidenceType;
    String? EvidenceSubject;

    RemEvidence({this.EvidenceType,this.EvidenceSubject});
    RemEvidence.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class GetOutRemMessageResponse implements IConvertible
{
    ViewedRemMessage? Result;
    List<RemDelivery>? Deliveries;
    List<RemEvidence>? Evidences;
    bool? ServiceSuccessResult;
    String? ErrorMesage;

    GetOutRemMessageResponse({this.Result,this.Deliveries,this.Evidences,this.ServiceSuccessResult,this.ErrorMesage});
    GetOutRemMessageResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Result = JsonConverters.fromJson(json['Result'],'ViewedRemMessage',context!);
        Deliveries = JsonConverters.fromJson(json['Deliveries'],'List<RemDelivery>',context!);
        Evidences = JsonConverters.fromJson(json['Evidences'],'List<RemEvidence>',context!);
        ServiceSuccessResult = json['ServiceSuccessResult'];
        ErrorMesage = json['ErrorMesage'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Result': JsonConverters.toJson(Result,'ViewedRemMessage',context!),
        'Deliveries': JsonConverters.toJson(Deliveries,'List<RemDelivery>',context!),
        'Evidences': JsonConverters.toJson(Evidences,'List<RemEvidence>',context!),
        'ServiceSuccessResult': ServiceSuccessResult,
        'ErrorMesage': ErrorMesage
    };

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

// @Route("/GetOutRemMessage")
class GetOutRemMessage implements IReturn<GetOutRemMessageResponse>, IConvertible, IPost
{
    String? AuthorizationID;
    String? ClientKey;
    int? RemID;

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

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

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

    createResponse() => GetOutRemMessageResponse();
    getResponseTypeName() => "GetOutRemMessageResponse";
    getTypeName() => "GetOutRemMessage";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'remservices.eyyubiye.bel.tr', types: <String, TypeInfo> {
    'RemMsgEvidence': TypeInfo(TypeOf.Class, create:() => RemMsgEvidence()),
    'RemMsgDelivery': TypeInfo(TypeOf.Class, create:() => RemMsgDelivery()),
    'ViewedRemMessage': TypeInfo(TypeOf.Class, create:() => ViewedRemMessage()),
    'List<RemMsgEvidence>': TypeInfo(TypeOf.Class, create:() => <RemMsgEvidence>[]),
    'List<RemMsgDelivery>': TypeInfo(TypeOf.Class, create:() => <RemMsgDelivery>[]),
    'RemDelivery': TypeInfo(TypeOf.Class, create:() => RemDelivery()),
    'RemEvidence': TypeInfo(TypeOf.Class, create:() => RemEvidence()),
    'GetOutRemMessageResponse': TypeInfo(TypeOf.Class, create:() => GetOutRemMessageResponse()),
    'List<RemDelivery>': TypeInfo(TypeOf.Class, create:() => <RemDelivery>[]),
    'List<RemEvidence>': TypeInfo(TypeOf.Class, create:() => <RemEvidence>[]),
    'GetOutRemMessage': TypeInfo(TypeOf.Class, create:() => GetOutRemMessage()),
});