/* Options:
Date: 2024-11-23 03:02:23
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: IncrementalAuthorizationRequest.*
//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;
}

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;
}

enum FundingSourceType
{
    DepositAccount,
    Credit,
    Debit,
    Prepaid,
}

class SenderInfo implements IConvertible
{
    String? ReferenceNumber;
    String? AccountNumber;
    /**
    * Name Format FirstName{Space}LastName. For Example :- Alvaro Morata
    */
    String? Name;
    String? Address;
    String? City;
    String? State;
    String? Country;
    /**
    * DateOfBirth Format MMDDYYYY. For Example :- 05051960
    */
    String? DateOfBirth;
    String? Zip;
    String? PhoneNumber;
    FundingSourceType? FundingSource;

    SenderInfo({this.ReferenceNumber,this.AccountNumber,this.Name,this.Address,this.City,this.State,this.Country,this.DateOfBirth,this.Zip,this.PhoneNumber,this.FundingSource});
    SenderInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ReferenceNumber = json['ReferenceNumber'];
        AccountNumber = json['AccountNumber'];
        Name = json['Name'];
        Address = json['Address'];
        City = json['City'];
        State = json['State'];
        Country = json['Country'];
        DateOfBirth = json['DateOfBirth'];
        Zip = json['Zip'];
        PhoneNumber = json['PhoneNumber'];
        FundingSource = JsonConverters.fromJson(json['FundingSource'],'FundingSourceType',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ReferenceNumber': ReferenceNumber,
        'AccountNumber': AccountNumber,
        'Name': Name,
        'Address': Address,
        'City': City,
        'State': State,
        'Country': Country,
        'DateOfBirth': DateOfBirth,
        'Zip': Zip,
        'PhoneNumber': PhoneNumber,
        'FundingSource': JsonConverters.toJson(FundingSource,'FundingSourceType',context!)
    };

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

enum NetworkName
{
    Default,
    NYCE,
    CU24,
    XCEL,
    STAR,
    PULS,
    SHZM,
    VISA,
    MAST,
    DISC,
    AMEX,
    ALIP,
    UPIN,
    STAC,
    STNE,
    MAES,
    INTL,
}

class ReceiverInfo implements IConvertible
{
    String? ReferenceNumber;
    String? AccountNumber;
    /**
    * Name Format FirstName{Space}LastName. For Example :- Alvaro Morata
    */
    String? Name;
    String? Address;
    String? City;
    String? State;
    String? Country;
    String? Zip;
    String? PhoneNumber;

    ReceiverInfo({this.ReferenceNumber,this.AccountNumber,this.Name,this.Address,this.City,this.State,this.Country,this.Zip,this.PhoneNumber});
    ReceiverInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ReferenceNumber = json['ReferenceNumber'];
        AccountNumber = json['AccountNumber'];
        Name = json['Name'];
        Address = json['Address'];
        City = json['City'];
        State = json['State'];
        Country = json['Country'];
        Zip = json['Zip'];
        PhoneNumber = json['PhoneNumber'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ReferenceNumber': ReferenceNumber,
        'AccountNumber': AccountNumber,
        'Name': Name,
        'Address': Address,
        'City': City,
        'State': State,
        'Country': Country,
        'Zip': Zip,
        'PhoneNumber': PhoneNumber
    };

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

enum BillPayGroup
{
    Default,
    Single,
    Recurring,
    Installment,
    Deferred,
}

enum DigitalWalletInfo
{
    Default,
    Staged,
    Passthrough,
}

class WalletDescriptor implements IConvertible
{
    String? Type;
    String? EncryptedData;
    String? ApplicationDataHash;
    String? EphemeralPublicKey;
    String? PublicKeyHash;
    String? TransactionId;
    String? Signature;
    String? Version;
    String? ApplicationData;
    String? MerchantIdentifier;
    String? SpecialPayment;
    DigitalWalletInfo? DigitalWalletIndicator;

