/* Options:
Date: 2025-07-18 00:25:59
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: ClientCountryConfigValidateReq.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data,dart:collection
*/

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

class Entity implements IEntity, IConvertible
{
    String? id;

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

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

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

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

abstract class IEntity
{
    String? id;
}

enum Gender
{
    Female,
    Male,
    Other,
}

class Entity implements IConvertible
{
    String? logoUri;
    String? name;
    ContactDetails? contactDetails;

    Entity({this.logoUri,this.name,this.contactDetails});
    Entity.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'logoUri': logoUri,
        'name': name,
        'contactDetails': JsonConverters.toJson(contactDetails,'ContactDetails',context!)
    };

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

enum DataSource
{
    Db,
    Cache,
    Parameter,
    NA,
}

class DataSourceResult implements IConvertible
{
    DataSource? d;
    int? t;

    DataSourceResult({this.d,this.t});
    DataSourceResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'd': JsonConverters.toJson(d,'DataSource',context!),
        't': t
    };

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

class LifeTableName implements IConvertible
{
    String? name;
    Gender? gender;

    LifeTableName({this.name,this.gender});
    LifeTableName.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'name': name,
        'gender': JsonConverters.toJson(gender,'Gender',context!)
    };

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

enum AnnuityPriceType
{
    Calc,
    Table,
}

class AnnuityConfig implements IConvertible
{
    List<LifeTableName>? tableNames;
    List<LifeTableName>? imprFactorTableNames;
    double? reversion;
    double? guarantee;
    double? timing;
    bool? allowDiscountPreRet;
    double? scaleQx;
    double? scaleImpr;
    int? ageRating;
    int? spouseAgeRating;
    double? expense;
    double? percBalanceSpent;
    double? amountSpent;
    double? incomePurchased;
    int? deferralPeriod;
    String? indexationName;
    String? drStochastic;
    String? impliedInflationStochasticSeries;
    double? targetTpx;
    AnnuityPriceType? priceType;
    double? price;

    AnnuityConfig({this.tableNames,this.imprFactorTableNames,this.reversion,this.guarantee,this.timing,this.allowDiscountPreRet,this.scaleQx,this.scaleImpr,this.ageRating,this.spouseAgeRating,this.expense,this.percBalanceSpent,this.amountSpent,this.incomePurchased,this.deferralPeriod,this.indexationName,this.drStochastic,this.impliedInflationStochasticSeries,this.targetTpx,this.priceType,this.price});
    AnnuityConfig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        tableNames = JsonConverters.fromJson(json['tableNames'],'List<LifeTableName>',context!);
        imprFactorTableNames = JsonConverters.fromJson(json['imprFactorTableNames'],'List<LifeTableName>',context!);
        reversion = JsonConverters.toDouble(json['reversion']);
        guarantee = JsonConverters.toDouble(json['guarantee']);
        timing = JsonConverters.toDouble(json['timing']);
        allowDiscountPreRet = json['allowDiscountPreRet'];
        scaleQx = JsonConverters.toDouble(json['scaleQx']);
        scaleImpr = JsonConverters.toDouble(json['scaleImpr']);
        ageRating = json['ageRating'];
        spouseAgeRating = json['spouseAgeRating'];
        expense = JsonConverters.toDouble(json['expense']);
        percBalanceSpent = JsonConverters.toDouble(json['percBalanceSpent']);
        amountSpent = JsonConverters.toDouble(json['amountSpent']);
        incomePurchased = JsonConverters.toDouble(json['incomePurchased']);
        deferralPeriod = json['deferralPeriod'];
        indexationName = json['indexationName'];
        drStochastic = json['drStochastic'];
        impliedInflationStochasticSeries = json['impliedInflationStochasticSeries'];
        targetTpx = JsonConverters.toDouble(json['targetTpx']);
        priceType = JsonConverters.fromJson(json['priceType'],'AnnuityPriceType',context!);
        price = JsonConverters.toDouble(json['price']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'tableNames': JsonConverters.toJson(tableNames,'List<LifeTableName>',context!),
        'imprFactorTableNames': JsonConverters.toJson(imprFactorTableNames,'List<LifeTableName>',context!),
        'reversion': reversion,
        'guarantee': guarantee,
        'timing': timing,
        'allowDiscountPreRet': allowDiscountPreRet,
        'scaleQx': scaleQx,
        'scaleImpr': scaleImpr,
        'ageRating': ageRating,
        'spouseAgeRating': spouseAgeRating,
        'expense': expense,
        'percBalanceSpent': percBalanceSpent,
        'amountSpent': amountSpent,
        'incomePurchased': incomePurchased,
        'deferralPeriod': deferralPeriod,
        'indexationName': indexationName,
        'drStochastic': drStochastic,
        'impliedInflationStochasticSeries': impliedInflationStochasticSeries,
        'targetTpx': targetTpx,
        'priceType': JsonConverters.toJson(priceType,'AnnuityPriceType',context!),
        'price': price
    };

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

enum ContributionType
{
    Fixed,
    Time,
    Lookup,
    Match,
}

class ContributionConstraint implements IConvertible
{
    int? fromAge;
    int? toAge;
    double? min;
    double? max;
    double? step;

