/* Options:
Date: 2025-11-08 11:13:53
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://s4w2.api.bettor.cc

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

import 'package:servicestack/servicestack.dart';

class Ref implements IConvertible
{
    String? id;
    String? val;

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

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

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

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

class BettingApp implements IConvertible
{
    String? name;
    String? version;

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

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

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

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

class RefEx extends Ref implements IConvertible
{
    RecordDictionary<String,String>? data;

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

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

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

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

class Origin implements IConvertible
{
    BettingApp? application;
    String? ip;
    RefEx? organization;
    Ref? region;
    Ref? locationGroup;
    RefEx? location;
    RefEx? device;
    Ref? clerk;

    Origin({this.application,this.ip,this.organization,this.region,this.locationGroup,this.location,this.device,this.clerk});
    Origin.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        application = JsonConverters.fromJson(json['application'],'BettingApp',context!);
        ip = json['ip'];
        organization = JsonConverters.fromJson(json['organization'],'RefEx',context!);
        region = JsonConverters.fromJson(json['region'],'Ref',context!);
        locationGroup = JsonConverters.fromJson(json['locationGroup'],'Ref',context!);
        location = JsonConverters.fromJson(json['location'],'RefEx',context!);
        device = JsonConverters.fromJson(json['device'],'RefEx',context!);
        clerk = JsonConverters.fromJson(json['clerk'],'Ref',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'application': JsonConverters.toJson(application,'BettingApp',context!),
        'ip': ip,
        'organization': JsonConverters.toJson(organization,'RefEx',context!),
        'region': JsonConverters.toJson(region,'Ref',context!),
        'locationGroup': JsonConverters.toJson(locationGroup,'Ref',context!),
        'location': JsonConverters.toJson(location,'RefEx',context!),
        'device': JsonConverters.toJson(device,'RefEx',context!),
        'clerk': JsonConverters.toJson(clerk,'Ref',context!)
    };

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

class CountdownConfiguration implements IConvertible
{
    int? lockdownStepFromEnd;
    int? assertLockdownStepFromEnd;

    CountdownConfiguration({this.lockdownStepFromEnd,this.assertLockdownStepFromEnd});
    CountdownConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class DrawConfiguration implements IConvertible
{
    int? introIntervalInMs;
    int? animationIntervalInMs;
    int? outroIntervalInMs;

    DrawConfiguration({this.introIntervalInMs,this.animationIntervalInMs,this.outroIntervalInMs});
    DrawConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'introIntervalInMs': introIntervalInMs,
        'animationIntervalInMs': animationIntervalInMs,
        'outroIntervalInMs': outroIntervalInMs
    };

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

class RTPStrategies
{
    static const RTPStrategies RNG = const RTPStrategies._(0);
    static const RTPStrategies Accumulator = const RTPStrategies._(1);

    final int _value;
    const RTPStrategies._(this._value);
    int get value => _value;
    static List<RTPStrategies> get values => const [RNG,Accumulator];
}

class HappyHourConfiguration implements IConvertible
{
    bool? isHappyHour;
    double? oddsModifier;
    double? roundPoolBonusPct;

    HappyHourConfiguration({this.isHappyHour,this.oddsModifier,this.roundPoolBonusPct});
    HappyHourConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        isHappyHour = json['isHappyHour'];
        oddsModifier = JsonConverters.toDouble(json['oddsModifier']);
        roundPoolBonusPct = JsonConverters.toDouble(json['roundPoolBonusPct']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'isHappyHour': isHappyHour,
        'oddsModifier': oddsModifier,
        'roundPoolBonusPct': roundPoolBonusPct
    };

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

class RoundConfiguration implements IConvertible
{
    RecordList<double>? coefficients;
    bool? isDoubleTripleActive;
    bool? isJackpot5Active;
    int? countdownDurationInSeconds;
    CountdownConfiguration? countdownConfiguration;
    DrawConfiguration? drawConfiguration;
    int? resultsDurationInSeconds;
    RTPStrategies? rtpStrategy;
    HappyHourConfiguration? happyHourConfiguration;

    RoundConfiguration({this.coefficients,this.isDoubleTripleActive,this.isJackpot5Active,this.countdownDurationInSeconds,this.countdownConfiguration,this.drawConfiguration,this.resultsDurationInSeconds,this.rtpStrategy,this.happyHourConfiguration});
    RoundConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        coefficients = JsonConverters.fromJson(json['coefficients'],'RecordList<double>',context!);
        isDoubleTripleActive = json['isDoubleTripleActive'];
        isJackpot5Active = json['isJackpot5Active'];
        countdownDurationInSeconds = json['countdownDurationInSeconds'];
        countdownConfiguration = JsonConverters.fromJson(json['countdownConfiguration'],'CountdownConfiguration',context!);
        drawConfiguration = JsonConverters.fromJson(json['drawConfiguration'],'DrawConfiguration',context!);
        resultsDurationInSeconds = json['resultsDurationInSeconds'];
        rtpStrategy = JsonConverters.fromJson(json['rtpStrategy'],'RTPStrategies',context!);
        happyHourConfiguration = JsonConverters.fromJson(json['happyHourConfiguration'],'HappyHourConfiguration',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'coefficients': JsonConverters.toJson(coefficients,'RecordList<double>',context!),
        'isDoubleTripleActive': isDoubleTripleActive,
        'isJackpot5Active': isJackpot5Active,
        'countdownDurationInSeconds': countdownDurationInSeconds,
        'countdownConfiguration': JsonConverters.toJson(countdownConfiguration,'CountdownConfiguration',context!),
        'drawConfiguration': JsonConverters.toJson(drawConfiguration,'DrawConfiguration',context!),
        'resultsDurationInSeconds': resultsDurationInSeconds,
        'rtpStrategy': JsonConverters.toJson(rtpStrategy,'RTPStrategies',context!),
        'happyHourConfiguration': JsonConverters.toJson(happyHourConfiguration,'HappyHourConfiguration',context!)
    };

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

class RecordList<T> extends ListBase<T> implements IConvertible
{
    final List<T> l = [];
    set length(int newLength) { l.length = newLength; }
    int get length => l.length;
    T operator [](int index) => l[index];
    void operator []=(int index, T value) { l[index] = value; }
    RecordList();
    RecordList.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

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

class RoundStatus
{
    static const RoundStatus Pending = const RoundStatus._(0);
    static const RoundStatus InProgress = const RoundStatus._(1);
    static const RoundStatus Ended = const RoundStatus._(2);

    final int _value;
    const RoundStatus._(this._value);
    int get value => _value;
    static List<RoundStatus> get values => const [Pending,InProgress,Ended];
}

class JackPot5Winner implements IConvertible
{
    String? betId;
    int? nrOfCombinations;
    double? winningsAmount;
    Origin? origin;
    Ref? bettor;
    Map<String,String?>? payload;

    JackPot5Winner({this.betId,this.nrOfCombinations,this.winningsAmount,this.origin,this.bettor,this.payload});
    JackPot5Winner.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        betId = json['betId'];
        nrOfCombinations = json['nrOfCombinations'];
        winningsAmount = JsonConverters.toDouble(json['winningsAmount']);
        origin = JsonConverters.fromJson(json['origin'],'Origin',context!);
        bettor = JsonConverters.fromJson(json['bettor'],'Ref',context!);
        payload = JsonConverters.toStringMap(json['payload']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'betId': betId,
        'nrOfCombinations': nrOfCombinations,
        'winningsAmount': winningsAmount,
        'origin': JsonConverters.toJson(origin,'Origin',context!),
        'bettor': JsonConverters.toJson(bettor,'Ref',context!),
        'payload': payload
    };

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

class Jackpot5Info implements IConvertible
{
    bool? isHit;
    double? amountAccumulated;
    double? amountAwarded;
    int? nrOfWinners;
    List<JackPot5Winner>? jackPot5Winners;

    Jackpot5Info({this.isHit,this.amountAccumulated,this.amountAwarded,this.nrOfWinners,this.jackPot5Winners});
    Jackpot5Info.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        isHit = json['isHit'];
        amountAccumulated = JsonConverters.toDouble(json['amountAccumulated']);
        amountAwarded = JsonConverters.toDouble(json['amountAwarded']);
        nrOfWinners = json['nrOfWinners'];
        jackPot5Winners = JsonConverters.fromJson(json['jackPot5Winners'],'List<JackPot5Winner>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'isHit': isHit,
        'amountAccumulated': amountAccumulated,
        'amountAwarded': amountAwarded,
        'nrOfWinners': nrOfWinners,
        'jackPot5Winners': JsonConverters.toJson(jackPot5Winners,'List<JackPot5Winner>',context!)
    };

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

class SuperWinInfo implements IConvertible
{
    int? durationInMs;

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

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

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

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

class WinnerByCode implements IConvertible
{
    String? roundId;
    DateTime? drawnAtUtc;
    String? slipId;
    String? betId;
    String? code;
    double? amount;
    Origin? origin;
    Ref? bettor;
    String? locationAddressOrBettorInfo;

    WinnerByCode({this.roundId,this.drawnAtUtc,this.slipId,this.betId,this.code,this.amount,this.origin,this.bettor,this.locationAddressOrBettorInfo});
    WinnerByCode.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        roundId = json['roundId'];
        drawnAtUtc = JsonConverters.fromJson(json['drawnAtUtc'],'DateTime',context!);
        slipId = json['slipId'];
        betId = json['betId'];
        code = json['code'];
        amount = JsonConverters.toDouble(json['amount']);
        origin = JsonConverters.fromJson(json['origin'],'Origin',context!);
        bettor = JsonConverters.fromJson(json['bettor'],'Ref',context!);
        locationAddressOrBettorInfo = json['locationAddressOrBettorInfo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'roundId': roundId,
        'drawnAtUtc': JsonConverters.toJson(drawnAtUtc,'DateTime',context!),
        'slipId': slipId,
        'betId': betId,
        'code': code,
        'amount': amount,
        'origin': JsonConverters.toJson(origin,'Origin',context!),
        'bettor': JsonConverters.toJson(bettor,'Ref',context!),
        'locationAddressOrBettorInfo': locationAddressOrBettorInfo
    };

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

class GlobalCodePotInfo implements IConvertible
{
    bool? isActive;
    bool? isDrawn;
    WinnerByCode? winner;
    String? inertCode;
    double? accumulation;

    GlobalCodePotInfo({this.isActive,this.isDrawn,this.winner,this.inertCode,this.accumulation});
    GlobalCodePotInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        isActive = json['isActive'];
        isDrawn = json['isDrawn'];
        winner = JsonConverters.fromJson(json['winner'],'WinnerByCode',context!);
        inertCode = json['inertCode'];
        accumulation = JsonConverters.toDouble(json['accumulation']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'isActive': isActive,
        'isDrawn': isDrawn,
        'winner': JsonConverters.toJson(winner,'WinnerByCode',context!),
        'inertCode': inertCode,
        'accumulation': accumulation
    };

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

class Stages
{
    static const Stages None = const Stages._(0);
    static const Stages Countdown = const Stages._(1);
    static const Stages Processing = const Stages._(2);
    static const Stages Draw = const Stages._(3);
    static const Stages Results = const Stages._(4);

    final int _value;
    const Stages._(this._value);
    int get value => _value;
    static List<Stages> get values => const [None,Countdown,Processing,Draw,Results];
}

class RoundProgress implements IConvertible
{
    Stages? stage;
    int? step;
    int? steps;
    DateTime? utcTimestamp;

    RoundProgress({this.stage,this.step,this.steps,this.utcTimestamp});
    RoundProgress.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        stage = JsonConverters.fromJson(json['stage'],'Stages',context!);
        step = json['step'];
        steps = json['steps'];
        utcTimestamp = JsonConverters.fromJson(json['utcTimestamp'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'stage': JsonConverters.toJson(stage,'Stages',context!),
        'step': step,
        'steps': steps,
        'utcTimestamp': JsonConverters.toJson(utcTimestamp,'DateTime',context!)
    };

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

class Round implements IConvertible
{
    String? id;
    DateTime? createdAt;
    DateTime? updatedAt;
    DateTime? shouldStartAtUtc;
    DateTime? startedAtUtc;
    RoundStatus? status;
    RoundConfiguration? configuration;
    String? sequence;
    Jackpot5Info? jackpot5Info;
    SuperWinInfo? superWinInfo;
    GlobalCodePotInfo? globalCodePotInfo;
    RoundProgress? progress;
    bool? isLocked;
    bool? isCalculated;

    Round({this.id,this.createdAt,this.updatedAt,this.shouldStartAtUtc,this.startedAtUtc,this.status,this.configuration,this.sequence,this.jackpot5Info,this.superWinInfo,this.globalCodePotInfo,this.progress,this.isLocked,this.isCalculated});
    Round.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
        updatedAt = JsonConverters.fromJson(json['updatedAt'],'DateTime',context!);
        shouldStartAtUtc = JsonConverters.fromJson(json['shouldStartAtUtc'],'DateTime',context!);
        startedAtUtc = JsonConverters.fromJson(json['startedAtUtc'],'DateTime',context!);
        status = JsonConverters.fromJson(json['status'],'RoundStatus',context!);
        configuration = JsonConverters.fromJson(json['configuration'],'RoundConfiguration',context!);
        sequence = json['sequence'];
        jackpot5Info = JsonConverters.fromJson(json['jackpot5Info'],'Jackpot5Info',context!);
        superWinInfo = JsonConverters.fromJson(json['superWinInfo'],'SuperWinInfo',context!);
        globalCodePotInfo = JsonConverters.fromJson(json['globalCodePotInfo'],'GlobalCodePotInfo',context!);
        progress = JsonConverters.fromJson(json['progress'],'RoundProgress',context!);
        isLocked = json['isLocked'];
        isCalculated = json['isCalculated'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
        'updatedAt': JsonConverters.toJson(updatedAt,'DateTime',context!),
        'shouldStartAtUtc': JsonConverters.toJson(shouldStartAtUtc,'DateTime',context!),
        'startedAtUtc': JsonConverters.toJson(startedAtUtc,'DateTime',context!),
        'status': JsonConverters.toJson(status,'RoundStatus',context!),
        'configuration': JsonConverters.toJson(configuration,'RoundConfiguration',context!),
        'sequence': sequence,
        'jackpot5Info': JsonConverters.toJson(jackpot5Info,'Jackpot5Info',context!),
        'superWinInfo': JsonConverters.toJson(superWinInfo,'SuperWinInfo',context!),
        'globalCodePotInfo': JsonConverters.toJson(globalCodePotInfo,'GlobalCodePotInfo',context!),
        'progress': JsonConverters.toJson(progress,'RoundProgress',context!),
        'isLocked': isLocked,
        'isCalculated': isCalculated
    };

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

class SuperWinInfo implements IConvertible
{
    bool? isActive;
    SuperWinWinner? winner;
    double? availableAmount;
    bool? allPrizesAwarded;

    SuperWinInfo({this.isActive,this.winner,this.availableAmount,this.allPrizesAwarded});
    SuperWinInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        isActive = json['isActive'];
        winner = JsonConverters.fromJson(json['winner'],'SuperWinWinner',context!);
        availableAmount = JsonConverters.toDouble(json['availableAmount']);
        allPrizesAwarded = json['allPrizesAwarded'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'isActive': isActive,
        'winner': JsonConverters.toJson(winner,'SuperWinWinner',context!),
        'availableAmount': availableAmount,
        'allPrizesAwarded': allPrizesAwarded
    };

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

class RecordDictionary<TKey,TVal> extends Map<TKey,TVal?> implements IConvertible
{
    RecordDictionary();
    RecordDictionary.fromJson(Map<String, dynamic> json) : super.fromJson(json);
    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson();
    getTypeName() => "RecordDictionary<$TKey,$TVal>";
    TypeContext? context = _ctx;
}

class Feed implements IConvertible
{
    String? id;
    Round? round;
    Jackpot5Info? lastJackpot5Info;
    SuperWinInfo? superWinInfo;
    GlobalCodePotInfo? globalCodePotInfo;

    Feed({this.id,this.round,this.lastJackpot5Info,this.superWinInfo,this.globalCodePotInfo});
    Feed.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        round = JsonConverters.fromJson(json['round'],'Round',context!);
        lastJackpot5Info = JsonConverters.fromJson(json['lastJackpot5Info'],'Jackpot5Info',context!);
        superWinInfo = JsonConverters.fromJson(json['superWinInfo'],'SuperWinInfo',context!);
        globalCodePotInfo = JsonConverters.fromJson(json['globalCodePotInfo'],'GlobalCodePotInfo',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'round': JsonConverters.toJson(round,'Round',context!),
        'lastJackpot5Info': JsonConverters.toJson(lastJackpot5Info,'Jackpot5Info',context!),
        'superWinInfo': JsonConverters.toJson(superWinInfo,'SuperWinInfo',context!),
        'globalCodePotInfo': JsonConverters.toJson(globalCodePotInfo,'GlobalCodePotInfo',context!)
    };

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

// @Route("/qry/feed")
class GetFeed implements IReturn<Feed>, IConvertible, IPost
{
    GetFeed();
    GetFeed.fromJson(Map<String, dynamic> json) : super();
    fromMap(Map<String, dynamic> json) {
        return this;
    }

    Map<String, dynamic> toJson() => {};
    createResponse() => Feed();
    getResponseTypeName() => "Feed";
    getTypeName() => "GetFeed";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 's4w2.api.bettor.cc', types: <String, TypeInfo> {
    'Ref': TypeInfo(TypeOf.Class, create:() => Ref()),
    'BettingApp': TypeInfo(TypeOf.Class, create:() => BettingApp()),
    'RefEx': TypeInfo(TypeOf.Class, create:() => RefEx()),
    'RecordDictionary<String,String>': TypeInfo(TypeOf.Class, create:() => RecordDictionary<String,String>()),
    'Origin': TypeInfo(TypeOf.Class, create:() => Origin()),
    'CountdownConfiguration': TypeInfo(TypeOf.Class, create:() => CountdownConfiguration()),
    'DrawConfiguration': TypeInfo(TypeOf.Class, create:() => DrawConfiguration()),
    'RTPStrategies': TypeInfo(TypeOf.Enum, enumValues:RTPStrategies.values),
    'HappyHourConfiguration': TypeInfo(TypeOf.Class, create:() => HappyHourConfiguration()),
    'RoundConfiguration': TypeInfo(TypeOf.Class, create:() => RoundConfiguration()),
    'RecordList<double>': TypeInfo(TypeOf.Class, create:() => RecordList<double>()),
    'RecordList<T>': TypeInfo(TypeOf.GenericDef,create:() => RecordList()),
    'RoundStatus': TypeInfo(TypeOf.Enum, enumValues:RoundStatus.values),
    'JackPot5Winner': TypeInfo(TypeOf.Class, create:() => JackPot5Winner()),
    'Jackpot5Info': TypeInfo(TypeOf.Class, create:() => Jackpot5Info()),
    'List<JackPot5Winner>': TypeInfo(TypeOf.Class, create:() => <JackPot5Winner>[]),
    'SuperWinInfo': TypeInfo(TypeOf.Class, create:() => SuperWinInfo()),
    'WinnerByCode': TypeInfo(TypeOf.Class, create:() => WinnerByCode()),
    'GlobalCodePotInfo': TypeInfo(TypeOf.Class, create:() => GlobalCodePotInfo()),
    'Stages': TypeInfo(TypeOf.Enum, enumValues:Stages.values),
    'RoundProgress': TypeInfo(TypeOf.Class, create:() => RoundProgress()),
    'Round': TypeInfo(TypeOf.Class, create:() => Round()),
    'SuperWinWinner': TypeInfo(TypeOf.Class, create:() => SuperWinWinner()),
    'RecordDictionary<TKey,TVal>': TypeInfo(TypeOf.GenericDef,create:() => RecordDictionary()),
    'Feed': TypeInfo(TypeOf.Class, create:() => Feed()),
    'GetFeed': TypeInfo(TypeOf.Class, create:() => GetFeed()),
});