    WalletDescriptor({this.Type,this.EncryptedData,this.ApplicationDataHash,this.EphemeralPublicKey,this.PublicKeyHash,this.TransactionId,this.Signature,this.Version,this.ApplicationData,this.MerchantIdentifier,this.SpecialPayment,this.DigitalWalletIndicator});
    WalletDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Type = json['Type'];
        EncryptedData = json['EncryptedData'];
        ApplicationDataHash = json['ApplicationDataHash'];
        EphemeralPublicKey = json['EphemeralPublicKey'];
        PublicKeyHash = json['PublicKeyHash'];
        TransactionId = json['TransactionId'];
        Signature = json['Signature'];
        Version = json['Version'];
        ApplicationData = json['ApplicationData'];
        MerchantIdentifier = json['MerchantIdentifier'];
        SpecialPayment = json['SpecialPayment'];
        DigitalWalletIndicator = JsonConverters.fromJson(json['DigitalWalletIndicator'],'DigitalWalletInfo',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Type': Type,
        'EncryptedData': EncryptedData,
        'ApplicationDataHash': ApplicationDataHash,
        'EphemeralPublicKey': EphemeralPublicKey,
        'PublicKeyHash': PublicKeyHash,
        'TransactionId': TransactionId,
        'Signature': Signature,
        'Version': Version,
        'ApplicationData': ApplicationData,
        'MerchantIdentifier': MerchantIdentifier,
        'SpecialPayment': SpecialPayment,
        'DigitalWalletIndicator': JsonConverters.toJson(DigitalWalletIndicator,'DigitalWalletInfo',context!)
    };

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

class SecureDescriptor implements IConvertible
{
    String? CAVV;
    String? SecureTransactionId;

    SecureDescriptor({this.CAVV,this.SecureTransactionId});
    SecureDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

enum TaxIndicator
{
    Default,
    NoTaxInfoProvided,
    TaxInfoProvided,
    TaxExemptItem,
}

class Level2Descriptor implements IConvertible
{
    TaxIndicator? TaxDetails;
    String? MerchantReferenceNumber;
    String? MerchantTaxId;
    String? OrderNumber;
    int? TaxAmount;
    String? DestinationPostalCode;
    String? ProductDescription;

    Level2Descriptor({this.TaxDetails,this.MerchantReferenceNumber,this.MerchantTaxId,this.OrderNumber,this.TaxAmount,this.DestinationPostalCode,this.ProductDescription});
    Level2Descriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TaxDetails = JsonConverters.fromJson(json['TaxDetails'],'TaxIndicator',context!);
        MerchantReferenceNumber = json['MerchantReferenceNumber'];
        MerchantTaxId = json['MerchantTaxId'];
        OrderNumber = json['OrderNumber'];
        TaxAmount = json['TaxAmount'];
        DestinationPostalCode = json['DestinationPostalCode'];
        ProductDescription = json['ProductDescription'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TaxDetails': JsonConverters.toJson(TaxDetails,'TaxIndicator',context!),
        'MerchantReferenceNumber': MerchantReferenceNumber,
        'MerchantTaxId': MerchantTaxId,
        'OrderNumber': OrderNumber,
        'TaxAmount': TaxAmount,
        'DestinationPostalCode': DestinationPostalCode,
        'ProductDescription': ProductDescription
    };

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

class PaymentFacilitatorDescriptor implements IConvertible
{
    String? PaymentFacilitatorIndicator;
    String? PFPhoneNumber;
    String? SubMerchID;
    String? SellerID;

    PaymentFacilitatorDescriptor({this.PaymentFacilitatorIndicator,this.PFPhoneNumber,this.SubMerchID,this.SellerID});
    PaymentFacilitatorDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PaymentFacilitatorIndicator = json['PaymentFacilitatorIndicator'];
        PFPhoneNumber = json['PFPhoneNumber'];
        SubMerchID = json['SubMerchID'];
        SellerID = json['SellerID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PaymentFacilitatorIndicator': PaymentFacilitatorIndicator,
        'PFPhoneNumber': PFPhoneNumber,
        'SubMerchID': SubMerchID,
        'SellerID': SellerID
    };

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

enum TokenTypes
{
    Default,
    UCAF,
    DSRP,
    UCAFDSRP,
    VisaVerified,
    DigitalWallet,
    VisaVerifiedDigitalWallet,
}

class TokenDescriptor implements IConvertible
{
    TokenTypes? TokenType;
    String? TokenCryptogramData1;
    String? TokenCryptogramData2;