    ContributionConstraint({this.fromAge,this.toAge,this.min,this.max,this.step});
    ContributionConstraint.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fromAge = json['fromAge'];
        toAge = json['toAge'];
        min = JsonConverters.toDouble(json['min']);
        max = JsonConverters.toDouble(json['max']);
        step = JsonConverters.toDouble(json['step']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fromAge': fromAge,
        'toAge': toAge,
        'min': min,
        'max': max,
        'step': step
    };

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

enum AmountType
{
    Any,
    Amount,
    Rate,
}

class ContributionSpec implements IConvertible
{
    String? code;
    String? name;
    ContributionType? type;
    bool? isEmployeeCont;
    String? table;
    String? ccy;
    int? fromAge;
    int? toAge;
    String? indexationType;
    String? salaryType;
    bool? isTaxable;
    String? relatedRate;
    int? order;
    bool? editable;
    List<ContributionConstraint>? constraints;
    AmountType? amountType;
    bool? isOneOff;

    ContributionSpec({this.code,this.name,this.type,this.isEmployeeCont,this.table,this.ccy,this.fromAge,this.toAge,this.indexationType,this.salaryType,this.isTaxable,this.relatedRate,this.order,this.editable,this.constraints,this.amountType,this.isOneOff});
    ContributionSpec.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        code = json['code'];
        name = json['name'];
        type = JsonConverters.fromJson(json['type'],'ContributionType',context!);
        isEmployeeCont = json['isEmployeeCont'];
        table = json['table'];
        ccy = json['ccy'];
        fromAge = json['fromAge'];
        toAge = json['toAge'];
        indexationType = json['indexationType'];
        salaryType = json['salaryType'];
        isTaxable = json['isTaxable'];
        relatedRate = json['relatedRate'];
        order = json['order'];
        editable = json['editable'];
        constraints = JsonConverters.fromJson(json['constraints'],'List<ContributionConstraint>',context!);
        amountType = JsonConverters.fromJson(json['amountType'],'AmountType',context!);
        isOneOff = json['isOneOff'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'code': code,
        'name': name,
        'type': JsonConverters.toJson(type,'ContributionType',context!),
        'isEmployeeCont': isEmployeeCont,
        'table': table,
        'ccy': ccy,
        'fromAge': fromAge,
        'toAge': toAge,
        'indexationType': indexationType,
        'salaryType': salaryType,
        'isTaxable': isTaxable,
        'relatedRate': relatedRate,
        'order': order,
        'editable': editable,
        'constraints': JsonConverters.toJson(constraints,'List<ContributionConstraint>',context!),
        'amountType': JsonConverters.toJson(amountType,'AmountType',context!),
        'isOneOff': isOneOff
    };

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

class AssetConfig implements IConvertible
{
    String? code;
    String? name;
    bool? rebalance;
    bool? canEditInvestmentChoice;
    bool? willSpend;
    List<String>? investments;
    List<ContributionSpec>? contributions;
    bool? isOneOff;

