Six4Win.WebApi

<back to all web services

GetDrawDignostics

import 'package:servicestack/servicestack.dart';

class Initialization implements IConvertible
{
    int? dataLoadDuration;
    int? betsCollectionsCreationDuration;
    int? combinationsOccuranceLookupInitializationDuration;

    Initialization({this.dataLoadDuration,this.betsCollectionsCreationDuration,this.combinationsOccuranceLookupInitializationDuration});
    Initialization.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'dataLoadDuration': dataLoadDuration,
        'betsCollectionsCreationDuration': betsCollectionsCreationDuration,
        'combinationsOccuranceLookupInitializationDuration': combinationsOccuranceLookupInitializationDuration
    };

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

class SequenceGeneration implements IConvertible
{
    int? nrOfThreads;
    int? nrOfResultsProbed;
    int? duration;
    int? avgSinglePassDuration;

    SequenceGeneration({this.nrOfThreads,this.nrOfResultsProbed,this.duration,this.avgSinglePassDuration});
    SequenceGeneration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        nrOfThreads = json['nrOfThreads'];
        nrOfResultsProbed = json['nrOfResultsProbed'];
        duration = json['duration'];
        avgSinglePassDuration = json['avgSinglePassDuration'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'nrOfThreads': nrOfThreads,
        'nrOfResultsProbed': nrOfResultsProbed,
        'duration': duration,
        'avgSinglePassDuration': avgSinglePassDuration
    };

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

class SortingOrder
{
    static const SortingOrder None = const SortingOrder._(0);
    static const SortingOrder Ascending = const SortingOrder._(1);
    static const SortingOrder Descending = const SortingOrder._(2);

    final int _value;
    const SortingOrder._(this._value);
    int get value => _value;
    static List<SortingOrder> get values => const [None,Ascending,Descending];
}

class BestFitFinder implements IConvertible
{
    double? targetAmount;
    double? awardedAmount;
    double? deviation;
    double? deviationPct;
    String? sequenceResultType;
    bool? isJackPot5Drawn;
    int? filteringPeriod;
    SortingOrder? winCountOrder;
    double? minAmount;
    double? maxAmount;

    BestFitFinder({this.targetAmount,this.awardedAmount,this.deviation,this.deviationPct,this.sequenceResultType,this.isJackPot5Drawn,this.filteringPeriod,this.winCountOrder,this.minAmount,this.maxAmount});
    BestFitFinder.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        targetAmount = JsonConverters.toDouble(json['targetAmount']);
        awardedAmount = JsonConverters.toDouble(json['awardedAmount']);
        deviation = JsonConverters.toDouble(json['deviation']);
        deviationPct = JsonConverters.toDouble(json['deviationPct']);
        sequenceResultType = json['sequenceResultType'];
        isJackPot5Drawn = json['isJackPot5Drawn'];
        filteringPeriod = json['filteringPeriod'];
        winCountOrder = JsonConverters.fromJson(json['winCountOrder'],'SortingOrder',context!);
        minAmount = JsonConverters.toDouble(json['minAmount']);
        maxAmount = JsonConverters.toDouble(json['maxAmount']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'targetAmount': targetAmount,
        'awardedAmount': awardedAmount,
        'deviation': deviation,
        'deviationPct': deviationPct,
        'sequenceResultType': sequenceResultType,
        'isJackPot5Drawn': isJackPot5Drawn,
        'filteringPeriod': filteringPeriod,
        'winCountOrder': JsonConverters.toJson(winCountOrder,'SortingOrder',context!),
        'minAmount': minAmount,
        'maxAmount': maxAmount
    };

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

class Bet implements IConvertible
{
    bool? isFound;
    String? betId;
    String? slipId;
    dynamic? combStake;

    Bet({this.isFound,this.betId,this.slipId,this.combStake});
    Bet.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'isFound': isFound,
        'betId': betId,
        'slipId': slipId,
        'combStake': JsonConverters.toJson(combStake,'dynamic',context!)
    };

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

class QualifiedPool implements IConvertible
{
    int? id;
    String? name;
    double? coefficient;
    double? availableAmount;
    double? awardedAmount;
    Bet? targetBet;

