/* Options:
Date: 2026-10-01 10:22:47
Version: 6.10
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://stubbur-app.azurewebsites.net

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

import 'package:servicestack/servicestack.dart';

class OwnerCardTypeSeriesItem implements IConvertible
{
    int? id;
    String? name;
    bool? isActive;
    int? ticketTypeCount;

    OwnerCardTypeSeriesItem({this.id,this.name,this.isActive,this.ticketTypeCount});
    OwnerCardTypeSeriesItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        name = json['name'];
        isActive = json['isActive'];
        ticketTypeCount = json['ticketTypeCount'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
        'isActive': isActive,
        'ticketTypeCount': ticketTypeCount
    };

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

class OwnerCardTypeConnectionsItem implements IConvertible
{
    int? ownerCardTypeId;
    String? name;
    bool? isActive;
    int? activeConnections;
    int? totalConnections;
    bool? entitlesNothing;
    List<OwnerCardTypeSeriesItem>? series;

    OwnerCardTypeConnectionsItem({this.ownerCardTypeId,this.name,this.isActive,this.activeConnections,this.totalConnections,this.entitlesNothing,this.series});
    OwnerCardTypeConnectionsItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ownerCardTypeId = json['ownerCardTypeId'];
        name = json['name'];
        isActive = json['isActive'];
        activeConnections = json['activeConnections'];
        totalConnections = json['totalConnections'];
        entitlesNothing = json['entitlesNothing'];
        series = JsonConverters.fromJson(json['series'],'List<OwnerCardTypeSeriesItem>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ownerCardTypeId': ownerCardTypeId,
        'name': name,
        'isActive': isActive,
        'activeConnections': activeConnections,
        'totalConnections': totalConnections,
        'entitlesNothing': entitlesNothing,
        'series': JsonConverters.toJson(series,'List<OwnerCardTypeSeriesItem>',context!)
    };

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

class UncoveredSeriesItem implements IConvertible
{
    int? seriesId;
    String? name;
    int? upcomingEvents;
    DateTime? nextEventUTC;

    UncoveredSeriesItem({this.seriesId,this.name,this.upcomingEvents,this.nextEventUTC});
    UncoveredSeriesItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        seriesId = json['seriesId'];
        name = json['name'];
        upcomingEvents = json['upcomingEvents'];
        nextEventUTC = JsonConverters.fromJson(json['nextEventUTC'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'seriesId': seriesId,
        'name': name,
        'upcomingEvents': upcomingEvents,
        'nextEventUTC': JsonConverters.toJson(nextEventUTC,'DateTime',context!)
    };

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

class OwnerCardTypeConnectionsResult implements IConvertible
{
    List<OwnerCardTypeConnectionsItem>? items;
    int? entitlesNothingCount;
    List<UncoveredSeriesItem>? seriesWithoutCards;
    int? seriesWithoutCardsCount;
    List<UncoveredSeriesItem>? upcomingSeries;
    int? statusCode;
    String? message;

    OwnerCardTypeConnectionsResult({this.items,this.entitlesNothingCount,this.seriesWithoutCards,this.seriesWithoutCardsCount,this.upcomingSeries,this.statusCode,this.message});
    OwnerCardTypeConnectionsResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        items = JsonConverters.fromJson(json['items'],'List<OwnerCardTypeConnectionsItem>',context!);
        entitlesNothingCount = json['entitlesNothingCount'];
        seriesWithoutCards = JsonConverters.fromJson(json['seriesWithoutCards'],'List<UncoveredSeriesItem>',context!);
        seriesWithoutCardsCount = json['seriesWithoutCardsCount'];
        upcomingSeries = JsonConverters.fromJson(json['upcomingSeries'],'List<UncoveredSeriesItem>',context!);
        statusCode = json['statusCode'];
        message = json['message'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'items': JsonConverters.toJson(items,'List<OwnerCardTypeConnectionsItem>',context!),
        'entitlesNothingCount': entitlesNothingCount,
        'seriesWithoutCards': JsonConverters.toJson(seriesWithoutCards,'List<UncoveredSeriesItem>',context!),
        'seriesWithoutCardsCount': seriesWithoutCardsCount,
        'upcomingSeries': JsonConverters.toJson(upcomingSeries,'List<UncoveredSeriesItem>',context!),
        'statusCode': statusCode,
        'message': message
    };

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

// @Route("/ownerCardTypes/connections/{OwnerId}", "GET")
class OwnerCardTypeConnectionsRequest implements IReturn<OwnerCardTypeConnectionsResult>, IConvertible
{
    int? ownerId;
    bool? includeInactive;

    OwnerCardTypeConnectionsRequest({this.ownerId,this.includeInactive});
    OwnerCardTypeConnectionsRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ownerId = json['ownerId'];
        includeInactive = json['includeInactive'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ownerId': ownerId,
        'includeInactive': includeInactive
    };

    createResponse() => OwnerCardTypeConnectionsResult();
    getResponseTypeName() => "OwnerCardTypeConnectionsResult";
    getTypeName() => "OwnerCardTypeConnectionsRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'stubbur_app.azurewebsites.net', types: <String, TypeInfo> {
    'OwnerCardTypeSeriesItem': TypeInfo(TypeOf.Class, create:() => OwnerCardTypeSeriesItem()),
    'OwnerCardTypeConnectionsItem': TypeInfo(TypeOf.Class, create:() => OwnerCardTypeConnectionsItem()),
    'List<OwnerCardTypeSeriesItem>': TypeInfo(TypeOf.Class, create:() => <OwnerCardTypeSeriesItem>[]),
    'UncoveredSeriesItem': TypeInfo(TypeOf.Class, create:() => UncoveredSeriesItem()),
    'OwnerCardTypeConnectionsResult': TypeInfo(TypeOf.Class, create:() => OwnerCardTypeConnectionsResult()),
    'List<OwnerCardTypeConnectionsItem>': TypeInfo(TypeOf.Class, create:() => <OwnerCardTypeConnectionsItem>[]),
    'List<UncoveredSeriesItem>': TypeInfo(TypeOf.Class, create:() => <UncoveredSeriesItem>[]),
    'OwnerCardTypeConnectionsRequest': TypeInfo(TypeOf.Class, create:() => OwnerCardTypeConnectionsRequest()),
});