/* Options:
Date: 2025-12-06 04:53:19
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.prod-mnta.webhop.biz

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

import 'package:servicestack/servicestack.dart';

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 BetSource
{
    static const BetSource Landbase = const BetSource._(0);
    static const BetSource Web = const BetSource._(1);

    final int _value;
    const BetSource._(this._value);
    int get value => _value;
    static List<BetSource> get values => const [Landbase,Web];
}

class TransactionDtoBase implements IConvertible
{
    String? transaction_id;
    DateTime? transaction_time;
    double? transaction_amount;
    String? game_name;
    String? betting_place_id;
    String? betting_terminal_id;
    String? jmbg;
    String? passport_number;
    BetSource? source;
    String? identification_document_country;
    String? identification_document_type;

    TransactionDtoBase({this.transaction_id,this.transaction_time,this.transaction_amount,this.game_name,this.betting_place_id,this.betting_terminal_id,this.jmbg,this.passport_number,this.source,this.identification_document_country,this.identification_document_type});
    TransactionDtoBase.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        transaction_id = json['transaction_id'];
        transaction_time = JsonConverters.fromJson(json['transaction_time'],'DateTime',context!);
        transaction_amount = JsonConverters.toDouble(json['transaction_amount']);
        game_name = json['game_name'];
        betting_place_id = json['betting_place_id'];
        betting_terminal_id = json['betting_terminal_id'];
        jmbg = json['jmbg'];
        passport_number = json['passport_number'];
        source = JsonConverters.fromJson(json['source'],'BetSource',context!);
        identification_document_country = json['identification_document_country'];
        identification_document_type = json['identification_document_type'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'transaction_id': transaction_id,
        'transaction_time': JsonConverters.toJson(transaction_time,'DateTime',context!),
        'transaction_amount': transaction_amount,
        'game_name': game_name,
        'betting_place_id': betting_place_id,
        'betting_terminal_id': betting_terminal_id,
        'jmbg': jmbg,
        'passport_number': passport_number,
        'source': JsonConverters.toJson(source,'BetSource',context!),
        'identification_document_country': identification_document_country,
        'identification_document_type': identification_document_type
    };

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

class RollbackTransactionType
{
    static const RollbackTransactionType Bet = const RollbackTransactionType._(0);
    static const RollbackTransactionType Win = const RollbackTransactionType._(1);
    static const RollbackTransactionType Jackpot = const RollbackTransactionType._(1);

    final int _value;
    const RollbackTransactionType._(this._value);
    int get value => _value;
    static List<RollbackTransactionType> get values => const [Bet,Win,Jackpot];
}

class RollbackDto extends TransactionDtoBase implements IConvertible
{
    String? rollback_transaction_id;
    String? ticket_id;
    RollbackTransactionType? rollback_transaction_type;

    RollbackDto({this.rollback_transaction_id,this.ticket_id,this.rollback_transaction_type});
    RollbackDto.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        rollback_transaction_id = json['rollback_transaction_id'];
        ticket_id = json['ticket_id'];
        rollback_transaction_type = JsonConverters.fromJson(json['rollback_transaction_type'],'RollbackTransactionType',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'rollback_transaction_id': rollback_transaction_id,
        'ticket_id': ticket_id,
        'rollback_transaction_type': JsonConverters.toJson(rollback_transaction_type,'RollbackTransactionType',context!)
    });

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

// @Route("/bets/cancel", "POST")
class ReportBetCancellations implements IReturn<ResponseStatus>, IConvertible, IPost
{
    RecordList<RollbackDto>? betCancellations;

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

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

    Map<String, dynamic> toJson() => {
        'betCancellations': JsonConverters.toJson(betCancellations,'RecordList<RollbackDto>',context!)
    };

    createResponse() => ResponseStatus();
    getResponseTypeName() => "ResponseStatus";
    getTypeName() => "ReportBetCancellations";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.prod_mnta.webhop.biz', types: <String, TypeInfo> {
    'RecordList<T>': TypeInfo(TypeOf.GenericDef,create:() => RecordList()),
    'BetSource': TypeInfo(TypeOf.Enum, enumValues:BetSource.values),
    'TransactionDtoBase': TypeInfo(TypeOf.Class, create:() => TransactionDtoBase()),
    'RollbackTransactionType': TypeInfo(TypeOf.Enum, enumValues:RollbackTransactionType.values),
    'RollbackDto': TypeInfo(TypeOf.Class, create:() => RollbackDto()),
    'ReportBetCancellations': TypeInfo(TypeOf.Class, create:() => ReportBetCancellations()),
    'RecordList<RollbackDto>': TypeInfo(TypeOf.Class, create:() => RecordList<RollbackDto>()),
});