    QualifiedPool({this.id,this.name,this.coefficient,this.availableAmount,this.awardedAmount,this.targetBet});
    QualifiedPool.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        coefficient = JsonConverters.toDouble(json['coefficient']);
        availableAmount = JsonConverters.toDouble(json['availableAmount']);
        awardedAmount = JsonConverters.toDouble(json['awardedAmount']);
        targetBet = JsonConverters.fromJson(json['targetBet'],'Bet',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'coefficient': coefficient,
        'availableAmount': availableAmount,
        'awardedAmount': awardedAmount,
        'targetBet': JsonConverters.toJson(targetBet,'Bet',context!)
    };

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

class Purger implements IConvertible
{
    double? prevalentStake;
    String? poolPurger;
    List<QualifiedPool>? qualifiedPools;

    Purger({this.prevalentStake,this.poolPurger,this.qualifiedPools});
    Purger.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        prevalentStake = JsonConverters.toDouble(json['prevalentStake']);
        poolPurger = json['poolPurger'];
        qualifiedPools = JsonConverters.fromJson(json['qualifiedPools'],'List<QualifiedPool>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'prevalentStake': prevalentStake,
        'poolPurger': poolPurger,
        'qualifiedPools': JsonConverters.toJson(qualifiedPools,'List<QualifiedPool>',context!)
    };

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

class ResponseStatus
{
    static const ResponseStatus Failure = const ResponseStatus._(0);
    static const ResponseStatus Success = const ResponseStatus._(1);

    final int _value;
    const ResponseStatus._(this._value);
    int get value => _value;
    static List<ResponseStatus> get values => const [Failure,Success];
}

class StimulationResponse implements IConvertible
{
    String? stimulationId;
    ResponseStatus? status;
    String? failureReason;
    String? slipId;
    String? betId;
    double? amountAwarded;

    StimulationResponse({this.stimulationId,this.status,this.failureReason,this.slipId,this.betId,this.amountAwarded});
    StimulationResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        stimulationId = json['stimulationId'];
        status = JsonConverters.fromJson(json['status'],'ResponseStatus',context!);
        failureReason = json['failureReason'];
        slipId = json['slipId'];
        betId = json['betId'];
        amountAwarded = JsonConverters.toDouble(json['amountAwarded']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'stimulationId': stimulationId,
        'status': JsonConverters.toJson(status,'ResponseStatus',context!),
        'failureReason': failureReason,
        'slipId': slipId,
        'betId': betId,
        'amountAwarded': amountAwarded
    };

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

class CurrentRoundInfo implements IConvertible
{
    String? roundId;
    double? amount;
    String? inertCode;

    CurrentRoundInfo({this.roundId,this.amount,this.inertCode});
    CurrentRoundInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        roundId = json['roundId'];
        amount = JsonConverters.toDouble(json['amount']);
        inertCode = json['inertCode'];
        return this;
    }

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