    TokenDescriptor({this.TokenType,this.TokenCryptogramData1,this.TokenCryptogramData2});
    TokenDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'TokenType': JsonConverters.toJson(TokenType,'TokenTypes',context!),
        'TokenCryptogramData1': TokenCryptogramData1,
        'TokenCryptogramData2': TokenCryptogramData2
    };

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

enum CardonFileInfo
{
    Default,
    Supported,
    NotSupported,
}

enum StoredCredentialIndicatorInfo
{
    Default,
    Initial,
    Subsequent,
}

enum TransactionInitiateInfo
{
    Default,
    Merchant,
    Terminal,
    Customer,
}

enum ScheduleIndicatorInfo
{
    Default,
    Scheduled,
    Unscheduled,
}

class CardonFileIndicatorDescriptor implements IConvertible
{
    CardonFileInfo? CardonFile;
    StoredCredentialIndicatorInfo? StoredCredentialIndicator;
    TransactionInitiateInfo? TransactionInitiate;
    ScheduleIndicatorInfo? ScheduleIndicator;
    String? NetworkTransactionId;

    CardonFileIndicatorDescriptor({this.CardonFile,this.StoredCredentialIndicator,this.TransactionInitiate,this.ScheduleIndicator,this.NetworkTransactionId});
    CardonFileIndicatorDescriptor.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CardonFile = JsonConverters.fromJson(json['CardonFile'],'CardonFileInfo',context!);
        StoredCredentialIndicator = JsonConverters.fromJson(json['StoredCredentialIndicator'],'StoredCredentialIndicatorInfo',context!);
        TransactionInitiate = JsonConverters.fromJson(json['TransactionInitiate'],'TransactionInitiateInfo',context!);
        ScheduleIndicator = JsonConverters.fromJson(json['ScheduleIndicator'],'ScheduleIndicatorInfo',context!);
        NetworkTransactionId = json['NetworkTransactionId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CardonFile': JsonConverters.toJson(CardonFile,'CardonFileInfo',context!),
        'StoredCredentialIndicator': JsonConverters.toJson(StoredCredentialIndicator,'StoredCredentialIndicatorInfo',context!),
        'TransactionInitiate': JsonConverters.toJson(TransactionInitiate,'TransactionInitiateInfo',context!),
        'ScheduleIndicator': JsonConverters.toJson(ScheduleIndicator,'ScheduleIndicatorInfo',context!),
        'NetworkTransactionId': NetworkTransactionId
    };

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

enum CardAccountUpdaterInfo
{
    Default,
    Supported,
    NotSupported,
}

enum OrderTypeInfo
{
    Default,
    Standing,
    Subscription,
}

class BillPayGroupIndicator implements IConvertible
{
    String? MITTotalPaymentCount;
    String? MITAmountType;
    String? MITAmount;
    String? MITUniqueID;
    String? MITFrequency;
    String? MITValidationFlag;
    String? MITValidationReference;
    String? MITSequenceIndicator;

    BillPayGroupIndicator({this.MITTotalPaymentCount,this.MITAmountType,this.MITAmount,this.MITUniqueID,this.MITFrequency,this.MITValidationFlag,this.MITValidationReference,this.MITSequenceIndicator});
    BillPayGroupIndicator.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MITTotalPaymentCount = json['MITTotalPaymentCount'];
        MITAmountType = json['MITAmountType'];
        MITAmount = json['MITAmount'];
        MITUniqueID = json['MITUniqueID'];
        MITFrequency = json['MITFrequency'];
        MITValidationFlag = json['MITValidationFlag'];
        MITValidationReference = json['MITValidationReference'];
        MITSequenceIndicator = json['MITSequenceIndicator'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MITTotalPaymentCount': MITTotalPaymentCount,
        'MITAmountType': MITAmountType,
        'MITAmount': MITAmount,
        'MITUniqueID': MITUniqueID,
        'MITFrequency': MITFrequency,
        'MITValidationFlag': MITValidationFlag,
        'MITValidationReference': MITValidationReference,
        'MITSequenceIndicator': MITSequenceIndicator
    };

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

enum ChargeTypeInfo
{
    Default,
    PartialShipment,
    Delayed,
    NoShow,
    Resubmission,
}

enum SAFEligibleFlag
{
    Default,
    True,
    False,
}

// @DataContract
class ExtendedData implements IConvertible
{
    // @DataMember
    String? Track2DataForEMVTransaction;

