/* Options:
Date: 2025-07-18 01:16:48
Version: 6.40
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://hcbtas-q-albamfs-api.azurewebsites.net

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

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

class TransactionHeader implements IConvertible
{
    int? versionNumber;
    String? transactionId;
    int? transactionsTypeNumber;
    DateTime? eventTime;

    TransactionHeader({this.versionNumber,this.transactionId,this.transactionsTypeNumber,this.eventTime});
    TransactionHeader.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        versionNumber = json['versionNumber'];
        transactionId = json['transactionId'];
        transactionsTypeNumber = json['transactionsTypeNumber'];
        eventTime = JsonConverters.fromJson(json['eventTime'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'versionNumber': versionNumber,
        'transactionId': transactionId,
        'transactionsTypeNumber': transactionsTypeNumber,
        'eventTime': JsonConverters.toJson(eventTime,'DateTime',context!)
    };

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

class SendPensionPlanHeader extends TransactionHeader implements IConvertible
{
    String? socialSecurityNumber;
    String? cohabitantSocialSecurityNumber;
    Uint8List? customerRemark;
    String? systemInfo;
    int? pensionProviderId;

    SendPensionPlanHeader({this.socialSecurityNumber,this.cohabitantSocialSecurityNumber,this.customerRemark,this.systemInfo,this.pensionProviderId});
    SendPensionPlanHeader.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        socialSecurityNumber = json['socialSecurityNumber'];
        cohabitantSocialSecurityNumber = json['cohabitantSocialSecurityNumber'];
        customerRemark = JsonConverters.fromJson(json['customerRemark'],'Uint8List',context!);
        systemInfo = json['systemInfo'];
        pensionProviderId = json['pensionProviderId'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'socialSecurityNumber': socialSecurityNumber,
        'cohabitantSocialSecurityNumber': cohabitantSocialSecurityNumber,
        'customerRemark': JsonConverters.toJson(customerRemark,'Uint8List',context!),
        'systemInfo': systemInfo,
        'pensionProviderId': pensionProviderId
    });

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

class Pdf implements IConvertible
{
    Uint8List? pdfReport;

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

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

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

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

class RemarkVer9DTO implements IConvertible
{
    int? typeNumber;
    int? number;
    String? text;

    RemarkVer9DTO({this.typeNumber,this.number,this.text});
    RemarkVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'typeNumber': typeNumber,
        'number': number,
        'text': text
    };

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

class PremiumWaiverBenefitVer9DTO implements IConvertible
{
    bool? isEligible;
    bool? isActive;
    int? value;

    PremiumWaiverBenefitVer9DTO({this.isEligible,this.isActive,this.value});
    PremiumWaiverBenefitVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'isEligible': isEligible,
        'isActive': isActive,
        'value': value
    };

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

class BenefitPaymentVer9DTO implements IConvertible
{
    int? benefitPayment;
    int? paymentYearToDate;
    DateTime? latestPaymentDate;

    BenefitPaymentVer9DTO({this.benefitPayment,this.paymentYearToDate,this.latestPaymentDate});
    BenefitPaymentVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'benefitPayment': benefitPayment,
        'paymentYearToDate': paymentYearToDate,
        'latestPaymentDate': JsonConverters.toJson(latestPaymentDate,'DateTime',context!)
    };

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

class PayoutForecastVer9DTO implements IConvertible
{
    int? age;
    int? amount;

    PayoutForecastVer9DTO({this.age,this.amount});
    PayoutForecastVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class BeneficiaryVer9DTO implements IConvertible
{
    String? name;
    int? percentage;
    int? typeNumber;
    String? typeText;

    BeneficiaryVer9DTO({this.name,this.percentage,this.typeNumber,this.typeText});
    BeneficiaryVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        name = json['name'];
        percentage = json['percentage'];
        typeNumber = json['typeNumber'];
        typeText = json['typeText'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'name': name,
        'percentage': percentage,
        'typeNumber': typeNumber,
        'typeText': typeText
    };

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

class DateAgeTypeVer9DTO implements IConvertible
{
    DateTime? date;
    int? age;

    DateAgeTypeVer9DTO({this.date,this.age});
    DateAgeTypeVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'date': JsonConverters.toJson(date,'DateTime',context!),
        'age': age
    };

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

class PayoutVer9DTO implements IConvertible
{
    bool? currentPayment;
    List<PayoutForecastVer9DTO>? payoutForecasts;
    int? paymentFormNumber;
    String? paymentFormText;
    int? paymentTaxationNumber;
    String? paymentTaxationText;
    int? receiverNumber;
    String? receiverText;
    int? conditionNumber;
    String? conditionText;
    int? conditionParameter;
    List<BeneficiaryVer9DTO>? beneficiaries;
    DateAgeTypeVer9DTO? payoutStart;
    DateAgeTypeVer9DTO? payoutEnd;
    DateAgeTypeVer9DTO? latestPossiblePayout;
    DateAgeTypeVer9DTO? earliestPossiblePayout;
    DateAgeTypeVer9DTO? latestPayoutStart;
    int? paymentYears;

    PayoutVer9DTO({this.currentPayment,this.payoutForecasts,this.paymentFormNumber,this.paymentFormText,this.paymentTaxationNumber,this.paymentTaxationText,this.receiverNumber,this.receiverText,this.conditionNumber,this.conditionText,this.conditionParameter,this.beneficiaries,this.payoutStart,this.payoutEnd,this.latestPossiblePayout,this.earliestPossiblePayout,this.latestPayoutStart,this.paymentYears});
    PayoutVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        currentPayment = json['currentPayment'];
        payoutForecasts = JsonConverters.fromJson(json['payoutForecasts'],'List<PayoutForecastVer9DTO>',context!);
        paymentFormNumber = json['paymentFormNumber'];
        paymentFormText = json['paymentFormText'];
        paymentTaxationNumber = json['paymentTaxationNumber'];
        paymentTaxationText = json['paymentTaxationText'];
        receiverNumber = json['receiverNumber'];
        receiverText = json['receiverText'];
        conditionNumber = json['conditionNumber'];
        conditionText = json['conditionText'];
        conditionParameter = json['conditionParameter'];
        beneficiaries = JsonConverters.fromJson(json['beneficiaries'],'List<BeneficiaryVer9DTO>',context!);
        payoutStart = JsonConverters.fromJson(json['payoutStart'],'DateAgeTypeVer9DTO',context!);
        payoutEnd = JsonConverters.fromJson(json['payoutEnd'],'DateAgeTypeVer9DTO',context!);
        latestPossiblePayout = JsonConverters.fromJson(json['latestPossiblePayout'],'DateAgeTypeVer9DTO',context!);
        earliestPossiblePayout = JsonConverters.fromJson(json['earliestPossiblePayout'],'DateAgeTypeVer9DTO',context!);
        latestPayoutStart = JsonConverters.fromJson(json['latestPayoutStart'],'DateAgeTypeVer9DTO',context!);
        paymentYears = json['paymentYears'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'currentPayment': currentPayment,
        'payoutForecasts': JsonConverters.toJson(payoutForecasts,'List<PayoutForecastVer9DTO>',context!),
        'paymentFormNumber': paymentFormNumber,
        'paymentFormText': paymentFormText,
        'paymentTaxationNumber': paymentTaxationNumber,
        'paymentTaxationText': paymentTaxationText,
        'receiverNumber': receiverNumber,
        'receiverText': receiverText,
        'conditionNumber': conditionNumber,
        'conditionText': conditionText,
        'conditionParameter': conditionParameter,
        'beneficiaries': JsonConverters.toJson(beneficiaries,'List<BeneficiaryVer9DTO>',context!),
        'payoutStart': JsonConverters.toJson(payoutStart,'DateAgeTypeVer9DTO',context!),
        'payoutEnd': JsonConverters.toJson(payoutEnd,'DateAgeTypeVer9DTO',context!),
        'latestPossiblePayout': JsonConverters.toJson(latestPossiblePayout,'DateAgeTypeVer9DTO',context!),
        'earliestPossiblePayout': JsonConverters.toJson(earliestPossiblePayout,'DateAgeTypeVer9DTO',context!),
        'latestPayoutStart': JsonConverters.toJson(latestPayoutStart,'DateAgeTypeVer9DTO',context!),
        'paymentYears': paymentYears
    };

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

class RiskBenefitVer9DTO implements IConvertible
{
    bool? shadowBenefit;
    int? amount;
    DateTime? amountDate;
    DateAgeTypeVer9DTO? riskTermination;
    int? benefitExtentNumber;
    List<int>? benefitDetail;

    RiskBenefitVer9DTO({this.shadowBenefit,this.amount,this.amountDate,this.riskTermination,this.benefitExtentNumber,this.benefitDetail});
    RiskBenefitVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        shadowBenefit = json['shadowBenefit'];
        amount = json['amount'];
        amountDate = JsonConverters.fromJson(json['amountDate'],'DateTime',context!);
        riskTermination = JsonConverters.fromJson(json['riskTermination'],'DateAgeTypeVer9DTO',context!);
        benefitExtentNumber = json['benefitExtentNumber'];
        benefitDetail = JsonConverters.fromJson(json['benefitDetail'],'List<int>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'shadowBenefit': shadowBenefit,
        'amount': amount,
        'amountDate': JsonConverters.toJson(amountDate,'DateTime',context!),
        'riskTermination': JsonConverters.toJson(riskTermination,'DateAgeTypeVer9DTO',context!),
        'benefitExtentNumber': benefitExtentNumber,
        'benefitDetail': JsonConverters.toJson(benefitDetail,'List<int>',context!)
    };

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

class InvestmentDistributionVer9DTO implements IConvertible
{
    int? investmentFormNumber;
    String? investmentIdentification;
    int? investmentValue;
    DateTime? investmentValueDate;
    int? pendingYieldAmount;

    InvestmentDistributionVer9DTO({this.investmentFormNumber,this.investmentIdentification,this.investmentValue,this.investmentValueDate,this.pendingYieldAmount});
    InvestmentDistributionVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        investmentFormNumber = json['investmentFormNumber'];
        investmentIdentification = json['investmentIdentification'];
        investmentValue = json['investmentValue'];
        investmentValueDate = JsonConverters.fromJson(json['investmentValueDate'],'DateTime',context!);
        pendingYieldAmount = json['pendingYieldAmount'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'investmentFormNumber': investmentFormNumber,
        'investmentIdentification': investmentIdentification,
        'investmentValue': investmentValue,
        'investmentValueDate': JsonConverters.toJson(investmentValueDate,'DateTime',context!),
        'pendingYieldAmount': pendingYieldAmount
    };

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

class ForecastVer9DTO implements IConvertible
{
    int? age;
    int? amount;

    ForecastVer9DTO({this.age,this.amount});
    ForecastVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class ForecastCalculationVer9DTO implements IConvertible
{
    int? forecastStartAge;
    List<RemarkVer9DTO>? remarks;
    List<ForecastVer9DTO>? forecasts;

    ForecastCalculationVer9DTO({this.forecastStartAge,this.remarks,this.forecasts});
    ForecastCalculationVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'forecastStartAge': forecastStartAge,
        'remarks': JsonConverters.toJson(remarks,'List<RemarkVer9DTO>',context!),
        'forecasts': JsonConverters.toJson(forecasts,'List<ForecastVer9DTO>',context!)
    };

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

class PensionForecastsVer9DTO implements IConvertible
{
    bool? pensionPayment;
    bool? earlyRetirementDeduction;
    bool? calculateForecasts;
    int? forecastInterestType;
    bool? priceIndexRegulated;
    bool? realIncomeRegulated;
    bool? enterPaymentEnabled;
    DateTime? forecastCalculationDate;
    List<ForecastCalculationVer9DTO>? forecastsCalculations;

    PensionForecastsVer9DTO({this.pensionPayment,this.earlyRetirementDeduction,this.calculateForecasts,this.forecastInterestType,this.priceIndexRegulated,this.realIncomeRegulated,this.enterPaymentEnabled,this.forecastCalculationDate,this.forecastsCalculations});
    PensionForecastsVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pensionPayment = json['pensionPayment'];
        earlyRetirementDeduction = json['earlyRetirementDeduction'];
        calculateForecasts = json['calculateForecasts'];
        forecastInterestType = json['forecastInterestType'];
        priceIndexRegulated = json['priceIndexRegulated'];
        realIncomeRegulated = json['realIncomeRegulated'];
        enterPaymentEnabled = json['enterPaymentEnabled'];
        forecastCalculationDate = JsonConverters.fromJson(json['forecastCalculationDate'],'DateTime',context!);
        forecastsCalculations = JsonConverters.fromJson(json['forecastsCalculations'],'List<ForecastCalculationVer9DTO>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pensionPayment': pensionPayment,
        'earlyRetirementDeduction': earlyRetirementDeduction,
        'calculateForecasts': calculateForecasts,
        'forecastInterestType': forecastInterestType,
        'priceIndexRegulated': priceIndexRegulated,
        'realIncomeRegulated': realIncomeRegulated,
        'enterPaymentEnabled': enterPaymentEnabled,
        'forecastCalculationDate': JsonConverters.toJson(forecastCalculationDate,'DateTime',context!),
        'forecastsCalculations': JsonConverters.toJson(forecastsCalculations,'List<ForecastCalculationVer9DTO>',context!)
    };

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

class PensionBenefitVer9DTO implements IConvertible
{
    int? pensionTypeNumber;
    String? pensionType;
    int? indexContractCount;
    List<InvestmentDistributionVer9DTO>? investmentDistributions;
    PensionForecastsVer9DTO? pensionForecasts;

    PensionBenefitVer9DTO({this.pensionTypeNumber,this.pensionType,this.indexContractCount,this.investmentDistributions,this.pensionForecasts});
    PensionBenefitVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pensionTypeNumber = json['pensionTypeNumber'];
        pensionType = json['pensionType'];
        indexContractCount = json['indexContractCount'];
        investmentDistributions = JsonConverters.fromJson(json['investmentDistributions'],'List<InvestmentDistributionVer9DTO>',context!);
        pensionForecasts = JsonConverters.fromJson(json['pensionForecasts'],'PensionForecastsVer9DTO',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pensionTypeNumber': pensionTypeNumber,
        'pensionType': pensionType,
        'indexContractCount': indexContractCount,
        'investmentDistributions': JsonConverters.toJson(investmentDistributions,'List<InvestmentDistributionVer9DTO>',context!),
        'pensionForecasts': JsonConverters.toJson(pensionForecasts,'PensionForecastsVer9DTO',context!)
    };

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

class BenefitVer9DTO implements IConvertible
{
    int? transactionStatus;
    int? typeNumber;
    String? typeText;
    int? subscriptionTypeNumber;
    String? subscriptionTypeText;
    bool? canBeShownInGraph;
    String? moreInfoUrl;
    String? systemInfo;
    PremiumWaiverBenefitVer9DTO? premiumWaiverBenefit;
    BenefitPaymentVer9DTO? payment;
    PayoutVer9DTO? payout;
    RiskBenefitVer9DTO? risk;
    PensionBenefitVer9DTO? pension;
    List<RemarkVer9DTO>? remarks;

    BenefitVer9DTO({this.transactionStatus,this.typeNumber,this.typeText,this.subscriptionTypeNumber,this.subscriptionTypeText,this.canBeShownInGraph,this.moreInfoUrl,this.systemInfo,this.premiumWaiverBenefit,this.payment,this.payout,this.risk,this.pension,this.remarks});
    BenefitVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        transactionStatus = json['transactionStatus'];
        typeNumber = json['typeNumber'];
        typeText = json['typeText'];
        subscriptionTypeNumber = json['subscriptionTypeNumber'];
        subscriptionTypeText = json['subscriptionTypeText'];
        canBeShownInGraph = json['canBeShownInGraph'];
        moreInfoUrl = json['moreInfoUrl'];
        systemInfo = json['systemInfo'];
        premiumWaiverBenefit = JsonConverters.fromJson(json['premiumWaiverBenefit'],'PremiumWaiverBenefitVer9DTO',context!);
        payment = JsonConverters.fromJson(json['payment'],'BenefitPaymentVer9DTO',context!);
        payout = JsonConverters.fromJson(json['payout'],'PayoutVer9DTO',context!);
        risk = JsonConverters.fromJson(json['risk'],'RiskBenefitVer9DTO',context!);
        pension = JsonConverters.fromJson(json['pension'],'PensionBenefitVer9DTO',context!);
        remarks = JsonConverters.fromJson(json['remarks'],'List<RemarkVer9DTO>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'transactionStatus': transactionStatus,
        'typeNumber': typeNumber,
        'typeText': typeText,
        'subscriptionTypeNumber': subscriptionTypeNumber,
        'subscriptionTypeText': subscriptionTypeText,
        'canBeShownInGraph': canBeShownInGraph,
        'moreInfoUrl': moreInfoUrl,
        'systemInfo': systemInfo,
        'premiumWaiverBenefit': JsonConverters.toJson(premiumWaiverBenefit,'PremiumWaiverBenefitVer9DTO',context!),
        'payment': JsonConverters.toJson(payment,'BenefitPaymentVer9DTO',context!),
        'payout': JsonConverters.toJson(payout,'PayoutVer9DTO',context!),
        'risk': JsonConverters.toJson(risk,'RiskBenefitVer9DTO',context!),
        'pension': JsonConverters.toJson(pension,'PensionBenefitVer9DTO',context!),
        'remarks': JsonConverters.toJson(remarks,'List<RemarkVer9DTO>',context!)
    };

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

class PensionSchemeVer9DTO implements IConvertible
{
    int? transactionStatus;
    String? referenceNumber;
    int? typeNumber;
    int? phone;
    String? contact;
    String? email;
    int? payment;
    DateTime? paymentDate;
    int? savedValue;
    DateTime? savedValueDate;
    int? savedValuePresentation;
    String? systemInfoScheme;
    int? businessPartnerNumber;
    int? guarantees;
    int? transferCosts;
    int? transferCostsJobChange;
    int? repurchase;
    Uint8List? repurchaseText;
    bool? hasWithdrawalPenalty;
    bool? benefitComposition;
    int? investmentFormNumber;
    String? businessPartner;
    int? wordSplitCharacter;
    List<RemarkVer9DTO>? remarks;
    List<BenefitVer9DTO>? benefits;

    PensionSchemeVer9DTO({this.transactionStatus,this.referenceNumber,this.typeNumber,this.phone,this.contact,this.email,this.payment,this.paymentDate,this.savedValue,this.savedValueDate,this.savedValuePresentation,this.systemInfoScheme,this.businessPartnerNumber,this.guarantees,this.transferCosts,this.transferCostsJobChange,this.repurchase,this.repurchaseText,this.hasWithdrawalPenalty,this.benefitComposition,this.investmentFormNumber,this.businessPartner,this.wordSplitCharacter,this.remarks,this.benefits});
    PensionSchemeVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        transactionStatus = json['transactionStatus'];
        referenceNumber = json['referenceNumber'];
        typeNumber = json['typeNumber'];
        phone = json['phone'];
        contact = json['contact'];
        email = json['email'];
        payment = json['payment'];
        paymentDate = JsonConverters.fromJson(json['paymentDate'],'DateTime',context!);
        savedValue = json['savedValue'];
        savedValueDate = JsonConverters.fromJson(json['savedValueDate'],'DateTime',context!);
        savedValuePresentation = json['savedValuePresentation'];
        systemInfoScheme = json['systemInfoScheme'];
        businessPartnerNumber = json['businessPartnerNumber'];
        guarantees = json['guarantees'];
        transferCosts = json['transferCosts'];
        transferCostsJobChange = json['transferCostsJobChange'];
        repurchase = json['repurchase'];
        repurchaseText = JsonConverters.fromJson(json['repurchaseText'],'Uint8List',context!);
        hasWithdrawalPenalty = json['hasWithdrawalPenalty'];
        benefitComposition = json['benefitComposition'];
        investmentFormNumber = json['investmentFormNumber'];
        businessPartner = json['businessPartner'];
        wordSplitCharacter = json['wordSplitCharacter'];
        remarks = JsonConverters.fromJson(json['remarks'],'List<RemarkVer9DTO>',context!);
        benefits = JsonConverters.fromJson(json['benefits'],'List<BenefitVer9DTO>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'transactionStatus': transactionStatus,
        'referenceNumber': referenceNumber,
        'typeNumber': typeNumber,
        'phone': phone,
        'contact': contact,
        'email': email,
        'payment': payment,
        'paymentDate': JsonConverters.toJson(paymentDate,'DateTime',context!),
        'savedValue': savedValue,
        'savedValueDate': JsonConverters.toJson(savedValueDate,'DateTime',context!),
        'savedValuePresentation': savedValuePresentation,
        'systemInfoScheme': systemInfoScheme,
        'businessPartnerNumber': businessPartnerNumber,
        'guarantees': guarantees,
        'transferCosts': transferCosts,
        'transferCostsJobChange': transferCostsJobChange,
        'repurchase': repurchase,
        'repurchaseText': JsonConverters.toJson(repurchaseText,'Uint8List',context!),
        'hasWithdrawalPenalty': hasWithdrawalPenalty,
        'benefitComposition': benefitComposition,
        'investmentFormNumber': investmentFormNumber,
        'businessPartner': businessPartner,
        'wordSplitCharacter': wordSplitCharacter,
        'remarks': JsonConverters.toJson(remarks,'List<RemarkVer9DTO>',context!),
        'benefits': JsonConverters.toJson(benefits,'List<BenefitVer9DTO>',context!)
    };

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

class PensionProviderVer9DTO implements IConvertible
{
    int? pensionProviderId;
    String? pensionProviderName;
    int? wordSplitCharacter;
    String? webSiteUrl;
    String? currencyCode;
    String? advisorName;
    bool? receiveDataForAdvisory;
    int? transactionStatus;
    List<PensionSchemeVer9DTO>? schemes;
    List<RemarkVer9DTO>? transactionRemarks;

    PensionProviderVer9DTO({this.pensionProviderId,this.pensionProviderName,this.wordSplitCharacter,this.webSiteUrl,this.currencyCode,this.advisorName,this.receiveDataForAdvisory,this.transactionStatus,this.schemes,this.transactionRemarks});
    PensionProviderVer9DTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pensionProviderId = json['pensionProviderId'];
        pensionProviderName = json['pensionProviderName'];
        wordSplitCharacter = json['wordSplitCharacter'];
        webSiteUrl = json['webSiteUrl'];
        currencyCode = json['currencyCode'];
        advisorName = json['advisorName'];
        receiveDataForAdvisory = json['receiveDataForAdvisory'];
        transactionStatus = json['transactionStatus'];
        schemes = JsonConverters.fromJson(json['schemes'],'List<PensionSchemeVer9DTO>',context!);
        transactionRemarks = JsonConverters.fromJson(json['transactionRemarks'],'List<RemarkVer9DTO>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pensionProviderId': pensionProviderId,
        'pensionProviderName': pensionProviderName,
        'wordSplitCharacter': wordSplitCharacter,
        'webSiteUrl': webSiteUrl,
        'currencyCode': currencyCode,
        'advisorName': advisorName,
        'receiveDataForAdvisory': receiveDataForAdvisory,
        'transactionStatus': transactionStatus,
        'schemes': JsonConverters.toJson(schemes,'List<PensionSchemeVer9DTO>',context!),
        'transactionRemarks': JsonConverters.toJson(transactionRemarks,'List<RemarkVer9DTO>',context!)
    };

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

class AnswerSendPensionPlanHeader extends TransactionHeader implements IConvertible
{
    String? socialSecurityNumber;
    bool? reportReceived;
    Uint8List? providerRemark;
    String? errorText;

    AnswerSendPensionPlanHeader({this.socialSecurityNumber,this.reportReceived,this.providerRemark,this.errorText});
    AnswerSendPensionPlanHeader.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        socialSecurityNumber = json['socialSecurityNumber'];
        reportReceived = json['reportReceived'];
        providerRemark = JsonConverters.fromJson(json['providerRemark'],'Uint8List',context!);
        errorText = json['errorText'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'socialSecurityNumber': socialSecurityNumber,
        'reportReceived': reportReceived,
        'providerRemark': JsonConverters.toJson(providerRemark,'Uint8List',context!),
        'errorText': errorText
    });

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

class SendPensionPlanToProviderResponseVer9DTO implements IConvertible
{
    AnswerSendPensionPlanHeader? header;

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

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

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

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

// @Route("/ext/pensionsinfo", "POST")
class PensionsInfoExtReq implements IReturn<SendPensionPlanToProviderResponseVer9DTO>, IConvertible
{
    SendPensionPlanHeader? header;
    Pdf? pdf;
    Pdf? cohabitantPdf;
    List<PensionProviderVer9DTO>? pensionProviders;
    List<PensionProviderVer9DTO>? cohabitantPensionProviders;

    PensionsInfoExtReq({this.header,this.pdf,this.cohabitantPdf,this.pensionProviders,this.cohabitantPensionProviders});
    PensionsInfoExtReq.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        header = JsonConverters.fromJson(json['header'],'SendPensionPlanHeader',context!);
        pdf = JsonConverters.fromJson(json['pdf'],'Pdf',context!);
        cohabitantPdf = JsonConverters.fromJson(json['cohabitantPdf'],'Pdf',context!);
        pensionProviders = JsonConverters.fromJson(json['pensionProviders'],'List<PensionProviderVer9DTO>',context!);
        cohabitantPensionProviders = JsonConverters.fromJson(json['cohabitantPensionProviders'],'List<PensionProviderVer9DTO>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'header': JsonConverters.toJson(header,'SendPensionPlanHeader',context!),
        'pdf': JsonConverters.toJson(pdf,'Pdf',context!),
        'cohabitantPdf': JsonConverters.toJson(cohabitantPdf,'Pdf',context!),
        'pensionProviders': JsonConverters.toJson(pensionProviders,'List<PensionProviderVer9DTO>',context!),
        'cohabitantPensionProviders': JsonConverters.toJson(cohabitantPensionProviders,'List<PensionProviderVer9DTO>',context!)
    };

    createResponse() => SendPensionPlanToProviderResponseVer9DTO();
    getResponseTypeName() => "SendPensionPlanToProviderResponseVer9DTO";
    getTypeName() => "PensionsInfoExtReq";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'hcbtas_q_albamfs_api.azurewebsites.net', types: <String, TypeInfo> {
    'TransactionHeader': TypeInfo(TypeOf.Class, create:() => TransactionHeader()),
    'SendPensionPlanHeader': TypeInfo(TypeOf.Class, create:() => SendPensionPlanHeader()),
    'Uint8List': TypeInfo(TypeOf.Class, create:() => Uint8List(0)),
    'Pdf': TypeInfo(TypeOf.Class, create:() => Pdf()),
    'RemarkVer9DTO': TypeInfo(TypeOf.Class, create:() => RemarkVer9DTO()),
    'PremiumWaiverBenefitVer9DTO': TypeInfo(TypeOf.Class, create:() => PremiumWaiverBenefitVer9DTO()),
    'BenefitPaymentVer9DTO': TypeInfo(TypeOf.Class, create:() => BenefitPaymentVer9DTO()),
    'PayoutForecastVer9DTO': TypeInfo(TypeOf.Class, create:() => PayoutForecastVer9DTO()),
    'BeneficiaryVer9DTO': TypeInfo(TypeOf.Class, create:() => BeneficiaryVer9DTO()),
    'DateAgeTypeVer9DTO': TypeInfo(TypeOf.Class, create:() => DateAgeTypeVer9DTO()),
    'PayoutVer9DTO': TypeInfo(TypeOf.Class, create:() => PayoutVer9DTO()),
    'List<PayoutForecastVer9DTO>': TypeInfo(TypeOf.Class, create:() => <PayoutForecastVer9DTO>[]),
    'List<BeneficiaryVer9DTO>': TypeInfo(TypeOf.Class, create:() => <BeneficiaryVer9DTO>[]),
    'RiskBenefitVer9DTO': TypeInfo(TypeOf.Class, create:() => RiskBenefitVer9DTO()),
    'InvestmentDistributionVer9DTO': TypeInfo(TypeOf.Class, create:() => InvestmentDistributionVer9DTO()),
    'ForecastVer9DTO': TypeInfo(TypeOf.Class, create:() => ForecastVer9DTO()),
    'ForecastCalculationVer9DTO': TypeInfo(TypeOf.Class, create:() => ForecastCalculationVer9DTO()),
    'List<RemarkVer9DTO>': TypeInfo(TypeOf.Class, create:() => <RemarkVer9DTO>[]),
    'List<ForecastVer9DTO>': TypeInfo(TypeOf.Class, create:() => <ForecastVer9DTO>[]),
    'PensionForecastsVer9DTO': TypeInfo(TypeOf.Class, create:() => PensionForecastsVer9DTO()),
    'List<ForecastCalculationVer9DTO>': TypeInfo(TypeOf.Class, create:() => <ForecastCalculationVer9DTO>[]),
    'PensionBenefitVer9DTO': TypeInfo(TypeOf.Class, create:() => PensionBenefitVer9DTO()),
    'List<InvestmentDistributionVer9DTO>': TypeInfo(TypeOf.Class, create:() => <InvestmentDistributionVer9DTO>[]),
    'BenefitVer9DTO': TypeInfo(TypeOf.Class, create:() => BenefitVer9DTO()),
    'PensionSchemeVer9DTO': TypeInfo(TypeOf.Class, create:() => PensionSchemeVer9DTO()),
    'List<BenefitVer9DTO>': TypeInfo(TypeOf.Class, create:() => <BenefitVer9DTO>[]),
    'PensionProviderVer9DTO': TypeInfo(TypeOf.Class, create:() => PensionProviderVer9DTO()),
    'List<PensionSchemeVer9DTO>': TypeInfo(TypeOf.Class, create:() => <PensionSchemeVer9DTO>[]),
    'AnswerSendPensionPlanHeader': TypeInfo(TypeOf.Class, create:() => AnswerSendPensionPlanHeader()),
    'SendPensionPlanToProviderResponseVer9DTO': TypeInfo(TypeOf.Class, create:() => SendPensionPlanToProviderResponseVer9DTO()),
    'PensionsInfoExtReq': TypeInfo(TypeOf.Class, create:() => PensionsInfoExtReq()),
    'List<PensionProviderVer9DTO>': TypeInfo(TypeOf.Class, create:() => <PensionProviderVer9DTO>[]),
});