    AssetConfig({this.code,this.name,this.rebalance,this.canEditInvestmentChoice,this.willSpend,this.investments,this.contributions,this.isOneOff});
    AssetConfig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        code = json['code'];
        name = json['name'];
        rebalance = json['rebalance'];
        canEditInvestmentChoice = json['canEditInvestmentChoice'];
        willSpend = json['willSpend'];
        investments = JsonConverters.fromJson(json['investments'],'List<String>',context!);
        contributions = JsonConverters.fromJson(json['contributions'],'List<ContributionSpec>',context!);
        isOneOff = json['isOneOff'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'code': code,
        'name': name,
        'rebalance': rebalance,
        'canEditInvestmentChoice': canEditInvestmentChoice,
        'willSpend': willSpend,
        'investments': JsonConverters.toJson(investments,'List<String>',context!),
        'contributions': JsonConverters.toJson(contributions,'List<ContributionSpec>',context!),
        'isOneOff': isOneOff
    };

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

class ContributionRateSpec implements IConvertible
{
    int? fromAge;
    int? toAge;
    int? fromService;
    int? toService;
    double? sourceRate;
    DateTime? dateFrom;
    DateTime? dateTo;
    double? upperLimit;
    double? rate;
    double? coreRate;
    String? lookupKey;

    ContributionRateSpec({this.fromAge,this.toAge,this.fromService,this.toService,this.sourceRate,this.dateFrom,this.dateTo,this.upperLimit,this.rate,this.coreRate,this.lookupKey});
    ContributionRateSpec.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fromAge = json['fromAge'];
        toAge = json['toAge'];
        fromService = json['fromService'];
        toService = json['toService'];
        sourceRate = JsonConverters.toDouble(json['sourceRate']);
        dateFrom = JsonConverters.fromJson(json['dateFrom'],'DateTime',context!);
        dateTo = JsonConverters.fromJson(json['dateTo'],'DateTime',context!);
        upperLimit = JsonConverters.toDouble(json['upperLimit']);
        rate = JsonConverters.toDouble(json['rate']);
        coreRate = JsonConverters.toDouble(json['coreRate']);
        lookupKey = json['lookupKey'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fromAge': fromAge,
        'toAge': toAge,
        'fromService': fromService,
        'toService': toService,
        'sourceRate': sourceRate,
        'dateFrom': JsonConverters.toJson(dateFrom,'DateTime',context!),
        'dateTo': JsonConverters.toJson(dateTo,'DateTime',context!),
        'upperLimit': upperLimit,
        'rate': rate,
        'coreRate': coreRate,
        'lookupKey': lookupKey
    };

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

class ContributionTableSpec implements IConvertible
{
    String? code;
    ContributionType? type;
    Map<String,double?>? rates;
    List<ContributionRateSpec>? rateSpecs;
    String? keyTemplate;

    ContributionTableSpec({this.code,this.type,this.rates,this.rateSpecs,this.keyTemplate});
    ContributionTableSpec.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        code = json['code'];
        type = JsonConverters.fromJson(json['type'],'ContributionType',context!);
        rates = JsonConverters.fromJson(json['rates'],'Map<String,double?>',context!);
        rateSpecs = JsonConverters.fromJson(json['rateSpecs'],'List<ContributionRateSpec>',context!);
        keyTemplate = json['keyTemplate'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'code': code,
        'type': JsonConverters.toJson(type,'ContributionType',context!),
        'rates': JsonConverters.toJson(rates,'Map<String,double?>',context!),
        'rateSpecs': JsonConverters.toJson(rateSpecs,'List<ContributionRateSpec>',context!),
        'keyTemplate': keyTemplate
    };

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

class InvestmentProduct implements IConvertible
{
    String? code;
    String? name;
    String? group;
    bool? isAssetClassFund;
    List<InvestmentProductAllocationsSpec>? allocs;
    int? order;
    Map<int,Map<String,double>?>? allocationsDictionary;