    getTypeName() => "CurrentRoundInfo";
    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 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 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 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 LocalCodePotInfo implements IConvertible
{
    bool? isActive;
    CurrentRoundInfo? current;
    List<WinnerByCode>? winners;

    LocalCodePotInfo({this.isActive,this.current,this.winners});
    LocalCodePotInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        isActive = json['isActive'];
        current = JsonConverters.fromJson(json['current'],'CurrentRoundInfo',context!);
        winners = JsonConverters.fromJson(json['winners'],'List<WinnerByCode>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'isActive': isActive,
        'current': JsonConverters.toJson(current,'CurrentRoundInfo',context!),
        'winners': JsonConverters.toJson(winners,'List<WinnerByCode>',context!)
    };

    getTypeName() => "LocalCodePotInfo";
    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 HappyHourInfo implements IConvertible
{
    bool? isHappyHour;
    double? oddsModifier;
    double? roundPoolBonusPct;

    HappyHourInfo({this.isHappyHour,this.oddsModifier,this.roundPoolBonusPct});
    HappyHourInfo.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() => "HappyHourInfo";
    TypeContext? context = _ctx;
}

class AccumulatorConfiguration extends AccumulatorConfiguration implements IConvertible
{
    String? id;
    DateTime? updatedAt;

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

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

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

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

class SyphonType
{
    static const SyphonType Location = const SyphonType._(0);
    static const SyphonType Bettor = const SyphonType._(1);

    final int _value;
    const SyphonType._(this._value);
    int get value => _value;
    static List<SyphonType> get values => const [Location,Bettor];
}

class Syphon implements IConvertible
{
    String? id;
    String? name;
    SyphonType? type;
    int? nrOfCombinations;

    Syphon({this.id,this.name,this.type,this.nrOfCombinations});
    Syphon.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'type': JsonConverters.toJson(type,'SyphonType',context!),
        'nrOfCombinations': nrOfCombinations
    };

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

class SyphonInfo implements IConvertible
{
    Map<String,Syphon?>? bettors;
    Map<String,Syphon?>? locations;
    bool? hasSyphons;
    int? totalSyphonsInRound;

    SyphonInfo({this.bettors,this.locations,this.hasSyphons,this.totalSyphonsInRound});
    SyphonInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        bettors = JsonConverters.fromJson(json['bettors'],'Map<String,Syphon?>',context!);
        locations = JsonConverters.fromJson(json['locations'],'Map<String,Syphon?>',context!);
        hasSyphons = json['hasSyphons'];
        totalSyphonsInRound = json['totalSyphonsInRound'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'bettors': JsonConverters.toJson(bettors,'Map<String,Syphon?>',context!),
        'locations': JsonConverters.toJson(locations,'Map<String,Syphon?>',context!),
        'hasSyphons': hasSyphons,
        'totalSyphonsInRound': totalSyphonsInRound
    };

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

class DrawDiagnostics implements IConvertible
{
    String? id;
    Initialization? initializationInfo;
    SequenceGeneration? sequenceGenerationInfo;
    BestFitFinder? bestFitFinderInfo;
    Purger? purgerInfo;
    int? duration;
    List<StimulationResponse>? stimulationResponses;
    LocalCodePotInfo? localCodePot;
    SuperWinInfo? superWin;
    HappyHourInfo? happyHour;
    String? reasoning;
    AccumulatorConfiguration? configuration;
    SyphonInfo? syphonInfo;

    DrawDiagnostics({this.id,this.initializationInfo,this.sequenceGenerationInfo,this.bestFitFinderInfo,this.purgerInfo,this.duration,this.stimulationResponses,this.localCodePot,this.superWin,this.happyHour,this.reasoning,this.configuration,this.syphonInfo});
    DrawDiagnostics.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        initializationInfo = JsonConverters.fromJson(json['initializationInfo'],'Initialization',context!);
        sequenceGenerationInfo = JsonConverters.fromJson(json['sequenceGenerationInfo'],'SequenceGeneration',context!);
        bestFitFinderInfo = JsonConverters.fromJson(json['bestFitFinderInfo'],'BestFitFinder',context!);
        purgerInfo = JsonConverters.fromJson(json['purgerInfo'],'Purger',context!);
        duration = json['duration'];
        stimulationResponses = JsonConverters.fromJson(json['stimulationResponses'],'List<StimulationResponse>',context!);
        localCodePot = JsonConverters.fromJson(json['localCodePot'],'LocalCodePotInfo',context!);
        superWin = JsonConverters.fromJson(json['superWin'],'SuperWinInfo',context!);
        happyHour = JsonConverters.fromJson(json['happyHour'],'HappyHourInfo',context!);
        reasoning = json['reasoning'];
        configuration = JsonConverters.fromJson(json['configuration'],'AccumulatorConfiguration',context!);
        syphonInfo = JsonConverters.fromJson(json['syphonInfo'],'SyphonInfo',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'initializationInfo': JsonConverters.toJson(initializationInfo,'Initialization',context!),
        'sequenceGenerationInfo': JsonConverters.toJson(sequenceGenerationInfo,'SequenceGeneration',context!),
        'bestFitFinderInfo': JsonConverters.toJson(bestFitFinderInfo,'BestFitFinder',context!),
        'purgerInfo': JsonConverters.toJson(purgerInfo,'Purger',context!),
        'duration': duration,
        'stimulationResponses': JsonConverters.toJson(stimulationResponses,'List<StimulationResponse>',context!),
        'localCodePot': JsonConverters.toJson(localCodePot,'LocalCodePotInfo',context!),
        'superWin': JsonConverters.toJson(superWin,'SuperWinInfo',context!),
        'happyHour': JsonConverters.toJson(happyHour,'HappyHourInfo',context!),
        'reasoning': reasoning,
        'configuration': JsonConverters.toJson(configuration,'AccumulatorConfiguration',context!),
        'syphonInfo': JsonConverters.toJson(syphonInfo,'SyphonInfo',context!)
    };

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

class GetDrawDignostics implements IConvertible
{
    String? id;

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

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

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

    getTypeName() => "GetDrawDignostics";
    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;
}

TypeContext _ctx = TypeContext(library: 's4w2.api.bettor.cc', types: <String, TypeInfo> {
    'Initialization': TypeInfo(TypeOf.Class, create:() => Initialization()),
    'SequenceGeneration': TypeInfo(TypeOf.Class, create:() => SequenceGeneration()),
    'SortingOrder': TypeInfo(TypeOf.Enum, enumValues:SortingOrder.values),
    'BestFitFinder': TypeInfo(TypeOf.Class, create:() => BestFitFinder()),
    'Bet': TypeInfo(TypeOf.Class, create:() => Bet()),
    'QualifiedPool': TypeInfo(TypeOf.Class, create:() => QualifiedPool()),
    'Purger': TypeInfo(TypeOf.Class, create:() => Purger()),
    'List<QualifiedPool>': TypeInfo(TypeOf.Class, create:() => <QualifiedPool>[]),
    'StimulationResponse': TypeInfo(TypeOf.Class, create:() => StimulationResponse()),
    'CurrentRoundInfo': TypeInfo(TypeOf.Class, create:() => CurrentRoundInfo()),
    'BettingApp': TypeInfo(TypeOf.Class, create:() => BettingApp()),
    'Ref': TypeInfo(TypeOf.Class, create:() => Ref()),
    'RefEx': TypeInfo(TypeOf.Class, create:() => RefEx()),
    'RecordDictionary<String,String>': TypeInfo(TypeOf.Class, create:() => RecordDictionary<String,String>()),
    'Origin': TypeInfo(TypeOf.Class, create:() => Origin()),
    'WinnerByCode': TypeInfo(TypeOf.Class, create:() => WinnerByCode()),
    'LocalCodePotInfo': TypeInfo(TypeOf.Class, create:() => LocalCodePotInfo()),
    'List<WinnerByCode>': TypeInfo(TypeOf.Class, create:() => <WinnerByCode>[]),
    'SuperWinInfo': TypeInfo(TypeOf.Class, create:() => SuperWinInfo()),
    'HappyHourInfo': TypeInfo(TypeOf.Class, create:() => HappyHourInfo()),
    'AccumulatorConfiguration': TypeInfo(TypeOf.Class, create:() => AccumulatorConfiguration()),
    'SyphonType': TypeInfo(TypeOf.Enum, enumValues:SyphonType.values),
    'Syphon': TypeInfo(TypeOf.Class, create:() => Syphon()),
    'SyphonInfo': TypeInfo(TypeOf.Class, create:() => SyphonInfo()),
    'Map<String,Syphon?>': TypeInfo(TypeOf.Class, create:() => Map<String,Syphon?>()),
    'DrawDiagnostics': TypeInfo(TypeOf.Class, create:() => DrawDiagnostics()),
    'List<StimulationResponse>': TypeInfo(TypeOf.Class, create:() => <StimulationResponse>[]),
    'GetDrawDignostics': TypeInfo(TypeOf.Class, create:() => GetDrawDignostics()),
    'RecordDictionary<TKey,TVal>': TypeInfo(TypeOf.GenericDef,create:() => RecordDictionary()),
});

Dart GetDrawDignostics DTOs

POST /qry/rounds/draw/diagnostics HTTP/1.1 
Host: s4w2.api.bettor.cc 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<GetDrawDignostics xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Six4Win.WebApi.ServiceModel">
  <Id>String</Id>
</GetDrawDignostics>

HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length

<DrawDiagnostics xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Six4Win.ReadModel">
  <BestFitFinderInfo>
    <AwardedAmount>0</AwardedAmount>
    <Deviation>0</Deviation>
    <DeviationPct>0</DeviationPct>
    <FilteringPeriod>0</FilteringPeriod>
    <IsJackPot5Drawn>false</IsJackPot5Drawn>
    <MaxAmount>0</MaxAmount>
    <MinAmount>0</MinAmount>
    <SequenceResultType>String</SequenceResultType>
    <TargetAmount>0</TargetAmount>
    <WinCountOrder>None</WinCountOrder>
  </BestFitFinderInfo>
  <Configuration xmlns:d2p1="http://schemas.datacontract.org/2004/07/Six4Win">
    <d2p1:AntiSyphonProtectionOverride>false</d2p1:AntiSyphonProtectionOverride>
    <d2p1:DebugConfig>
      <d2p1:LogBettorSats>false</d2p1:LogBettorSats>
      <d2p1:LogLocationStats>false</d2p1:LogLocationStats>
    </d2p1:DebugConfig>
    <d2p1:DeviationCategorySpanInPct>0</d2p1:DeviationCategorySpanInPct>
    <d2p1:DeviationCategoryThresholdAmount>0</d2p1:DeviationCategoryThresholdAmount>
    <d2p1:FraudDetectionConfig>
      <d2p1:AntiSyphon>
        <d2p1:CombinationCountPerRoundThresholdPct>0</d2p1:CombinationCountPerRoundThresholdPct>
        <d2p1:ExcludedLocations xmlns:d5p1="http://schemas.datacontract.org/2004/07/Starnet.Common">
          <d5p1:Ref>
            <d5p1:Id>String</d5p1:Id>
            <d5p1:Val>String</d5p1:Val>
          </d5p1:Ref>
        </d2p1:ExcludedLocations>
        <d2p1:IncludeRoundPctAsBettorSyphonCriteria>false</d2p1:IncludeRoundPctAsBettorSyphonCriteria>
        <d2p1:IsActive>false</d2p1:IsActive>
      </d2p1:AntiSyphon>
    </d2p1:FraudDetectionConfig>
    <d2p1:HighRollerSettings>
      <d2p1:CategoryThresholds>
        <d2p1:HighRollerSettings.CategoryThreshold>
          <d2p1:Category>Pickerel</d2p1:Category>
          <d2p1:Threshold>0</d2p1:Threshold>
        </d2p1:HighRollerSettings.CategoryThreshold>
      </d2p1:CategoryThresholds>
      <d2p1:Pools>
        <d2p1:HighRollerSettings.PoolSettings>
          <d2p1:Caps>
            <d2p1:MaxAmountInPrevalentStakes>0</d2p1:MaxAmountInPrevalentStakes>
            <d2p1:MinusCoef>0</d2p1:MinusCoef>
            <d2p1:PlusCoef>0</d2p1:PlusCoef>
          </d2p1:Caps>
          <d2p1:ContributionToRoundPoolPct>0</d2p1:ContributionToRoundPoolPct>
          <d2p1:Id>0</d2p1:Id>
          <d2p1:IsActive>false</d2p1:IsActive>
          <d2p1:Name>String</d2p1:Name>
        </d2p1:HighRollerSettings.PoolSettings>
      </d2p1:Pools>
    </d2p1:HighRollerSettings>
    <d2p1:JackPot5ThresholdInterval>
      <d2p1:End>0</d2p1:End>
      <d2p1:Start>0</d2p1:Start>
    </d2p1:JackPot5ThresholdInterval>
    <d2p1:LocationOptimizationLevel>None</d2p1:LocationOptimizationLevel>
    <d2p1:LowWinCountAffinityInPct>0</d2p1:LowWinCountAffinityInPct>
    <d2p1:OverflowCoefficientPoolsToRound>false</d2p1:OverflowCoefficientPoolsToRound>
    <d2p1:Pools>
      <d2p1:AccumulatorConfiguration.Pool>
        <d2p1:Id>0</d2p1:Id>
        <d2p1:Name>String</d2p1:Name>
        <d2p1:RTP>0</d2p1:RTP>
        <d2p1:ReserveRTP>0</d2p1:ReserveRTP>
      </d2p1:AccumulatorConfiguration.Pool>
    </d2p1:Pools>
    <d2p1:PrevalentStake>0</d2p1:PrevalentStake>
    <d2p1:PurgeThresholdModifier>0</d2p1:PurgeThresholdModifier>
    <d2p1:RoundPoolCircuitBreakerThreshold>0</d2p1:RoundPoolCircuitBreakerThreshold>
    <d2p1:WinCountOrderAffinity>
      <d2p1:WinCountOrderProbability>
        <d2p1:Order>None</d2p1:Order>
        <d2p1:Probability>0</d2p1:Probability>
      </d2p1:WinCountOrderProbability>
    </d2p1:WinCountOrderAffinity>
  </Configuration>
  <Duration>0</Duration>
  <HappyHour>
    <IsHappyHour>false</IsHappyHour>
    <OddsModifier>0</OddsModifier>
    <RoundPoolBonusPct>0</RoundPoolBonusPct>
  </HappyHour>
  <Id>String</Id>
  <InitializationInfo>
    <BetsCollectionsCreationDuration>0</BetsCollectionsCreationDuration>
    <CombinationsOccuranceLookupInitializationDuration>0</CombinationsOccuranceLookupInitializationDuration>
    <DataLoadDuration>0</DataLoadDuration>
  </InitializationInfo>
  <LocalCodePot>
    <DurationInMs>0</DurationInMs>
  </LocalCodePot>
  <PurgerInfo>
    <PoolPurger>String</PoolPurger>
    <PrevalentStake>0</PrevalentStake>
    <QualifiedPools>
      <DrawDiagnostics.QualifiedPool>
        <AvailableAmount>0</AvailableAmount>
        <AwardedAmount>0</AwardedAmount>
        <Coefficient>0</Coefficient>
        <Id>0</Id>
        <Name>String</Name>
        <TargetBet>
          <BetId>String</BetId>
          <CombStake />
          <IsFound>false</IsFound>
          <SlipId>String</SlipId>
        </TargetBet>
      </DrawDiagnostics.QualifiedPool>
    </QualifiedPools>
  </PurgerInfo>
  <Reasoning>String</Reasoning>
  <SequenceGenerationInfo>
    <AvgSinglePassDuration>0</AvgSinglePassDuration>
    <Duration>0</Duration>
    <NrOfResultsProbed>0</NrOfResultsProbed>
    <NrOfThreads>0</NrOfThreads>
  </SequenceGenerationInfo>
  <StimulationResponses>
    <DrawDiagnostics.StimulationResponse>
      <AmountAwarded>0</AmountAwarded>
      <BetId>String</BetId>
      <FailureReason>String</FailureReason>
      <SlipId>String</SlipId>
      <Status>Failure</Status>
      <StimulationId>String</StimulationId>
    </DrawDiagnostics.StimulationResponse>
  </StimulationResponses>
  <SuperWin>
    <DurationInMs>0</DurationInMs>
  </SuperWin>
  <SyphonInfo xmlns:d2p1="http://schemas.datacontract.org/2004/07/Six4Win.Common">
    <d2p1:Bettors xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
      <d3p1:KeyValueOfstringSyphonFQuwRXs4>
        <d3p1:Key>String</d3p1:Key>
        <d3p1:Value>
          <d2p1:Id>String</d2p1:Id>
          <d2p1:Name>String</d2p1:Name>
          <d2p1:NrOfCombinations>0</d2p1:NrOfCombinations>
          <d2p1:Type>Location</d2p1:Type>
        </d3p1:Value>
      </d3p1:KeyValueOfstringSyphonFQuwRXs4>
    </d2p1:Bettors>
    <d2p1:Locations xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
      <d3p1:KeyValueOfstringSyphonFQuwRXs4>
        <d3p1:Key>String</d3p1:Key>
        <d3p1:Value>
          <d2p1:Id>String</d2p1:Id>
          <d2p1:Name>String</d2p1:Name>
          <d2p1:NrOfCombinations>0</d2p1:NrOfCombinations>
          <d2p1:Type>Location</d2p1:Type>
        </d3p1:Value>
      </d3p1:KeyValueOfstringSyphonFQuwRXs4>
    </d2p1:Locations>
  </SyphonInfo>
</DrawDiagnostics>