/* Options:
Date: 2025-11-09 11:09:43
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: GetAccumulatorConfig.*
//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 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 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 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 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;
}

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

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

TypeContext _ctx = TypeContext(library: 's4w2.api.bettor.cc', types: <String, TypeInfo> {
    'Ref': TypeInfo(TypeOf.Class, create:() => Ref()),
    '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>()),
    'RecordList<T>': TypeInfo(TypeOf.GenericDef,create:() => RecordList()),
    'GetAccumulatorConfig': TypeInfo(TypeOf.Class, create:() => GetAccumulatorConfig()),
});