    InvestmentProduct({this.code,this.name,this.group,this.isAssetClassFund,this.allocs,this.order,this.allocationsDictionary});
    InvestmentProduct.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        code = json['code'];
        name = json['name'];
        group = json['group'];
        isAssetClassFund = json['isAssetClassFund'];
        allocs = JsonConverters.fromJson(json['allocs'],'List<InvestmentProductAllocationsSpec>',context!);
        order = json['order'];
        allocationsDictionary = JsonConverters.fromJson(json['allocationsDictionary'],'Map<int,Map<String,double>?>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'code': code,
        'name': name,
        'group': group,
        'isAssetClassFund': isAssetClassFund,
        'allocs': JsonConverters.toJson(allocs,'List<InvestmentProductAllocationsSpec>',context!),
        'order': order,
        'allocationsDictionary': JsonConverters.toJson(allocationsDictionary,'Map<int,Map<String,double>?>',context!)
    };

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

class ReturnRates implements IConvertible
{
    List<double>? earningRates;
    List<double>? taxRates;

    ReturnRates({this.earningRates,this.taxRates});
    ReturnRates.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

abstract class DatedEntity extends Entity implements IDatedEntity
{
    DateTime? asAt;

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

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

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

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

abstract class IDatedEntity extends IEntity
{
    DateTime? asAt;
}

enum ContributionType
{
    Employer,
    Employee,
    EmployerMatching,
}

class InvestmentProduct implements IConvertible
{
    String? riskId;
    String? riskName;

