| All Verbs | /qry/feed |
|---|
import 'package:servicestack/servicestack.dart';
class RoundStatus
{
static const RoundStatus Pending = const RoundStatus._(0);
static const RoundStatus InProgress = const RoundStatus._(1);
static const RoundStatus Ended = const RoundStatus._(2);
final int _value;
const RoundStatus._(this._value);
int get value => _value;
static List<RoundStatus> get values => const [Pending,InProgress,Ended];
}
class CountdownConfiguration implements IConvertible
{
int? lockdownStepFromEnd;
int? assertLockdownStepFromEnd;
CountdownConfiguration({this.lockdownStepFromEnd,this.assertLockdownStepFromEnd});
CountdownConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
lockdownStepFromEnd = json['lockdownStepFromEnd'];
assertLockdownStepFromEnd = json['assertLockdownStepFromEnd'];
return this;
}
Map<String, dynamic> toJson() => {
'lockdownStepFromEnd': lockdownStepFromEnd,
'assertLockdownStepFromEnd': assertLockdownStepFromEnd
};
getTypeName() => "CountdownConfiguration";
TypeContext? context = _ctx;
}
class DrawConfiguration implements IConvertible
{
int? introIntervalInMs;
int? animationIntervalInMs;
int? outroIntervalInMs;
DrawConfiguration({this.introIntervalInMs,this.animationIntervalInMs,this.outroIntervalInMs});
DrawConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
introIntervalInMs = json['introIntervalInMs'];
animationIntervalInMs = json['animationIntervalInMs'];
outroIntervalInMs = json['outroIntervalInMs'];
return this;
}
Map<String, dynamic> toJson() => {
'introIntervalInMs': introIntervalInMs,
'animationIntervalInMs': animationIntervalInMs,
'outroIntervalInMs': outroIntervalInMs
};
getTypeName() => "DrawConfiguration";
TypeContext? context = _ctx;
}
class RTPStrategies
{
static const RTPStrategies RNG = const RTPStrategies._(0);
static const RTPStrategies Accumulator = const RTPStrategies._(1);
final int _value;
const RTPStrategies._(this._value);
int get value => _value;
static List<RTPStrategies> get values => const [RNG,Accumulator];
}
class HappyHourConfiguration implements IConvertible
{
bool? isHappyHour;
double? oddsModifier;
double? roundPoolBonusPct;
HappyHourConfiguration({this.isHappyHour,this.oddsModifier,this.roundPoolBonusPct});
HappyHourConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
isHappyHour = json['isHappyHour'];
oddsModifier = JsonConverters.toDouble(json['oddsModifier']);
roundPoolBonusPct = JsonConverters.toDouble(json['roundPoolBonusPct']);
return this;
}
Map<String, dynamic> toJson() => {
'isHappyHour': isHappyHour,
'oddsModifier': oddsModifier,
'roundPoolBonusPct': roundPoolBonusPct
};
getTypeName() => "HappyHourConfiguration";
TypeContext? context = _ctx;
}
class RoundConfiguration implements IConvertible
{
RecordList<double>? coefficients;
bool? isDoubleTripleActive;
bool? isJackpot5Active;
int? countdownDurationInSeconds;
CountdownConfiguration? countdownConfiguration;
DrawConfiguration? drawConfiguration;
int? resultsDurationInSeconds;
RTPStrategies? rtpStrategy;
HappyHourConfiguration? happyHourConfiguration;
RoundConfiguration({this.coefficients,this.isDoubleTripleActive,this.isJackpot5Active,this.countdownDurationInSeconds,this.countdownConfiguration,this.drawConfiguration,this.resultsDurationInSeconds,this.rtpStrategy,this.happyHourConfiguration});
RoundConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
coefficients = JsonConverters.fromJson(json['coefficients'],'RecordList<double>',context!);
isDoubleTripleActive = json['isDoubleTripleActive'];
isJackpot5Active = json['isJackpot5Active'];
countdownDurationInSeconds = json['countdownDurationInSeconds'];
countdownConfiguration = JsonConverters.fromJson(json['countdownConfiguration'],'CountdownConfiguration',context!);
drawConfiguration = JsonConverters.fromJson(json['drawConfiguration'],'DrawConfiguration',context!);
resultsDurationInSeconds = json['resultsDurationInSeconds'];
rtpStrategy = JsonConverters.fromJson(json['rtpStrategy'],'RTPStrategies',context!);
happyHourConfiguration = JsonConverters.fromJson(json['happyHourConfiguration'],'HappyHourConfiguration',context!);
return this;
}
Map<String, dynamic> toJson() => {
'coefficients': JsonConverters.toJson(coefficients,'RecordList<double>',context!),
'isDoubleTripleActive': isDoubleTripleActive,
'isJackpot5Active': isJackpot5Active,
'countdownDurationInSeconds': countdownDurationInSeconds,
'countdownConfiguration': JsonConverters.toJson(countdownConfiguration,'CountdownConfiguration',context!),
'drawConfiguration': JsonConverters.toJson(drawConfiguration,'DrawConfiguration',context!),
'resultsDurationInSeconds': resultsDurationInSeconds,
'rtpStrategy': JsonConverters.toJson(rtpStrategy,'RTPStrategies',context!),
'happyHourConfiguration': JsonConverters.toJson(happyHourConfiguration,'HappyHourConfiguration',context!)
};
getTypeName() => "RoundConfiguration";
TypeContext? context = _ctx;
}
class 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 JackPot5Winner implements IConvertible
{
String? betId;
int? nrOfCombinations;
double? winningsAmount;
Origin? origin;
Ref? bettor;
Map<String,String?>? payload;
JackPot5Winner({this.betId,this.nrOfCombinations,this.winningsAmount,this.origin,this.bettor,this.payload});
JackPot5Winner.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
betId = json['betId'];
nrOfCombinations = json['nrOfCombinations'];
winningsAmount = JsonConverters.toDouble(json['winningsAmount']);
origin = JsonConverters.fromJson(json['origin'],'Origin',context!);
bettor = JsonConverters.fromJson(json['bettor'],'Ref',context!);
payload = JsonConverters.toStringMap(json['payload']);
return this;
}
Map<String, dynamic> toJson() => {
'betId': betId,
'nrOfCombinations': nrOfCombinations,
'winningsAmount': winningsAmount,
'origin': JsonConverters.toJson(origin,'Origin',context!),
'bettor': JsonConverters.toJson(bettor,'Ref',context!),
'payload': payload
};
getTypeName() => "JackPot5Winner";
TypeContext? context = _ctx;
}
class Jackpot5Info implements IConvertible
{
bool? isHit;
double? amountAccumulated;
double? amountAwarded;
int? nrOfWinners;
List<JackPot5Winner>? jackPot5Winners;
Jackpot5Info({this.isHit,this.amountAccumulated,this.amountAwarded,this.nrOfWinners,this.jackPot5Winners});
Jackpot5Info.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
isHit = json['isHit'];
amountAccumulated = JsonConverters.toDouble(json['amountAccumulated']);
amountAwarded = JsonConverters.toDouble(json['amountAwarded']);
nrOfWinners = json['nrOfWinners'];
jackPot5Winners = JsonConverters.fromJson(json['jackPot5Winners'],'List<JackPot5Winner>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'isHit': isHit,
'amountAccumulated': amountAccumulated,
'amountAwarded': amountAwarded,
'nrOfWinners': nrOfWinners,
'jackPot5Winners': JsonConverters.toJson(jackPot5Winners,'List<JackPot5Winner>',context!)
};
getTypeName() => "Jackpot5Info";
TypeContext? context = _ctx;
}
class SuperWinWinner implements IConvertible
{
bool? isDrawn;
DateTime? drawnAtUtc;
String? roundId;
String? betId;
String? slipId;
Origin? origin;
Ref? bettor;
String? code;
double? amount;
String? locationAddressOrBettorInfo;
SuperWinWinner({this.isDrawn,this.drawnAtUtc,this.roundId,this.betId,this.slipId,this.origin,this.bettor,this.code,this.amount,this.locationAddressOrBettorInfo});
SuperWinWinner.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
isDrawn = json['isDrawn'];
drawnAtUtc = JsonConverters.fromJson(json['drawnAtUtc'],'DateTime',context!);
roundId = json['roundId'];
betId = json['betId'];
slipId = json['slipId'];
origin = JsonConverters.fromJson(json['origin'],'Origin',context!);
bettor = JsonConverters.fromJson(json['bettor'],'Ref',context!);
code = json['code'];
amount = JsonConverters.toDouble(json['amount']);
locationAddressOrBettorInfo = json['locationAddressOrBettorInfo'];
return this;
}
Map<String, dynamic> toJson() => {
'isDrawn': isDrawn,
'drawnAtUtc': JsonConverters.toJson(drawnAtUtc,'DateTime',context!),
'roundId': roundId,
'betId': betId,
'slipId': slipId,
'origin': JsonConverters.toJson(origin,'Origin',context!),
'bettor': JsonConverters.toJson(bettor,'Ref',context!),
'code': code,
'amount': amount,
'locationAddressOrBettorInfo': locationAddressOrBettorInfo
};
getTypeName() => "SuperWinWinner";
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 WinnerByCode implements IConvertible
{
String? roundId;
DateTime? drawnAtUtc;
String? slipId;
String? betId;
String? code;
double? amount;
Origin? origin;
Ref? bettor;
String? locationAddressOrBettorInfo;
WinnerByCode({this.roundId,this.drawnAtUtc,this.slipId,this.betId,this.code,this.amount,this.origin,this.bettor,this.locationAddressOrBettorInfo});
WinnerByCode.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
roundId = json['roundId'];
drawnAtUtc = JsonConverters.fromJson(json['drawnAtUtc'],'DateTime',context!);
slipId = json['slipId'];
betId = json['betId'];
code = json['code'];
amount = JsonConverters.toDouble(json['amount']);
origin = JsonConverters.fromJson(json['origin'],'Origin',context!);
bettor = JsonConverters.fromJson(json['bettor'],'Ref',context!);
locationAddressOrBettorInfo = json['locationAddressOrBettorInfo'];
return this;
}
Map<String, dynamic> toJson() => {
'roundId': roundId,
'drawnAtUtc': JsonConverters.toJson(drawnAtUtc,'DateTime',context!),
'slipId': slipId,
'betId': betId,
'code': code,
'amount': amount,
'origin': JsonConverters.toJson(origin,'Origin',context!),
'bettor': JsonConverters.toJson(bettor,'Ref',context!),
'locationAddressOrBettorInfo': locationAddressOrBettorInfo
};
getTypeName() => "WinnerByCode";
TypeContext? context = _ctx;
}
class GlobalCodePotInfo implements IConvertible
{
bool? isActive;
bool? isDrawn;
WinnerByCode? winner;
String? inertCode;
double? accumulation;
GlobalCodePotInfo({this.isActive,this.isDrawn,this.winner,this.inertCode,this.accumulation});
GlobalCodePotInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
isActive = json['isActive'];
isDrawn = json['isDrawn'];
winner = JsonConverters.fromJson(json['winner'],'WinnerByCode',context!);
inertCode = json['inertCode'];
accumulation = JsonConverters.toDouble(json['accumulation']);
return this;
}
Map<String, dynamic> toJson() => {
'isActive': isActive,
'isDrawn': isDrawn,
'winner': JsonConverters.toJson(winner,'WinnerByCode',context!),
'inertCode': inertCode,
'accumulation': accumulation
};
getTypeName() => "GlobalCodePotInfo";
TypeContext? context = _ctx;
}
class Stages
{
static const Stages None = const Stages._(0);
static const Stages Countdown = const Stages._(1);
static const Stages Processing = const Stages._(2);
static const Stages Draw = const Stages._(3);
static const Stages Results = const Stages._(4);
final int _value;
const Stages._(this._value);
int get value => _value;
static List<Stages> get values => const [None,Countdown,Processing,Draw,Results];
}
class RoundProgress implements IConvertible
{
Stages? stage;
int? step;
int? steps;
DateTime? utcTimestamp;
RoundProgress({this.stage,this.step,this.steps,this.utcTimestamp});
RoundProgress.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
stage = JsonConverters.fromJson(json['stage'],'Stages',context!);
step = json['step'];
steps = json['steps'];
utcTimestamp = JsonConverters.fromJson(json['utcTimestamp'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'stage': JsonConverters.toJson(stage,'Stages',context!),
'step': step,
'steps': steps,
'utcTimestamp': JsonConverters.toJson(utcTimestamp,'DateTime',context!)
};
getTypeName() => "RoundProgress";
TypeContext? context = _ctx;
}
class Round implements IConvertible
{
String? id;
DateTime? createdAt;
DateTime? updatedAt;
DateTime? shouldStartAtUtc;
DateTime? startedAtUtc;
RoundStatus? status;
RoundConfiguration? configuration;
String? sequence;
Jackpot5Info? jackpot5Info;
SuperWinInfo? superWinInfo;
GlobalCodePotInfo? globalCodePotInfo;
RoundProgress? progress;
bool? isLocked;
bool? isCalculated;
Round({this.id,this.createdAt,this.updatedAt,this.shouldStartAtUtc,this.startedAtUtc,this.status,this.configuration,this.sequence,this.jackpot5Info,this.superWinInfo,this.globalCodePotInfo,this.progress,this.isLocked,this.isCalculated});
Round.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
id = json['id'];
createdAt = JsonConverters.fromJson(json['createdAt'],'DateTime',context!);
updatedAt = JsonConverters.fromJson(json['updatedAt'],'DateTime',context!);
shouldStartAtUtc = JsonConverters.fromJson(json['shouldStartAtUtc'],'DateTime',context!);
startedAtUtc = JsonConverters.fromJson(json['startedAtUtc'],'DateTime',context!);
status = JsonConverters.fromJson(json['status'],'RoundStatus',context!);
configuration = JsonConverters.fromJson(json['configuration'],'RoundConfiguration',context!);
sequence = json['sequence'];
jackpot5Info = JsonConverters.fromJson(json['jackpot5Info'],'Jackpot5Info',context!);
superWinInfo = JsonConverters.fromJson(json['superWinInfo'],'SuperWinInfo',context!);
globalCodePotInfo = JsonConverters.fromJson(json['globalCodePotInfo'],'GlobalCodePotInfo',context!);
progress = JsonConverters.fromJson(json['progress'],'RoundProgress',context!);
isLocked = json['isLocked'];
isCalculated = json['isCalculated'];
return this;
}
Map<String, dynamic> toJson() => {
'id': id,
'createdAt': JsonConverters.toJson(createdAt,'DateTime',context!),
'updatedAt': JsonConverters.toJson(updatedAt,'DateTime',context!),
'shouldStartAtUtc': JsonConverters.toJson(shouldStartAtUtc,'DateTime',context!),
'startedAtUtc': JsonConverters.toJson(startedAtUtc,'DateTime',context!),
'status': JsonConverters.toJson(status,'RoundStatus',context!),
'configuration': JsonConverters.toJson(configuration,'RoundConfiguration',context!),
'sequence': sequence,
'jackpot5Info': JsonConverters.toJson(jackpot5Info,'Jackpot5Info',context!),
'superWinInfo': JsonConverters.toJson(superWinInfo,'SuperWinInfo',context!),
'globalCodePotInfo': JsonConverters.toJson(globalCodePotInfo,'GlobalCodePotInfo',context!),
'progress': JsonConverters.toJson(progress,'RoundProgress',context!),
'isLocked': isLocked,
'isCalculated': isCalculated
};
getTypeName() => "Round";
TypeContext? context = _ctx;
}
class Feed implements IConvertible
{
String? id;
Round? round;
Jackpot5Info? lastJackpot5Info;
SuperWinInfo? superWinInfo;
GlobalCodePotInfo? globalCodePotInfo;
Feed({this.id,this.round,this.lastJackpot5Info,this.superWinInfo,this.globalCodePotInfo});
Feed.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
id = json['id'];
round = JsonConverters.fromJson(json['round'],'Round',context!);
lastJackpot5Info = JsonConverters.fromJson(json['lastJackpot5Info'],'Jackpot5Info',context!);
superWinInfo = JsonConverters.fromJson(json['superWinInfo'],'SuperWinInfo',context!);
globalCodePotInfo = JsonConverters.fromJson(json['globalCodePotInfo'],'GlobalCodePotInfo',context!);
return this;
}
Map<String, dynamic> toJson() => {
'id': id,
'round': JsonConverters.toJson(round,'Round',context!),
'lastJackpot5Info': JsonConverters.toJson(lastJackpot5Info,'Jackpot5Info',context!),
'superWinInfo': JsonConverters.toJson(superWinInfo,'SuperWinInfo',context!),
'globalCodePotInfo': JsonConverters.toJson(globalCodePotInfo,'GlobalCodePotInfo',context!)
};
getTypeName() => "Feed";
TypeContext? context = _ctx;
}
class GetFeed implements IConvertible
{
GetFeed();
GetFeed.fromJson(Map<String, dynamic> json) : super();
fromMap(Map<String, dynamic> json) {
return this;
}
Map<String, dynamic> toJson() => {};
getTypeName() => "GetFeed";
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 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> {
'RoundStatus': TypeInfo(TypeOf.Enum, enumValues:RoundStatus.values),
'CountdownConfiguration': TypeInfo(TypeOf.Class, create:() => CountdownConfiguration()),
'DrawConfiguration': TypeInfo(TypeOf.Class, create:() => DrawConfiguration()),
'RTPStrategies': TypeInfo(TypeOf.Enum, enumValues:RTPStrategies.values),
'HappyHourConfiguration': TypeInfo(TypeOf.Class, create:() => HappyHourConfiguration()),
'RoundConfiguration': TypeInfo(TypeOf.Class, create:() => RoundConfiguration()),
'RecordList<double>': TypeInfo(TypeOf.Class, create:() => RecordList<double>()),
'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()),
'JackPot5Winner': TypeInfo(TypeOf.Class, create:() => JackPot5Winner()),
'Jackpot5Info': TypeInfo(TypeOf.Class, create:() => Jackpot5Info()),
'List<JackPot5Winner>': TypeInfo(TypeOf.Class, create:() => <JackPot5Winner>[]),
'SuperWinWinner': TypeInfo(TypeOf.Class, create:() => SuperWinWinner()),
'SuperWinInfo': TypeInfo(TypeOf.Class, create:() => SuperWinInfo()),
'WinnerByCode': TypeInfo(TypeOf.Class, create:() => WinnerByCode()),
'GlobalCodePotInfo': TypeInfo(TypeOf.Class, create:() => GlobalCodePotInfo()),
'Stages': TypeInfo(TypeOf.Enum, enumValues:Stages.values),
'RoundProgress': TypeInfo(TypeOf.Class, create:() => RoundProgress()),
'Round': TypeInfo(TypeOf.Class, create:() => Round()),
'Feed': TypeInfo(TypeOf.Class, create:() => Feed()),
'GetFeed': TypeInfo(TypeOf.Class, create:() => GetFeed()),
'RecordList<T>': TypeInfo(TypeOf.GenericDef,create:() => RecordList()),
'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/feed HTTP/1.1
Host: s4w2.api.bettor.cc
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length
{
}
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length
{
id: String,
round:
{
id: String,
createdAt: 0001-01-01,
updatedAt: 0001-01-01,
shouldStartAtUtc: 0001-01-01,
startedAtUtc: 0001-01-01,
status: 0,
configuration:
{
coefficients:
[
0
],
isDoubleTripleActive: False,
isJackpot5Active: False,
countdownDurationInSeconds: 0,
countdownConfiguration:
{
lockdownStepFromEnd: 0,
assertLockdownStepFromEnd: 0
},
drawConfiguration:
{
introIntervalInMs: 0,
animationIntervalInMs: 0,
outroIntervalInMs: 0
},
resultsDurationInSeconds: 0,
rtpStrategy: 0,
happyHourConfiguration:
{
isHappyHour: False,
oddsModifier: 0,
roundPoolBonusPct: 0
}
},
sequence: String,
jackpot5Info:
{
isHit: False,
amountAccumulated: 0,
amountAwarded: 0,
nrOfWinners: 0,
jackPot5Winners:
[
{
betId: String,
nrOfCombinations: 0,
winningsAmount: 0,
origin:
{
application:
{
name: String,
version: String
},
ip: String,
organization:
{
data:
{
String: String
},
id: String,
val: String
},
region:
{
id: String,
val: String
},
locationGroup:
{
id: String,
val: String
},
location:
{
data:
{
String: String
},
id: String,
val: String
},
device:
{
data:
{
String: String
},
id: String,
val: String
},
clerk:
{
id: String,
val: String
}
},
bettor:
{
id: String,
val: String
},
payload:
{
String: String
}
}
]
},
superWinInfo:
{
isActive: False,
winner:
{
isDrawn: False,
drawnAtUtc: 0001-01-01,
roundId: String,
betId: String,
slipId: String,
origin:
{
application:
{
name: String,
version: String
},
ip: String,
organization:
{
data:
{
String: String
},
id: String,
val: String
},
region:
{
id: String,
val: String
},
locationGroup:
{
id: String,
val: String
},
location:
{
data:
{
String: String
},
id: String,
val: String
},
device:
{
data:
{
String: String
},
id: String,
val: String
},
clerk:
{
id: String,
val: String
}
},
bettor:
{
id: String,
val: String
},
code: String,
amount: 0,
locationAddressOrBettorInfo: String
},
availableAmount: 0,
allPrizesAwarded: False
},
globalCodePotInfo:
{
isActive: False,
isDrawn: True,
winner:
{
roundId: String,
drawnAtUtc: 0001-01-01,
slipId: String,
betId: String,
code: String,
amount: 0,
origin:
{
application:
{
name: String,
version: String
},
ip: String,
organization:
{
data:
{
String: String
},
id: String,
val: String
},
region:
{
id: String,
val: String
},
locationGroup:
{
id: String,
val: String
},
location:
{
data:
{
String: String
},
id: String,
val: String
},
device:
{
data:
{
String: String
},
id: String,
val: String
},
clerk:
{
id: String,
val: String
}
},
bettor:
{
id: String,
val: String
},
locationAddressOrBettorInfo: String
},
inertCode: String,
accumulation: 0
},
progress:
{
stage: 0,
step: 0,
steps: 0,
utcTimestamp: 0001-01-01
},
isLocked: False,
isCalculated: False
},
lastJackpot5Info:
{
isHit: False,
amountAccumulated: 0,
amountAwarded: 0,
nrOfWinners: 0,
jackPot5Winners:
[
{
betId: String,
nrOfCombinations: 0,
winningsAmount: 0,
origin:
{
application:
{
name: String,
version: String
},
ip: String,
organization:
{
data:
{
String: String
},
id: String,
val: String
},
region:
{
id: String,
val: String
},
locationGroup:
{
id: String,
val: String
},
location:
{
data:
{
String: String
},
id: String,
val: String
},
device:
{
data:
{
String: String
},
id: String,
val: String
},
clerk:
{
id: String,
val: String
}
},
bettor:
{
id: String,
val: String
},
payload:
{
String: String
}
}
]
},
superWinInfo:
{
isActive: False,
winner:
{
isDrawn: False,
drawnAtUtc: 0001-01-01,
roundId: String,
betId: String,
slipId: String,
origin:
{
application:
{
name: String,
version: String
},
ip: String,
organization:
{
data:
{
String: String
},
id: String,
val: String
},
region:
{
id: String,
val: String
},
locationGroup:
{
id: String,
val: String
},
location:
{
data:
{
String: String
},
id: String,
val: String
},
device:
{
data:
{
String: String
},
id: String,
val: String
},
clerk:
{
id: String,
val: String
}
},
bettor:
{
id: String,
val: String
},
code: String,
amount: 0,
locationAddressOrBettorInfo: String
},
availableAmount: 0,
allPrizesAwarded: False
},
globalCodePotInfo:
{
isActive: False,
isDrawn: True,
winner:
{
roundId: String,
drawnAtUtc: 0001-01-01,
slipId: String,
betId: String,
code: String,
amount: 0,
origin:
{
application:
{
name: String,
version: String
},
ip: String,
organization:
{
data:
{
String: String
},
id: String,
val: String
},
region:
{
id: String,
val: String
},
locationGroup:
{
id: String,
val: String
},
location:
{
data:
{
String: String
},
id: String,
val: String
},
device:
{
data:
{
String: String
},
id: String,
val: String
},
clerk:
{
id: String,
val: String
}
},
bettor:
{
id: String,
val: String
},
locationAddressOrBettorInfo: String
},
inertCode: String,
accumulation: 0
}
}