/* Options:
Date: 2024-11-21 05:56:16
Version: 6.10
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.paysecure.acculynk.net

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

import 'package:servicestack/servicestack.dart';

class RequestorCredentials implements IConvertible
{
    // @Required()
    String? MerchantId;

    // @Required()
    String? UserName;

    // @Required()
    String? Password;

    // @Required()
    String? Version;

    RequestorCredentials({this.MerchantId,this.UserName,this.Password,this.Version});
    RequestorCredentials.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MerchantId = json['MerchantId'];
        UserName = json['UserName'];
        Password = json['Password'];
        Version = json['Version'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MerchantId': MerchantId,
        'UserName': UserName,
        'Password': Password,
        'Version': Version
    };

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

enum TelephoneType
{
    D,
    H,
    N,
    W,
}

class Avs implements IConvertible
{
    String? Address;
    String? City;
    String? State;
    String? Zip;
    String? Country;
    String? Email;
    String? IPAddress;
    String? TelephoneNumber;
    TelephoneType? TelephoneType;
    int? DeliveryMethod;
    String? FirstName;
    String? MiddleName;
    String? LastName;

    Avs({this.Address,this.City,this.State,this.Zip,this.Country,this.Email,this.IPAddress,this.TelephoneNumber,this.TelephoneType,this.DeliveryMethod,this.FirstName,this.MiddleName,this.LastName});
    Avs.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Address = json['Address'];
        City = json['City'];
        State = json['State'];
        Zip = json['Zip'];
        Country = json['Country'];
        Email = json['Email'];
        IPAddress = json['IPAddress'];
        TelephoneNumber = json['TelephoneNumber'];
        TelephoneType = JsonConverters.fromJson(json['TelephoneType'],'TelephoneType',context!);
        DeliveryMethod = json['DeliveryMethod'];
        FirstName = json['FirstName'];
        MiddleName = json['MiddleName'];
        LastName = json['LastName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Address': Address,
        'City': City,
        'State': State,
        'Zip': Zip,
        'Country': Country,
        'Email': Email,
        'IPAddress': IPAddress,
        'TelephoneNumber': TelephoneNumber,
        'TelephoneType': JsonConverters.toJson(TelephoneType,'TelephoneType',context!),
        'DeliveryMethod': DeliveryMethod,
        'FirstName': FirstName,
        'MiddleName': MiddleName,
        'LastName': LastName
    };

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

class MerchantDataElements implements IConvertible
{
    int? RefundSettlementTypeDetails;
    bool? SendRecurringPOSEntryModeFeature;
    bool? UseOrgPOSCode;

    MerchantDataElements({this.RefundSettlementTypeDetails,this.SendRecurringPOSEntryModeFeature,this.UseOrgPOSCode});
    MerchantDataElements.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'RefundSettlementTypeDetails': RefundSettlementTypeDetails,
        'SendRecurringPOSEntryModeFeature': SendRecurringPOSEntryModeFeature,
        'UseOrgPOSCode': UseOrgPOSCode
    };

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

abstract class MerchantDescriptorBase
{
    MerchantDataElements? DataElements;

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

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

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

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

class MerchantDescriptor extends MerchantDescriptorBase implements IConvertible
{
    String? Name;
    String? Address;
    String? City;
    String? State;
    String? Zip;
    String? Country;
    String? CustomerServiceNumber;
    String? MCC;
    String? FNSnum;
    String? Email;

    MerchantDescriptor({this.Name,this.Address,this.City,this.State,this.Zip,this.Country,this.CustomerServiceNumber,this.MCC,this.FNSnum,this.Email});
    MerchantDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        Name = json['Name'];
        Address = json['Address'];
        City = json['City'];
        State = json['State'];
        Zip = json['Zip'];
        Country = json['Country'];
        CustomerServiceNumber = json['CustomerServiceNumber'];
        MCC = json['MCC'];
        FNSnum = json['FNSnum'];
        Email = json['Email'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'Name': Name,
        'Address': Address,
        'City': City,
        'State': State,
        'Zip': Zip,
        'Country': Country,
        'CustomerServiceNumber': CustomerServiceNumber,
        'MCC': MCC,
        'FNSnum': FNSnum,
        'Email': Email
    });

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

// @DataContract
class ACHExtendedData implements IConvertible
{
    // @DataMember
    int? CashbackAmount;

    // @DataMember
    String? ConnectPaySubScriberId;

    // @DataMember
    String? OrganizationId;

    // @DataMember
    String? DeviceFingerPrint;

    // @DataMember
    String? MerchantSessionId;

    // @DataMember
    String? CurrencyCode;

    // @DataMember
    String? PaymentType;

    // @DataMember
    bool? VerifyCustomer;

    // @DataMember
    String? CustomerExternalId;

    // @DataMember
    String? Description;

    // @DataMember
    String? CustomerName;

    // @DataMember
    String? AddressLine1;

    // @DataMember
    String? AddressLine2;

    // @DataMember
    String? City;

    // @DataMember
    String? State;

    // @DataMember
    String? Zip;

    // @DataMember
    String? Country;

    // @DataMember
    String? Email;

    // @DataMember
    String? TelephoneNumber;

    // @DataMember
    String? ReturnUrl;

    // @DataMember
    String? CancelUrl;

    // @DataMember
    String? EstablishData;

    // @DataMember
    String? RedirectUrl;

    // @DataMember
    int? RetryAttemptCount;

    // @DataMember
    String? SignatureHashVersion;

    // @DataMember
    DateTime? DeadlineHashDate;

    ACHExtendedData({this.CashbackAmount,this.ConnectPaySubScriberId,this.OrganizationId,this.DeviceFingerPrint,this.MerchantSessionId,this.CurrencyCode,this.PaymentType,this.VerifyCustomer,this.CustomerExternalId,this.Description,this.CustomerName,this.AddressLine1,this.AddressLine2,this.City,this.State,this.Zip,this.Country,this.Email,this.TelephoneNumber,this.ReturnUrl,this.CancelUrl,this.EstablishData,this.RedirectUrl,this.RetryAttemptCount,this.SignatureHashVersion,this.DeadlineHashDate});
    ACHExtendedData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CashbackAmount = json['CashbackAmount'];
        ConnectPaySubScriberId = json['ConnectPaySubScriberId'];
        OrganizationId = json['OrganizationId'];
        DeviceFingerPrint = json['DeviceFingerPrint'];
        MerchantSessionId = json['MerchantSessionId'];
        CurrencyCode = json['CurrencyCode'];
        PaymentType = json['PaymentType'];
        VerifyCustomer = json['VerifyCustomer'];
        CustomerExternalId = json['CustomerExternalId'];
        Description = json['Description'];
        CustomerName = json['CustomerName'];
        AddressLine1 = json['AddressLine1'];
        AddressLine2 = json['AddressLine2'];
        City = json['City'];
        State = json['State'];
        Zip = json['Zip'];
        Country = json['Country'];
        Email = json['Email'];
        TelephoneNumber = json['TelephoneNumber'];
        ReturnUrl = json['ReturnUrl'];
        CancelUrl = json['CancelUrl'];
        EstablishData = json['EstablishData'];
        RedirectUrl = json['RedirectUrl'];
        RetryAttemptCount = json['RetryAttemptCount'];
        SignatureHashVersion = json['SignatureHashVersion'];
        DeadlineHashDate = JsonConverters.fromJson(json['DeadlineHashDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CashbackAmount': CashbackAmount,
        'ConnectPaySubScriberId': ConnectPaySubScriberId,
        'OrganizationId': OrganizationId,
        'DeviceFingerPrint': DeviceFingerPrint,
        'MerchantSessionId': MerchantSessionId,
        'CurrencyCode': CurrencyCode,
        'PaymentType': PaymentType,
        'VerifyCustomer': VerifyCustomer,
        'CustomerExternalId': CustomerExternalId,
        'Description': Description,
        'CustomerName': CustomerName,
        'AddressLine1': AddressLine1,
        'AddressLine2': AddressLine2,
        'City': City,
        'State': State,
        'Zip': Zip,
        'Country': Country,
        'Email': Email,
        'TelephoneNumber': TelephoneNumber,
        'ReturnUrl': ReturnUrl,
        'CancelUrl': CancelUrl,
        'EstablishData': EstablishData,
        'RedirectUrl': RedirectUrl,
        'RetryAttemptCount': RetryAttemptCount,
        'SignatureHashVersion': SignatureHashVersion,
        'DeadlineHashDate': JsonConverters.toJson(DeadlineHashDate,'DateTime',context!)
    };

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

enum CardInfoType
{
    CardNumber,
    Token,
    Track,
    EMV,
    Encrypted,
    DPAN,
    ApplePay,
    GooglePay,
    SamsungPay,
    CPToken,
    EncryptedEnhanced,
    EncryptedJWE,
}

class CardAccountUpdaterDescriptor implements IConvertible
{
    CardInfoType? CardDataType;
    String? CardNumberInfo;
    String? ExpiryDate;
    String? Status;
    String? ErrorCode;
    String? CardToken;

    CardAccountUpdaterDescriptor({this.CardDataType,this.CardNumberInfo,this.ExpiryDate,this.Status,this.ErrorCode,this.CardToken});
    CardAccountUpdaterDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CardDataType = JsonConverters.fromJson(json['CardDataType'],'CardInfoType',context!);
        CardNumberInfo = json['CardNumberInfo'];
        ExpiryDate = json['ExpiryDate'];
        Status = json['Status'];
        ErrorCode = json['ErrorCode'];
        CardToken = json['CardToken'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CardDataType': JsonConverters.toJson(CardDataType,'CardInfoType',context!),
        'CardNumberInfo': CardNumberInfo,
        'ExpiryDate': ExpiryDate,
        'Status': Status,
        'ErrorCode': ErrorCode,
        'CardToken': CardToken
    };

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

// @DataContract
class ExtendedResponse implements IConvertible
{
    // @DataMember(EmitDefaultValue=false)
    CardAccountUpdaterDescriptor? CardAccountUpdater;

    // @DataMember(EmitDefaultValue=false)
    String? ProductId;

    // @DataMember(EmitDefaultValue=false)
    String? NetworkResponseCode;

    // @DataMember(EmitDefaultValue=false)
    String? NetworkTransactionId;

    // @DataMember(EmitDefaultValue=false)
    String? CHEmailAddrResult;

    ExtendedResponse({this.CardAccountUpdater,this.ProductId,this.NetworkResponseCode,this.NetworkTransactionId,this.CHEmailAddrResult});
    ExtendedResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CardAccountUpdater = JsonConverters.fromJson(json['CardAccountUpdater'],'CardAccountUpdaterDescriptor',context!);
        ProductId = json['ProductId'];
        NetworkResponseCode = json['NetworkResponseCode'];
        NetworkTransactionId = json['NetworkTransactionId'];
        CHEmailAddrResult = json['CHEmailAddrResult'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CardAccountUpdater': JsonConverters.toJson(CardAccountUpdater,'CardAccountUpdaterDescriptor',context!),
        'ProductId': ProductId,
        'NetworkResponseCode': NetworkResponseCode,
        'NetworkTransactionId': NetworkTransactionId,
        'CHEmailAddrResult': CHEmailAddrResult
    };

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

// @DataContract
class InOutTimes implements IConvertible
{
    InOutTimes();
    InOutTimes.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    getTypeName() => "InOutTimes";
    TypeContext? context = _ctx;
}

// @DataContract
class RequestTimestamps implements IConvertible
{
    // @DataMember(EmitDefaultValue=false)
    InOutTimes? AppLayer;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? ParentLookup;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? RetryLookup;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? GetCardData;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? CardTokenize;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? CardEncrypt;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? DBInsert;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? BackendProcess;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? DBUpdate;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? ParentUpdate;

    // @DataMember(EmitDefaultValue=false)
    InOutTimes? Network;

    RequestTimestamps({this.AppLayer,this.ParentLookup,this.RetryLookup,this.GetCardData,this.CardTokenize,this.CardEncrypt,this.DBInsert,this.BackendProcess,this.DBUpdate,this.ParentUpdate,this.Network});
    RequestTimestamps.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AppLayer = JsonConverters.fromJson(json['AppLayer'],'InOutTimes',context!);
        ParentLookup = JsonConverters.fromJson(json['ParentLookup'],'InOutTimes',context!);
        RetryLookup = JsonConverters.fromJson(json['RetryLookup'],'InOutTimes',context!);
        GetCardData = JsonConverters.fromJson(json['GetCardData'],'InOutTimes',context!);
        CardTokenize = JsonConverters.fromJson(json['CardTokenize'],'InOutTimes',context!);
        CardEncrypt = JsonConverters.fromJson(json['CardEncrypt'],'InOutTimes',context!);
        DBInsert = JsonConverters.fromJson(json['DBInsert'],'InOutTimes',context!);
        BackendProcess = JsonConverters.fromJson(json['BackendProcess'],'InOutTimes',context!);
        DBUpdate = JsonConverters.fromJson(json['DBUpdate'],'InOutTimes',context!);
        ParentUpdate = JsonConverters.fromJson(json['ParentUpdate'],'InOutTimes',context!);
        Network = JsonConverters.fromJson(json['Network'],'InOutTimes',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AppLayer': JsonConverters.toJson(AppLayer,'InOutTimes',context!),
        'ParentLookup': JsonConverters.toJson(ParentLookup,'InOutTimes',context!),
        'RetryLookup': JsonConverters.toJson(RetryLookup,'InOutTimes',context!),
        'GetCardData': JsonConverters.toJson(GetCardData,'InOutTimes',context!),
        'CardTokenize': JsonConverters.toJson(CardTokenize,'InOutTimes',context!),
        'CardEncrypt': JsonConverters.toJson(CardEncrypt,'InOutTimes',context!),
        'DBInsert': JsonConverters.toJson(DBInsert,'InOutTimes',context!),
        'BackendProcess': JsonConverters.toJson(BackendProcess,'InOutTimes',context!),
        'DBUpdate': JsonConverters.toJson(DBUpdate,'InOutTimes',context!),
        'ParentUpdate': JsonConverters.toJson(ParentUpdate,'InOutTimes',context!),
        'Network': JsonConverters.toJson(Network,'InOutTimes',context!)
    };

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

// @DataContract
class PaysecureResponseInternal implements IConvertible
{
    // @DataMember(EmitDefaultValue=false)
    RequestTimestamps? Timestamps;

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

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

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

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

// @DataContract
class PaysecureVersion extends PaysecureResponseInternal implements IConvertible
{
    // @DataMember(EmitDefaultValue=false)
    String? LocalDateTime;

    // @DataMember(EmitDefaultValue=false)
    String? Token;

    // @DataMember(EmitDefaultValue=false)
    ExtendedResponse? ExtendedData;

    PaysecureVersion({this.LocalDateTime,this.Token,this.ExtendedData});
    PaysecureVersion.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'LocalDateTime': LocalDateTime,
        'Token': Token,
        'ExtendedData': JsonConverters.toJson(ExtendedData,'ExtendedResponse',context!)
    });

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

// @DataContract
class Refund extends PaysecureVersion implements IConvertible
{
    // @DataMember
    String? TranId;

    // @DataMember
    String? ApprovalCode;

    // @DataMember
    String? ResponseCode;

    // @DataMember
    String? Network;

    // @DataMember
    String? ErrorMessage;

    // @DataMember
    String? ErrorCode;

    Refund({this.TranId,this.ApprovalCode,this.ResponseCode,this.Network,this.ErrorMessage,this.ErrorCode});
    Refund.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        TranId = json['TranId'];
        ApprovalCode = json['ApprovalCode'];
        ResponseCode = json['ResponseCode'];
        Network = json['Network'];
        ErrorMessage = json['ErrorMessage'];
        ErrorCode = json['ErrorCode'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'TranId': TranId,
        'ApprovalCode': ApprovalCode,
        'ResponseCode': ResponseCode,
        'Network': Network,
        'ErrorMessage': ErrorMessage,
        'ErrorCode': ErrorCode
    });

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

// @Route("/ACHRefund", "POST")
// @DataContract
class AchRefundRequest implements IReturn<Refund>, IConvertible, IPost
{
    // @DataMember
    RequestorCredentials? Credentials;

    // @DataMember
    String? TranId;

    // @DataMember
    int? Amount;

    // @DataMember
    String? ReferenceKey;

    // @DataMember
    MerchantDescriptor? MerchantDetails;

    // @DataMember
    String? Custom1;

    // @DataMember
    String? Custom2;

    // @DataMember
    String? Custom3;

    // @DataMember
    String? Custom4;

    // @DataMember
    String? Custom5;

    // @DataMember
    String? SignatureHash;

    // @DataMember
    Avs? AVS;

    // @DataMember
    ACHExtendedData? ExtendedData;

    AchRefundRequest({this.Credentials,this.TranId,this.Amount,this.ReferenceKey,this.MerchantDetails,this.Custom1,this.Custom2,this.Custom3,this.Custom4,this.Custom5,this.SignatureHash,this.AVS,this.ExtendedData});
    AchRefundRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Credentials = JsonConverters.fromJson(json['Credentials'],'RequestorCredentials',context!);
        TranId = json['TranId'];
        Amount = json['Amount'];
        ReferenceKey = json['ReferenceKey'];
        MerchantDetails = JsonConverters.fromJson(json['MerchantDetails'],'MerchantDescriptor',context!);
        Custom1 = json['Custom1'];
        Custom2 = json['Custom2'];
        Custom3 = json['Custom3'];
        Custom4 = json['Custom4'];
        Custom5 = json['Custom5'];
        SignatureHash = json['SignatureHash'];
        AVS = JsonConverters.fromJson(json['AVS'],'Avs',context!);
        ExtendedData = JsonConverters.fromJson(json['ExtendedData'],'ACHExtendedData',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Credentials': JsonConverters.toJson(Credentials,'RequestorCredentials',context!),
        'TranId': TranId,
        'Amount': Amount,
        'ReferenceKey': ReferenceKey,
        'MerchantDetails': JsonConverters.toJson(MerchantDetails,'MerchantDescriptor',context!),
        'Custom1': Custom1,
        'Custom2': Custom2,
        'Custom3': Custom3,
        'Custom4': Custom4,
        'Custom5': Custom5,
        'SignatureHash': SignatureHash,
        'AVS': JsonConverters.toJson(AVS,'Avs',context!),
        'ExtendedData': JsonConverters.toJson(ExtendedData,'ACHExtendedData',context!)
    };

    createResponse() => Refund();
    getResponseTypeName() => "Refund";
    getTypeName() => "AchRefundRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.paysecure.acculynk.net', types: <String, TypeInfo> {
    'RequestorCredentials': TypeInfo(TypeOf.Class, create:() => RequestorCredentials()),
    'TelephoneType': TypeInfo(TypeOf.Enum, enumValues:TelephoneType.values),
    'Avs': TypeInfo(TypeOf.Class, create:() => Avs()),
    'MerchantDataElements': TypeInfo(TypeOf.Class, create:() => MerchantDataElements()),
    'MerchantDescriptorBase': TypeInfo(TypeOf.AbstractClass),
    'MerchantDescriptor': TypeInfo(TypeOf.Class, create:() => MerchantDescriptor()),
    'ACHExtendedData': TypeInfo(TypeOf.Class, create:() => ACHExtendedData()),
    'CardInfoType': TypeInfo(TypeOf.Enum, enumValues:CardInfoType.values),
    'CardAccountUpdaterDescriptor': TypeInfo(TypeOf.Class, create:() => CardAccountUpdaterDescriptor()),
    'ExtendedResponse': TypeInfo(TypeOf.Class, create:() => ExtendedResponse()),
    'InOutTimes': TypeInfo(TypeOf.Class, create:() => InOutTimes()),
    'RequestTimestamps': TypeInfo(TypeOf.Class, create:() => RequestTimestamps()),
    'PaysecureResponseInternal': TypeInfo(TypeOf.Class, create:() => PaysecureResponseInternal()),
    'PaysecureVersion': TypeInfo(TypeOf.Class, create:() => PaysecureVersion()),
    'Refund': TypeInfo(TypeOf.Class, create:() => Refund()),
    'AchRefundRequest': TypeInfo(TypeOf.Class, create:() => AchRefundRequest()),
});