    InvestmentProduct({this.riskId,this.riskName});
    InvestmentProduct.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class ClientCountryConfig extends DatedEntity implements IConvertible
{
    String? clientCode;
    String? clientName;
    String? countryCode;
    DataSourceResult? source;
    int? ageRMin;
    int? ageRMax;
    String? primarySalary;
    AnnuityConfig? annuityConfig;
    List<AssetConfig>? assets;
    List<ContributionTableSpec>? contTables;
    List<InvestmentProduct>? investments;
    Map<String,List<Content>?>? content;
    Map<String,String?>? environments;
    Map<String,Constraint<double>?>? customNumericConstraints;
    Map<String,ReturnRates?>? assetReturnRates;
    double? investmentPropertyRates;
    Map<String,bool?>? getAssetClassFundDictionary;
    Map<String,bool?>? getTermBasedFundDictionary;
    Map<String,Map<int,Map<String,double>>?>? getAllocationsDictionary;
    Map<String,String?>? assetNameMap;
    Map<String,Map<String,String>?>? assetContNameMap;
    String? cacheKey;

    ClientCountryConfig({this.clientCode,this.clientName,this.countryCode,this.source,this.ageRMin,this.ageRMax,this.primarySalary,this.annuityConfig,this.assets,this.contTables,this.investments,this.content,this.environments,this.customNumericConstraints,this.assetReturnRates,this.investmentPropertyRates,this.getAssetClassFundDictionary,this.getTermBasedFundDictionary,this.getAllocationsDictionary,this.assetNameMap,this.assetContNameMap,this.cacheKey});
    ClientCountryConfig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        clientCode = json['clientCode'];
        clientName = json['clientName'];
        countryCode = json['countryCode'];
        source = JsonConverters.fromJson(json['source'],'DataSourceResult',context!);
        ageRMin = json['ageRMin'];
        ageRMax = json['ageRMax'];
        primarySalary = json['primarySalary'];
        annuityConfig = JsonConverters.fromJson(json['annuityConfig'],'AnnuityConfig',context!);
        assets = JsonConverters.fromJson(json['assets'],'List<AssetConfig>',context!);
        contTables = JsonConverters.fromJson(json['contTables'],'List<ContributionTableSpec>',context!);
        investments = JsonConverters.fromJson(json['investments'],'List<InvestmentProduct>',context!);
        content = JsonConverters.fromJson(json['content'],'Map<String,List<Content>?>',context!);
        environments = JsonConverters.toStringMap(json['environments']);
        customNumericConstraints = JsonConverters.fromJson(json['customNumericConstraints'],'Map<String,Constraint<double>?>',context!);
        assetReturnRates = JsonConverters.fromJson(json['assetReturnRates'],'Map<String,ReturnRates?>',context!);
        investmentPropertyRates = JsonConverters.toDouble(json['investmentPropertyRates']);
        getAssetClassFundDictionary = JsonConverters.fromJson(json['getAssetClassFundDictionary'],'Map<String,bool?>',context!);
        getTermBasedFundDictionary = JsonConverters.fromJson(json['getTermBasedFundDictionary'],'Map<String,bool?>',context!);
        getAllocationsDictionary = JsonConverters.fromJson(json['getAllocationsDictionary'],'Map<String,Map<int,Map<String,double>>?>',context!);
        assetNameMap = JsonConverters.toStringMap(json['assetNameMap']);
        assetContNameMap = JsonConverters.fromJson(json['assetContNameMap'],'Map<String,Map<String,String>?>',context!);
        cacheKey = json['cacheKey'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'clientCode': clientCode,
        'clientName': clientName,
        'countryCode': countryCode,
        'source': JsonConverters.toJson(source,'DataSourceResult',context!),
        'ageRMin': ageRMin,
        'ageRMax': ageRMax,
        'primarySalary': primarySalary,
        'annuityConfig': JsonConverters.toJson(annuityConfig,'AnnuityConfig',context!),
        'assets': JsonConverters.toJson(assets,'List<AssetConfig>',context!),
        'contTables': JsonConverters.toJson(contTables,'List<ContributionTableSpec>',context!),
        'investments': JsonConverters.toJson(investments,'List<InvestmentProduct>',context!),
        'content': JsonConverters.toJson(content,'Map<String,List<Content>?>',context!),
        'environments': environments,
        'customNumericConstraints': JsonConverters.toJson(customNumericConstraints,'Map<String,Constraint<double>?>',context!),
        'assetReturnRates': JsonConverters.toJson(assetReturnRates,'Map<String,ReturnRates?>',context!),
        'investmentPropertyRates': investmentPropertyRates,
        'getAssetClassFundDictionary': JsonConverters.toJson(getAssetClassFundDictionary,'Map<String,bool?>',context!),
        'getTermBasedFundDictionary': JsonConverters.toJson(getTermBasedFundDictionary,'Map<String,bool?>',context!),
        'getAllocationsDictionary': JsonConverters.toJson(getAllocationsDictionary,'Map<String,Map<int,Map<String,double>>?>',context!),
        'assetNameMap': assetNameMap,
        'assetContNameMap': JsonConverters.toJson(assetContNameMap,'Map<String,Map<String,String>?>',context!),
        'cacheKey': cacheKey
    });

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

// @Route("/clientcountryconfig/validate", "POST")
class ClientCountryConfigValidateReq implements IReturn<ClientCountryConfig>, IConvertible
{
    ClientCountryConfig? config;

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

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

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

