/* Options:
Date: 2025-12-06 06:09:07
Version: 8.70
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.sbbet.ath.cx

//GlobalNamespace: 
//AddServiceStackTypes: True
//AddResponseStatus: False
//AddImplicitVersion: 
//AddDescriptionAsComments: True
IncludeTypes: GetProductInstanceConfiguration.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

class Money implements IConvertible
{
    double? amount;
    String? currency;

    Money({this.amount,this.currency});
    Money.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class PayinConstraintType
{
    static const PayinConstraintType SingleBet = const PayinConstraintType._(0);
    static const PayinConstraintType MultiBet = const PayinConstraintType._(1);
    static const PayinConstraintType SystemBet = const PayinConstraintType._(2);

    final int _value;
    const PayinConstraintType._(this._value);
    int get value => _value;
    static List<PayinConstraintType> get values => const [SingleBet,MultiBet,SystemBet];
}

class PayinConstraint implements IConvertible
{
    PayinConstraintType? type;
    Money? min;
    Money? Default;
    Money? warningThreshold;
    Money? max;

    PayinConstraint({this.type,this.min,this.Default,this.warningThreshold,this.max});
    PayinConstraint.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        type = JsonConverters.fromJson(json['type'],'PayinConstraintType',context!);
        min = JsonConverters.fromJson(json['min'],'Money',context!);
        Default = JsonConverters.fromJson(json['default'],'Money',context!);
        warningThreshold = JsonConverters.fromJson(json['warningThreshold'],'Money',context!);
        max = JsonConverters.fromJson(json['max'],'Money',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'PayinConstraintType',context!),
        'min': JsonConverters.toJson(min,'Money',context!),
        'default': JsonConverters.toJson(Default,'Money',context!),
        'warningThreshold': JsonConverters.toJson(warningThreshold,'Money',context!),
        'max': JsonConverters.toJson(max,'Money',context!)
    };

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

class WinningsCapType
{
    static const WinningsCapType SingleBet = const WinningsCapType._(0);
    static const WinningsCapType MultiBet = const WinningsCapType._(1);
    static const WinningsCapType SystemBet = const WinningsCapType._(2);

    final int _value;
    const WinningsCapType._(this._value);
    int get value => _value;
    static List<WinningsCapType> get values => const [SingleBet,MultiBet,SystemBet];
}

class WinningsCap implements IConvertible
{
    WinningsCapType? type;
    Money? cap;

    WinningsCap({this.type,this.cap});
    WinningsCap.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'type': JsonConverters.toJson(type,'WinningsCapType',context!),
        'cap': JsonConverters.toJson(cap,'Money',context!)
    };

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

class BettingPolicies implements IConvertible
{
    RecordList<PayinConstraint>? payinConstraints;
    String? payinTaxationPolicyId;
    RecordList<WinningsCap>? winningsCaps;
    String? winningsTaxationPolicyId;

    BettingPolicies({this.payinConstraints,this.payinTaxationPolicyId,this.winningsCaps,this.winningsTaxationPolicyId});
    BettingPolicies.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        payinConstraints = JsonConverters.fromJson(json['payinConstraints'],'RecordList<PayinConstraint>',context!);
        payinTaxationPolicyId = json['payinTaxationPolicyId'];
        winningsCaps = JsonConverters.fromJson(json['winningsCaps'],'RecordList<WinningsCap>',context!);
        winningsTaxationPolicyId = json['winningsTaxationPolicyId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'payinConstraints': JsonConverters.toJson(payinConstraints,'RecordList<PayinConstraint>',context!),
        'payinTaxationPolicyId': payinTaxationPolicyId,
        'winningsCaps': JsonConverters.toJson(winningsCaps,'RecordList<WinningsCap>',context!),
        'winningsTaxationPolicyId': winningsTaxationPolicyId
    };

    getTypeName() => "BettingPolicies";
    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 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 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 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 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 ProductInstanceConfiguration implements IConvertible
{
    String? id;
    BettingPolicies? bettingPolicies;
    String? apiUrl;
    Map<String,String?>? settings;

    ProductInstanceConfiguration({this.id,this.bettingPolicies,this.apiUrl,this.settings});
    ProductInstanceConfiguration.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        bettingPolicies = JsonConverters.fromJson(json['bettingPolicies'],'BettingPolicies',context!);
        apiUrl = json['apiUrl'];
        settings = JsonConverters.toStringMap(json['settings']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'bettingPolicies': JsonConverters.toJson(bettingPolicies,'BettingPolicies',context!),
        'apiUrl': apiUrl,
        'settings': settings
    };

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

// @Route("/qry/configurations/productInstances")
class GetProductInstanceConfiguration implements IReturn<ProductInstanceConfiguration>, IConvertible, IPost
{
    String? id;
    Origin? origin;

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

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

    Map<String, dynamic> toJson() => {
        'id': id,
        'origin': JsonConverters.toJson(origin,'Origin',context!)
    };

    createResponse() => ProductInstanceConfiguration();
    getResponseTypeName() => "ProductInstanceConfiguration";
    getTypeName() => "GetProductInstanceConfiguration";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.sbbet.ath.cx', types: <String, TypeInfo> {
    'Money': TypeInfo(TypeOf.Class, create:() => Money()),
    'PayinConstraintType': TypeInfo(TypeOf.Enum, enumValues:PayinConstraintType.values),
    'PayinConstraint': TypeInfo(TypeOf.Class, create:() => PayinConstraint()),
    'WinningsCapType': TypeInfo(TypeOf.Enum, enumValues:WinningsCapType.values),
    'WinningsCap': TypeInfo(TypeOf.Class, create:() => WinningsCap()),
    'BettingPolicies': TypeInfo(TypeOf.Class, create:() => BettingPolicies()),
    'RecordList<PayinConstraint>': TypeInfo(TypeOf.Class, create:() => RecordList<PayinConstraint>()),
    'RecordList<WinningsCap>': TypeInfo(TypeOf.Class, create:() => RecordList<WinningsCap>()),
    'Ref': TypeInfo(TypeOf.Class, create:() => Ref()),
    'RefEx': TypeInfo(TypeOf.Class, create:() => RefEx()),
    'RecordDictionary<String,String>': TypeInfo(TypeOf.Class, create:() => RecordDictionary<String,String>()),
    'RecordDictionary<TKey,TVal>': TypeInfo(TypeOf.GenericDef,create:() => RecordDictionary()),
    'BettingApp': TypeInfo(TypeOf.Class, create:() => BettingApp()),
    'Origin': TypeInfo(TypeOf.Class, create:() => Origin()),
    'RecordList<T>': TypeInfo(TypeOf.GenericDef,create:() => RecordList()),
    'ProductInstanceConfiguration': TypeInfo(TypeOf.Class, create:() => ProductInstanceConfiguration()),
    'GetProductInstanceConfiguration': TypeInfo(TypeOf.Class, create:() => GetProductInstanceConfiguration()),
});