    // @DataMember
    SenderInfo? SenderInfo;

    // @DataMember
    int? CashbackAmount;

    // @DataMember
    NetworkName? Network;

    // @DataMember
    ReceiverInfo? ReceiverInfo;

    // @DataMember
    BillPayGroup? BillPayGroup;

    // @DataMember
    WalletDescriptor? WalletData;

    // @DataMember
    SecureDescriptor? SecureData;

    // @DataMember
    Level2Descriptor? Level2Data;

    // @DataMember
    PaymentFacilitatorDescriptor? PaymentFacilitatorData;

    // @DataMember
    TokenDescriptor? TokenData;

    // @DataMember
    String? OTPTranId;

    // @DataMember
    int? CurrentShipment;

    // @DataMember
    int? TotalShipments;

    // @DataMember
    bool? IsTokenRequested;

    // @DataMember
    CardonFileIndicatorDescriptor? CardonFileIndicator;

    // @DataMember
    CardAccountUpdaterInfo? CardAccountUpdater;

    // @DataMember
    int? RetryAttemptCount;

    // @DataMember
    int? TotalAuthAmount;

    // @DataMember
    String? SignatureHashVersion;

    // @DataMember
    OrderTypeInfo? OrderTypeDetail;

    // @DataMember
    BillPayGroupIndicator? BillPayGroupIndicator;

    // @DataMember
    ChargeTypeInfo? ChargeTypeDetail;

    // @DataMember
    SAFEligibleFlag? SAFEligible;

