| All Verbs | /qry/rounds/draw/diagnostics |
|---|
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()),
});
To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv
The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.
POST /qry/rounds/draw/diagnostics HTTP/1.1
Host: s4w2.api.bettor.cc
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length
{
id: String
}
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length
{
id: String,
initializationInfo:
{
dataLoadDuration: 0,
betsCollectionsCreationDuration: 0,
combinationsOccuranceLookupInitializationDuration: 0
},
sequenceGenerationInfo:
{
nrOfThreads: 0,
nrOfResultsProbed: 0,
duration: 0,
avgSinglePassDuration: 0
},
bestFitFinderInfo:
{
targetAmount: 0,
awardedAmount: 0,
deviation: 0,
deviationPct: 0,
sequenceResultType: String,
isJackPot5Drawn: False,
filteringPeriod: 0,
winCountOrder: 0,
minAmount: 0,
maxAmount: 0
},
purgerInfo:
{
prevalentStake: 0,
poolPurger: String,
qualifiedPools:
[
{
id: 0,
name: String,
coefficient: 0,
availableAmount: 0,
awardedAmount: 0,
targetBet:
{
isFound: False,
betId: String,
slipId: String,
combStake: {}
}
}
]
},
duration: 0,
stimulationResponses:
[
{
stimulationId: String,
status: 0,
failureReason: String,
slipId: String,
betId: String,
amountAwarded: 0
}
],
localCodePot:
{
durationInMs: 0
},
superWin:
{
durationInMs: 0
},
happyHour:
{
isHappyHour: False,
oddsModifier: 0,
roundPoolBonusPct: 0
},
reasoning: String,
configuration:
{
pools:
[
{
id: 0,
name: String,
rtp: 0,
reserveRTP: 0,
totalRTP: 0
}
],
prevalentStake: 0,
purgeThresholdModifier: 0,
locationOptimizationLevel: 0,
jackPot5ThresholdInterval:
{
start: 0,
end: 0
},
deviationCategorySpanInPct: 0,
deviationCategoryThresholdAmount: 0,
roundPoolCircuitBreakerThreshold: 0,
lowWinCountAffinityInPct: 0,
winCountOrderAffinity:
[
{
order: 0,
probability: 0
}
],
highRollerSettings:
{
pools:
[
{
id: 0,
name: String,
isActive: False,
contributionToRoundPoolPct: 0,
caps:
{
plusCoef: 0,
minusCoef: 0,
maxAmountInPrevalentStakes: 0
}
}
],
categoryThresholds:
[
{
category: 0,
threshold: 0
}
]
},
overflowCoefficientPoolsToRound: False,
antiSyphonProtectionOverride: False,
fraudDetectionConfig:
{
antiSyphon:
{
combinationCountPerRoundThresholdPct: 0,
excludedLocations:
[
{
id: String,
val: String
}
],
includeRoundPctAsBettorSyphonCriteria: False,
isActive: False
}
},
debugConfig:
{
logLocationStats: False,
logBettorSats: False
}
},
syphonInfo:
{
bettors:
{
String:
{
id: String,
name: String,
type: 0,
nrOfCombinations: 0
}
},
locations:
{
String:
{
id: String,
name: String,
type: 0,
nrOfCombinations: 0
}
},
hasSyphons: True,
totalSyphonsInRound: 2
}
}