    createResponse() => ClientCountryConfig();
    getResponseTypeName() => "ClientCountryConfig";
    getTypeName() => "ClientCountryConfigValidateReq";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'hcbtas_q_albamfs_api.azurewebsites.net', types: <String, TypeInfo> {
    'Entity': TypeInfo(TypeOf.Class, create:() => Entity()),
    'IEntity': TypeInfo(TypeOf.Interface),
    'Gender': TypeInfo(TypeOf.Enum, enumValues:Gender.values),
    'ContactDetails': TypeInfo(TypeOf.Class, create:() => ContactDetails()),
    'DataSource': TypeInfo(TypeOf.Enum, enumValues:DataSource.values),
    'DataSourceResult': TypeInfo(TypeOf.Class, create:() => DataSourceResult()),
    'LifeTableName': TypeInfo(TypeOf.Class, create:() => LifeTableName()),
    'AnnuityPriceType': TypeInfo(TypeOf.Enum, enumValues:AnnuityPriceType.values),
    'AnnuityConfig': TypeInfo(TypeOf.Class, create:() => AnnuityConfig()),
    'List<LifeTableName>': TypeInfo(TypeOf.Class, create:() => <LifeTableName>[]),
    'ContributionType': TypeInfo(TypeOf.Enum, enumValues:ContributionType.values),
    'ContributionConstraint': TypeInfo(TypeOf.Class, create:() => ContributionConstraint()),
    'AmountType': TypeInfo(TypeOf.Enum, enumValues:AmountType.values),
    'ContributionSpec': TypeInfo(TypeOf.Class, create:() => ContributionSpec()),
    'List<ContributionConstraint>': TypeInfo(TypeOf.Class, create:() => <ContributionConstraint>[]),
    'AssetConfig': TypeInfo(TypeOf.Class, create:() => AssetConfig()),
    'List<ContributionSpec>': TypeInfo(TypeOf.Class, create:() => <ContributionSpec>[]),
    'ContributionRateSpec': TypeInfo(TypeOf.Class, create:() => ContributionRateSpec()),
    'ContributionTableSpec': TypeInfo(TypeOf.Class, create:() => ContributionTableSpec()),
    'Map<String,double?>': TypeInfo(TypeOf.Class, create:() => Map<String,double?>()),
    'List<ContributionRateSpec>': TypeInfo(TypeOf.Class, create:() => <ContributionRateSpec>[]),
    'InvestmentProduct': TypeInfo(TypeOf.Class, create:() => InvestmentProduct()),
    'List<InvestmentProductAllocationsSpec>': TypeInfo(TypeOf.Class, create:() => <InvestmentProductAllocationsSpec>[]),
    'InvestmentProductAllocationsSpec': TypeInfo(TypeOf.Class, create:() => InvestmentProductAllocationsSpec()),
    'Map<int,Map<String,double>?>': TypeInfo(TypeOf.Class, create:() => Map<int,Map<String,double>?>()),
    'Map<String,double>': TypeInfo(TypeOf.Class, create:() => Map<String,double>()),
    'ReturnRates': TypeInfo(TypeOf.Class, create:() => ReturnRates()),
    'DatedEntity': TypeInfo(TypeOf.AbstractClass),
    'IDatedEntity': TypeInfo(TypeOf.Interface),
    'ClientCountryConfig': TypeInfo(TypeOf.Class, create:() => ClientCountryConfig()),
    'List<AssetConfig>': TypeInfo(TypeOf.Class, create:() => <AssetConfig>[]),
    'List<ContributionTableSpec>': TypeInfo(TypeOf.Class, create:() => <ContributionTableSpec>[]),
    'List<InvestmentProduct>': TypeInfo(TypeOf.Class, create:() => <InvestmentProduct>[]),
    'Map<String,List<Content>?>': TypeInfo(TypeOf.Class, create:() => Map<String,List<Content>?>()),
    'List<Content>': TypeInfo(TypeOf.Class, create:() => <Content>[]),
    'Content': TypeInfo(TypeOf.Class, create:() => Content()),
    'Map<String,Constraint<double>?>': TypeInfo(TypeOf.Class, create:() => Map<String,Constraint<double>?>()),
    'Constraint<double>': TypeInfo(TypeOf.Class, create:() => Constraint<double>()),
    'Map<String,ReturnRates?>': TypeInfo(TypeOf.Class, create:() => Map<String,ReturnRates?>()),
    'Map<String,bool?>': TypeInfo(TypeOf.Class, create:() => Map<String,bool?>()),
    'Map<String,Map<int,Map<String,double>>?>': TypeInfo(TypeOf.Class, create:() => Map<String,Map<int,Map<String,double>>?>()),
    'Map<int,Map<String,double>>': TypeInfo(TypeOf.Class, create:() => Map<int,Map<String,double>>()),
    'Map<String,Map<String,String>?>': TypeInfo(TypeOf.Class, create:() => Map<String,Map<String,String>?>()),
    'ClientCountryConfigValidateReq': TypeInfo(TypeOf.Class, create:() => ClientCountryConfigValidateReq()),
});