    ExtendedData({this.Track2DataForEMVTransaction,this.SenderInfo,this.CashbackAmount,this.Network,this.ReceiverInfo,this.BillPayGroup,this.WalletData,this.SecureData,this.Level2Data,this.PaymentFacilitatorData,this.TokenData,this.OTPTranId,this.CurrentShipment,this.TotalShipments,this.IsTokenRequested,this.CardonFileIndicator,this.CardAccountUpdater,this.RetryAttemptCount,this.TotalAuthAmount,this.SignatureHashVersion,this.OrderTypeDetail,this.BillPayGroupIndicator,this.ChargeTypeDetail,this.SAFEligible});
    ExtendedData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Track2DataForEMVTransaction = json['Track2DataForEMVTransaction'];
        SenderInfo = JsonConverters.fromJson(json['SenderInfo'],'SenderInfo',context!);
        CashbackAmount = json['CashbackAmount'];
        Network = JsonConverters.fromJson(json['Network'],'NetworkName',context!);
        ReceiverInfo = JsonConverters.fromJson(json['ReceiverInfo'],'ReceiverInfo',context!);
        BillPayGroup = JsonConverters.fromJson(json['BillPayGroup'],'BillPayGroup',context!);
        WalletData = JsonConverters.fromJson(json['WalletData'],'WalletDescriptor',context!);
        SecureData = JsonConverters.fromJson(json['SecureData'],'SecureDescriptor',context!);
        Level2Data = JsonConverters.fromJson(json['Level2Data'],'Level2Descriptor',context!);
        PaymentFacilitatorData = JsonConverters.fromJson(json['PaymentFacilitatorData'],'PaymentFacilitatorDescriptor',context!);
        TokenData = JsonConverters.fromJson(json['TokenData'],'TokenDescriptor',context!);
        OTPTranId = json['OTPTranId'];
        CurrentShipment = json['CurrentShipment'];
        TotalShipments = json['TotalShipments'];
        IsTokenRequested = json['IsTokenRequested'];
        CardonFileIndicator = JsonConverters.fromJson(json['CardonFileIndicator'],'CardonFileIndicatorDescriptor',context!);
        CardAccountUpdater = JsonConverters.fromJson(json['CardAccountUpdater'],'CardAccountUpdaterInfo',context!);
        RetryAttemptCount = json['RetryAttemptCount'];
        TotalAuthAmount = json['TotalAuthAmount'];
        SignatureHashVersion = json['SignatureHashVersion'];
        OrderTypeDetail = JsonConverters.fromJson(json['OrderTypeDetail'],'OrderTypeInfo',context!);
        BillPayGroupIndicator = JsonConverters.fromJson(json['BillPayGroupIndicator'],'BillPayGroupIndicator',context!);
        ChargeTypeDetail = JsonConverters.fromJson(json['ChargeTypeDetail'],'ChargeTypeInfo',context!);
        SAFEligible = JsonConverters.fromJson(json['SAFEligible'],'SAFEligibleFlag',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Track2DataForEMVTransaction': Track2DataForEMVTransaction,
        'SenderInfo': JsonConverters.toJson(SenderInfo,'SenderInfo',context!),
        'CashbackAmount': CashbackAmount,
        'Network': JsonConverters.toJson(Network,'NetworkName',context!),
        'ReceiverInfo': JsonConverters.toJson(ReceiverInfo,'ReceiverInfo',context!),
        'BillPayGroup': JsonConverters.toJson(BillPayGroup,'BillPayGroup',context!),
        'WalletData': JsonConverters.toJson(WalletData,'WalletDescriptor',context!),
        'SecureData': JsonConverters.toJson(SecureData,'SecureDescriptor',context!),
        'Level2Data': JsonConverters.toJson(Level2Data,'Level2Descriptor',context!),
        'PaymentFacilitatorData': JsonConverters.toJson(PaymentFacilitatorData,'PaymentFacilitatorDescriptor',context!),
        'TokenData': JsonConverters.toJson(TokenData,'TokenDescriptor',context!),
        'OTPTranId': OTPTranId,
        'CurrentShipment': CurrentShipment,
        'TotalShipments': TotalShipments,
        'IsTokenRequested': IsTokenRequested,
        'CardonFileIndicator': JsonConverters.toJson(CardonFileIndicator,'CardonFileIndicatorDescriptor',context!),
        'CardAccountUpdater': JsonConverters.toJson(CardAccountUpdater,'CardAccountUpdaterInfo',context!),
        'RetryAttemptCount': RetryAttemptCount,
        'TotalAuthAmount': TotalAuthAmount,
        'SignatureHashVersion': SignatureHashVersion,
        'OrderTypeDetail': JsonConverters.toJson(OrderTypeDetail,'OrderTypeInfo',context!),
        'BillPayGroupIndicator': JsonConverters.toJson(BillPayGroupIndicator,'BillPayGroupIndicator',context!),
        'ChargeTypeDetail': JsonConverters.toJson(ChargeTypeDetail,'ChargeTypeInfo',context!),
        'SAFEligible': JsonConverters.toJson(SAFEligible,'SAFEligibleFlag',context!)
    };

    getTypeName() => "ExtendedData";
    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 IncrementalAuthorization extends PaysecureVersion implements IConvertible
{
    // @DataMember
    String? ApprovalCode;

    // @DataMember
    String? TranId;

    // @DataMember
    String? ResponseCode;

    // @DataMember
    String? ErrorMessage;

    // @DataMember
    String? ErrorCode;

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

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

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

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

// @Route("/IncrementalAuthorization", "POST")
// @DataContract
class IncrementalAuthorizationRequest implements IReturn<IncrementalAuthorization>, 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
    ExtendedData? ExtendedData;

    // @DataMember
    String? IntegratorID;

    IncrementalAuthorizationRequest({this.Credentials,this.TranId,this.Amount,this.ReferenceKey,this.MerchantDetails,this.Custom1,this.Custom2,this.Custom3,this.Custom4,this.Custom5,this.SignatureHash,this.ExtendedData,this.IntegratorID});
    IncrementalAuthorizationRequest.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'];
        ExtendedData = JsonConverters.fromJson(json['ExtendedData'],'ExtendedData',context!);
        IntegratorID = json['IntegratorID'];
        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,
        'ExtendedData': JsonConverters.toJson(ExtendedData,'ExtendedData',context!),
        'IntegratorID': IntegratorID
    };

