/* Options:
Date: 2025-11-09 11:09:44
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: GetDrawDignostics.*
//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 Bet implements IConvertible
{
    String? id;
    int? ordinalOfAvailableRoundToAssignTo;
    String? content;
    double? stake;
    Map<String,String?>? payload;

    Bet({this.id,this.ordinalOfAvailableRoundToAssignTo,this.content,this.stake,this.payload});
    Bet.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        ordinalOfAvailableRoundToAssignTo = json['ordinalOfAvailableRoundToAssignTo'];
        content = json['content'];
        stake = JsonConverters.toDouble(json['stake']);
        payload = JsonConverters.toStringMap(json['payload']);
        return this;
    }

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

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

class Pool implements IConvertible
{
    int? id;
    String? name;
    double? treshold;

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

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

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

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

class LocationOptimizationLevel
{
    static const LocationOptimizationLevel None = const LocationOptimizationLevel._(0);
    static const LocationOptimizationLevel Low = const LocationOptimizationLevel._(1);
    static const LocationOptimizationLevel Medium = const LocationOptimizationLevel._(2);
    static const LocationOptimizationLevel High = const LocationOptimizationLevel._(3);

    final int _value;
    const LocationOptimizationLevel._(this._value);
    int get value => _value;
    static List<LocationOptimizationLevel> get values => const [None,Low,Medium,High];
}

class ThresholdInterval implements IConvertible
{
    double? start;
    double? end;

    ThresholdInterval({this.start,this.end});
    ThresholdInterval.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

    getTypeName() => "ThresholdInterval";
    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 WinCountOrderProbability implements IConvertible
{
    SortingOrder? order;
    int? probability;

    WinCountOrderProbability({this.order,this.probability});
    WinCountOrderProbability.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'order': JsonConverters.toJson(order,'SortingOrder',context!),
        'probability': probability
    };

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

class PoolCaps implements IConvertible
{
    double? plusCoef;
    double? minusCoef;
    double? maxAmountInPrevalentStakes;

    PoolCaps({this.plusCoef,this.minusCoef,this.maxAmountInPrevalentStakes});
    PoolCaps.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        plusCoef = JsonConverters.toDouble(json['plusCoef']);
        minusCoef = JsonConverters.toDouble(json['minusCoef']);
        maxAmountInPrevalentStakes = JsonConverters.toDouble(json['maxAmountInPrevalentStakes']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'plusCoef': plusCoef,
        'minusCoef': minusCoef,
        'maxAmountInPrevalentStakes': maxAmountInPrevalentStakes
    };

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

class PoolSettings implements IConvertible
{
    int? id;
    String? name;
    bool? isActive;
    double? contributionToRoundPoolPct;
    PoolCaps? caps;

    PoolSettings({this.id,this.name,this.isActive,this.contributionToRoundPoolPct,this.caps});
    PoolSettings.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        isActive = json['isActive'];
        contributionToRoundPoolPct = JsonConverters.toDouble(json['contributionToRoundPoolPct']);
        caps = JsonConverters.fromJson(json['caps'],'PoolCaps',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'isActive': isActive,
        'contributionToRoundPoolPct': contributionToRoundPoolPct,
        'caps': JsonConverters.toJson(caps,'PoolCaps',context!)
    };

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

class StakeCategory
{
    static const StakeCategory Pickerel = const StakeCategory._(0);
    static const StakeCategory Fish = const StakeCategory._(1);
    static const StakeCategory Salmon = const StakeCategory._(2);
    static const StakeCategory Tuna = const StakeCategory._(3);
    static const StakeCategory Shark = const StakeCategory._(4);
    static const StakeCategory Whale = const StakeCategory._(5);
    static const StakeCategory None = const StakeCategory._(-1);

    final int _value;
    const StakeCategory._(this._value);
    int get value => _value;
    static List<StakeCategory> get values => const [Pickerel,Fish,Salmon,Tuna,Shark,Whale,None];
}

class CategoryThreshold implements IConvertible
{
    StakeCategory? category;
    double? threshold;

    CategoryThreshold({this.category,this.threshold});
    CategoryThreshold.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'category': JsonConverters.toJson(category,'StakeCategory',context!),
        'threshold': threshold
    };

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

class HighRollerSettings implements IConvertible
{
    RecordList<PoolSettings>? pools;
    RecordList<CategoryThreshold>? categoryThresholds;

    HighRollerSettings({this.pools,this.categoryThresholds});
    HighRollerSettings.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pools = JsonConverters.fromJson(json['pools'],'RecordList<PoolSettings>',context!);
        categoryThresholds = JsonConverters.fromJson(json['categoryThresholds'],'RecordList<CategoryThreshold>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pools': JsonConverters.toJson(pools,'RecordList<PoolSettings>',context!),
        'categoryThresholds': JsonConverters.toJson(categoryThresholds,'RecordList<CategoryThreshold>',context!)
    };

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

class AntiSyphonConfig implements IConvertible
{
    double? combinationCountPerRoundThresholdPct;
    RecordList<Ref>? excludedLocations;
    bool? includeRoundPctAsBettorSyphonCriteria;
    bool? isActive;

    AntiSyphonConfig({this.combinationCountPerRoundThresholdPct,this.excludedLocations,this.includeRoundPctAsBettorSyphonCriteria,this.isActive});
    AntiSyphonConfig.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        combinationCountPerRoundThresholdPct = JsonConverters.toDouble(json['combinationCountPerRoundThresholdPct']);
        excludedLocations = JsonConverters.fromJson(json['excludedLocations'],'RecordList<Ref>',context!);
        includeRoundPctAsBettorSyphonCriteria = json['includeRoundPctAsBettorSyphonCriteria'];
        isActive = json['isActive'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'combinationCountPerRoundThresholdPct': combinationCountPerRoundThresholdPct,
        'excludedLocations': JsonConverters.toJson(excludedLocations,'RecordList<Ref>',context!),
        'includeRoundPctAsBettorSyphonCriteria': includeRoundPctAsBettorSyphonCriteria,
        'isActive': isActive
    };

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

class FraudDetectionConfiguration implements IConvertible
{
    AntiSyphonConfig? antiSyphon;

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

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

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

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

class DebugConfiguration implements IConvertible
{
    bool? logLocationStats;
    bool? logBettorSats;

    DebugConfiguration({this.logLocationStats,this.logBettorSats});
    DebugConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class AccumulatorConfiguration implements IConvertible
{
    RecordList<Pool>? pools;
    double? prevalentStake;
    double? purgeThresholdModifier;
    LocationOptimizationLevel? locationOptimizationLevel;
    ThresholdInterval? jackPot5ThresholdInterval;
    int? deviationCategorySpanInPct;
    double? deviationCategoryThresholdAmount;
    double? roundPoolCircuitBreakerThreshold;
    int? lowWinCountAffinityInPct;
    RecordList<WinCountOrderProbability>? winCountOrderAffinity;
    HighRollerSettings? highRollerSettings;
    bool? overflowCoefficientPoolsToRound;
    bool? antiSyphonProtectionOverride;
    FraudDetectionConfiguration? fraudDetectionConfig;
    DebugConfiguration? debugConfig;

    AccumulatorConfiguration({this.pools,this.prevalentStake,this.purgeThresholdModifier,this.locationOptimizationLevel,this.jackPot5ThresholdInterval,this.deviationCategorySpanInPct,this.deviationCategoryThresholdAmount,this.roundPoolCircuitBreakerThreshold,this.lowWinCountAffinityInPct,this.winCountOrderAffinity,this.highRollerSettings,this.overflowCoefficientPoolsToRound,this.antiSyphonProtectionOverride,this.fraudDetectionConfig,this.debugConfig});
    AccumulatorConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        pools = JsonConverters.fromJson(json['pools'],'RecordList<Pool>',context!);
        prevalentStake = JsonConverters.toDouble(json['prevalentStake']);
        purgeThresholdModifier = JsonConverters.toDouble(json['purgeThresholdModifier']);
        locationOptimizationLevel = JsonConverters.fromJson(json['locationOptimizationLevel'],'LocationOptimizationLevel',context!);
        jackPot5ThresholdInterval = JsonConverters.fromJson(json['jackPot5ThresholdInterval'],'ThresholdInterval',context!);
        deviationCategorySpanInPct = json['deviationCategorySpanInPct'];
        deviationCategoryThresholdAmount = JsonConverters.toDouble(json['deviationCategoryThresholdAmount']);
        roundPoolCircuitBreakerThreshold = JsonConverters.toDouble(json['roundPoolCircuitBreakerThreshold']);
        lowWinCountAffinityInPct = json['lowWinCountAffinityInPct'];
        winCountOrderAffinity = JsonConverters.fromJson(json['winCountOrderAffinity'],'RecordList<WinCountOrderProbability>',context!);
        highRollerSettings = JsonConverters.fromJson(json['highRollerSettings'],'HighRollerSettings',context!);
        overflowCoefficientPoolsToRound = json['overflowCoefficientPoolsToRound'];
        antiSyphonProtectionOverride = json['antiSyphonProtectionOverride'];
        fraudDetectionConfig = JsonConverters.fromJson(json['fraudDetectionConfig'],'FraudDetectionConfiguration',context!);
        debugConfig = JsonConverters.fromJson(json['debugConfig'],'DebugConfiguration',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'pools': JsonConverters.toJson(pools,'RecordList<Pool>',context!),
        'prevalentStake': prevalentStake,
        'purgeThresholdModifier': purgeThresholdModifier,
        'locationOptimizationLevel': JsonConverters.toJson(locationOptimizationLevel,'LocationOptimizationLevel',context!),
        'jackPot5ThresholdInterval': JsonConverters.toJson(jackPot5ThresholdInterval,'ThresholdInterval',context!),
        'deviationCategorySpanInPct': deviationCategorySpanInPct,
        'deviationCategoryThresholdAmount': deviationCategoryThresholdAmount,
        'roundPoolCircuitBreakerThreshold': roundPoolCircuitBreakerThreshold,
        'lowWinCountAffinityInPct': lowWinCountAffinityInPct,
        'winCountOrderAffinity': JsonConverters.toJson(winCountOrderAffinity,'RecordList<WinCountOrderProbability>',context!),
        'highRollerSettings': JsonConverters.toJson(highRollerSettings,'HighRollerSettings',context!),
        'overflowCoefficientPoolsToRound': overflowCoefficientPoolsToRound,
        'antiSyphonProtectionOverride': antiSyphonProtectionOverride,
        'fraudDetectionConfig': JsonConverters.toJson(fraudDetectionConfig,'FraudDetectionConfiguration',context!),
        'debugConfig': JsonConverters.toJson(debugConfig,'DebugConfiguration',context!)
    };

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

class Pool implements IConvertible
{
    int? id;
    String? name;
    double? coefficient;
    double? rtp;
    double? threshold;
    double? balance;
    double? rrtp;
    double? rBalance;

    Pool({this.id,this.name,this.coefficient,this.rtp,this.threshold,this.balance,this.rrtp,this.rBalance});
    Pool.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        coefficient = JsonConverters.toDouble(json['coefficient']);
        rtp = JsonConverters.toDouble(json['rtp']);
        threshold = JsonConverters.toDouble(json['threshold']);
        balance = JsonConverters.toDouble(json['balance']);
        rrtp = JsonConverters.toDouble(json['rrtp']);
        rBalance = JsonConverters.toDouble(json['rBalance']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'coefficient': coefficient,
        'rtp': rtp,
        'threshold': threshold,
        'balance': balance,
        'rrtp': rrtp,
        'rBalance': rBalance
    };

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

class Bet implements IConvertible
{
    String? id;
    String? slipId;
    Ref? bettor;
    Origin? origin;
    DateTime? placedAt;
    String? roundId;
    String? content;
    double? stake;
    BetOutcome? outcome;
    double? win;
    BetProcessingStatus? processingStatus;
    BetValidity? validity;
    Map<String,String?>? results;
    Map<String,String?>? payload;

    Bet({this.id,this.slipId,this.bettor,this.origin,this.placedAt,this.roundId,this.content,this.stake,this.outcome,this.win,this.processingStatus,this.validity,this.results,this.payload});
    Bet.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        slipId = json['slipId'];
        bettor = JsonConverters.fromJson(json['bettor'],'Ref',context!);
        origin = JsonConverters.fromJson(json['origin'],'Origin',context!);
        placedAt = JsonConverters.fromJson(json['placedAt'],'DateTime',context!);
        roundId = json['roundId'];
        content = json['content'];
        stake = JsonConverters.toDouble(json['stake']);
        outcome = JsonConverters.fromJson(json['outcome'],'BetOutcome',context!);
        win = JsonConverters.toDouble(json['win']);
        processingStatus = JsonConverters.fromJson(json['processingStatus'],'BetProcessingStatus',context!);
        validity = JsonConverters.fromJson(json['validity'],'BetValidity',context!);
        results = JsonConverters.toStringMap(json['results']);
        payload = JsonConverters.toStringMap(json['payload']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'slipId': slipId,
        'bettor': JsonConverters.toJson(bettor,'Ref',context!),
        'origin': JsonConverters.toJson(origin,'Origin',context!),
        'placedAt': JsonConverters.toJson(placedAt,'DateTime',context!),
        'roundId': roundId,
        'content': content,
        'stake': stake,
        'outcome': JsonConverters.toJson(outcome,'BetOutcome',context!),
        'win': win,
        'processingStatus': JsonConverters.toJson(processingStatus,'BetProcessingStatus',context!),
        'validity': JsonConverters.toJson(validity,'BetValidity',context!),
        'results': results,
        'payload': payload
    };

    getTypeName() => "Bet";
    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 Pool implements IConvertible
{
    int? id;
    String? name;
    double? rtp;
    double? reserveRTP;
    double? totalRTP;

    Pool({this.id,this.name,this.rtp,this.reserveRTP,this.totalRTP});
    Pool.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        rtp = JsonConverters.toDouble(json['rtp']);
        reserveRTP = JsonConverters.toDouble(json['reserveRTP']);
        totalRTP = JsonConverters.toDouble(json['totalRTP']);
        return this;
    }

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

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

// @Route("/qry/rounds/draw/diagnostics")
class GetDrawDignostics implements IReturn<DrawDiagnostics>, IConvertible, IPost
{
    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
    };

    createResponse() => DrawDiagnostics();
    getResponseTypeName() => "DrawDiagnostics";
    getTypeName() => "GetDrawDignostics";
    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()),
    'Bet': TypeInfo(TypeOf.Class, create:() => Bet()),
    'Pool': TypeInfo(TypeOf.Class, create:() => Pool()),
    'LocationOptimizationLevel': TypeInfo(TypeOf.Enum, enumValues:LocationOptimizationLevel.values),
    'ThresholdInterval': TypeInfo(TypeOf.Class, create:() => ThresholdInterval()),
    'SortingOrder': TypeInfo(TypeOf.Enum, enumValues:SortingOrder.values),
    'WinCountOrderProbability': TypeInfo(TypeOf.Class, create:() => WinCountOrderProbability()),
    'PoolCaps': TypeInfo(TypeOf.Class, create:() => PoolCaps()),
    'PoolSettings': TypeInfo(TypeOf.Class, create:() => PoolSettings()),
    'StakeCategory': TypeInfo(TypeOf.Enum, enumValues:StakeCategory.values),
    'CategoryThreshold': TypeInfo(TypeOf.Class, create:() => CategoryThreshold()),
    'HighRollerSettings': TypeInfo(TypeOf.Class, create:() => HighRollerSettings()),
    'RecordList<PoolSettings>': TypeInfo(TypeOf.Class, create:() => RecordList<PoolSettings>()),
    'RecordList<CategoryThreshold>': TypeInfo(TypeOf.Class, create:() => RecordList<CategoryThreshold>()),
    'AntiSyphonConfig': TypeInfo(TypeOf.Class, create:() => AntiSyphonConfig()),
    'RecordList<Ref>': TypeInfo(TypeOf.Class, create:() => RecordList<Ref>()),
    'FraudDetectionConfiguration': TypeInfo(TypeOf.Class, create:() => FraudDetectionConfiguration()),
    'DebugConfiguration': TypeInfo(TypeOf.Class, create:() => DebugConfiguration()),
    'AccumulatorConfiguration': TypeInfo(TypeOf.Class, create:() => AccumulatorConfiguration()),
    'RecordList<Pool>': TypeInfo(TypeOf.Class, create:() => RecordList<Pool>()),
    'RecordList<WinCountOrderProbability>': TypeInfo(TypeOf.Class, create:() => RecordList<WinCountOrderProbability>()),
    'BetOutcome': TypeInfo(TypeOf.Class, create:() => BetOutcome()),
    'BetProcessingStatus': TypeInfo(TypeOf.Class, create:() => BetProcessingStatus()),
    'BetValidity': TypeInfo(TypeOf.Class, create:() => BetValidity()),
    'RecordList<T>': TypeInfo(TypeOf.GenericDef,create:() => RecordList()),
    'SuperWinInfo': TypeInfo(TypeOf.Class, create:() => SuperWinInfo()),
    'SuperWinWinner': TypeInfo(TypeOf.Class, create:() => SuperWinWinner()),
    'CurrentRoundInfo': TypeInfo(TypeOf.Class, create:() => CurrentRoundInfo()),
    'WinnerByCode': TypeInfo(TypeOf.Class, create:() => WinnerByCode()),
    'LocalCodePotInfo': TypeInfo(TypeOf.Class, create:() => LocalCodePotInfo()),
    'List<WinnerByCode>': TypeInfo(TypeOf.Class, create:() => <WinnerByCode>[]),
    'Initialization': TypeInfo(TypeOf.Class, create:() => Initialization()),
    'SequenceGeneration': TypeInfo(TypeOf.Class, create:() => SequenceGeneration()),
    'BestFitFinder': TypeInfo(TypeOf.Class, create:() => BestFitFinder()),
    '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()),
    'HappyHourInfo': TypeInfo(TypeOf.Class, create:() => HappyHourInfo()),
    '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?>()),
    'RecordDictionary<TKey,TVal>': TypeInfo(TypeOf.GenericDef,create:() => RecordDictionary()),
    'DrawDiagnostics': TypeInfo(TypeOf.Class, create:() => DrawDiagnostics()),
    'List<StimulationResponse>': TypeInfo(TypeOf.Class, create:() => <StimulationResponse>[]),
    'GetDrawDignostics': TypeInfo(TypeOf.Class, create:() => GetDrawDignostics()),
});