    createResponse() => IncrementalAuthorization();
    getResponseTypeName() => "IncrementalAuthorization";
    getTypeName() => "IncrementalAuthorizationRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.paysecure.acculynk.net', types: <String, TypeInfo> {
    'RequestorCredentials': TypeInfo(TypeOf.Class, create:() => RequestorCredentials()),
    'MerchantDataElements': TypeInfo(TypeOf.Class, create:() => MerchantDataElements()),
    'MerchantDescriptorBase': TypeInfo(TypeOf.AbstractClass),
    'MerchantDescriptor': TypeInfo(TypeOf.Class, create:() => MerchantDescriptor()),
    'FundingSourceType': TypeInfo(TypeOf.Enum, enumValues:FundingSourceType.values),
    'SenderInfo': TypeInfo(TypeOf.Class, create:() => SenderInfo()),
    'NetworkName': TypeInfo(TypeOf.Enum, enumValues:NetworkName.values),
    'ReceiverInfo': TypeInfo(TypeOf.Class, create:() => ReceiverInfo()),
    'BillPayGroup': TypeInfo(TypeOf.Enum, enumValues:BillPayGroup.values),
    'DigitalWalletInfo': TypeInfo(TypeOf.Enum, enumValues:DigitalWalletInfo.values),
    'WalletDescriptor': TypeInfo(TypeOf.Class, create:() => WalletDescriptor()),
    'SecureDescriptor': TypeInfo(TypeOf.Class, create:() => SecureDescriptor()),
    'TaxIndicator': TypeInfo(TypeOf.Enum, enumValues:TaxIndicator.values),
    'Level2Descriptor': TypeInfo(TypeOf.Class, create:() => Level2Descriptor()),
    'PaymentFacilitatorDescriptor': TypeInfo(TypeOf.Class, create:() => PaymentFacilitatorDescriptor()),
    'TokenTypes': TypeInfo(TypeOf.Enum, enumValues:TokenTypes.values),
    'TokenDescriptor': TypeInfo(TypeOf.Class, create:() => TokenDescriptor()),
    'CardonFileInfo': TypeInfo(TypeOf.Enum, enumValues:CardonFileInfo.values),
    'StoredCredentialIndicatorInfo': TypeInfo(TypeOf.Enum, enumValues:StoredCredentialIndicatorInfo.values),
    'TransactionInitiateInfo': TypeInfo(TypeOf.Enum, enumValues:TransactionInitiateInfo.values),
    'ScheduleIndicatorInfo': TypeInfo(TypeOf.Enum, enumValues:ScheduleIndicatorInfo.values),
    'CardonFileIndicatorDescriptor': TypeInfo(TypeOf.Class, create:() => CardonFileIndicatorDescriptor()),
    'CardAccountUpdaterInfo': TypeInfo(TypeOf.Enum, enumValues:CardAccountUpdaterInfo.values),
    'OrderTypeInfo': TypeInfo(TypeOf.Enum, enumValues:OrderTypeInfo.values),
    'BillPayGroupIndicator': TypeInfo(TypeOf.Class, create:() => BillPayGroupIndicator()),
    'ChargeTypeInfo': TypeInfo(TypeOf.Enum, enumValues:ChargeTypeInfo.values),
    'SAFEligibleFlag': TypeInfo(TypeOf.Enum, enumValues:SAFEligibleFlag.values),
    'ExtendedData': TypeInfo(TypeOf.Class, create:() => ExtendedData()),
    '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()),
    'IncrementalAuthorization': TypeInfo(TypeOf.Class, create:() => IncrementalAuthorization()),
    'IncrementalAuthorizationRequest': TypeInfo(TypeOf.Class, create:() => IncrementalAuthorizationRequest()),
});