/* Options:
Date: 2025-12-06 05:26:09
Version: 8.60
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://geniuslink-api-zane.dev.platform.georiot.com

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

import 'package:servicestack/servicestack.dart';

enum GroupBy
{
    Default,
    Retailer,
    Date,
}

enum ReportType
{
    ShortUrl,
    Group,
    User,
}

// @DataContract
class ReportRequest implements IConvertible
{
    // @DataMember(Name="items")
    List<String>? items;

    // @DataMember(Name="groupBy")
    List<GroupBy>? groupBy;

    // @DataMember(Name="attribute")
    String? attribute;

    // @DataMember(Name="type")
    ReportType? type;

    // @DataMember(Name="fromStartUtcInclusive")
    DateTime? fromStartUtcInclusive;

    // @DataMember(Name="fromEndUtcInclusive")
    DateTime? fromEndUtcInclusive;

    // @DataMember(Name="retailers")
    List<String>? retailers;

    ReportRequest({this.items,this.groupBy,this.attribute,this.type,this.fromStartUtcInclusive,this.fromEndUtcInclusive,this.retailers});
    ReportRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        items = JsonConverters.fromJson(json['items'],'List<String>',context!);
        groupBy = JsonConverters.fromJson(json['groupBy'],'List<GroupBy>',context!);
        attribute = json['attribute'];
        type = JsonConverters.fromJson(json['type'],'ReportType',context!);
        fromStartUtcInclusive = JsonConverters.fromJson(json['fromStartUtcInclusive'],'DateTime',context!);
        fromEndUtcInclusive = JsonConverters.fromJson(json['fromEndUtcInclusive'],'DateTime',context!);
        retailers = JsonConverters.fromJson(json['retailers'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'items': JsonConverters.toJson(items,'List<String>',context!),
        'groupBy': JsonConverters.toJson(groupBy,'List<GroupBy>',context!),
        'attribute': attribute,
        'type': JsonConverters.toJson(type,'ReportType',context!),
        'fromStartUtcInclusive': JsonConverters.toJson(fromStartUtcInclusive,'DateTime',context!),
        'fromEndUtcInclusive': JsonConverters.toJson(fromEndUtcInclusive,'DateTime',context!),
        'retailers': JsonConverters.toJson(retailers,'List<String>',context!)
    };

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

// @DataContract
class Item implements IConvertible
{
    // @DataMember(Name="id")
    String? id;

    // @DataMember(Name="displayName")
    String? displayName;

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

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

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

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

// @DataContract
class ReportData implements IConvertible
{
    // @DataMember(Name="id")
    String? id;

    // @DataMember(Name="item")
    Item? item;

    // @DataMember(Name="totalClicks")
    int? totalClicks;

    // @DataMember(Name="clicks")
    int? clicks;

    // @DataMember(Name="junkClicks")
    int? junkClicks;

    // @DataMember(Name="spiderClicks")
    int? spiderClicks;

    // @DataMember(Name="dateUtc")
    DateTime? dateUtc;

    ReportData({this.id,this.item,this.totalClicks,this.clicks,this.junkClicks,this.spiderClicks,this.dateUtc});
    ReportData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        item = JsonConverters.fromJson(json['item'],'Item',context!);
        totalClicks = json['totalClicks'];
        clicks = json['actualClicks'];
        junkClicks = json['junkClicks'];
        spiderClicks = json['spiderClicks'];
        dateUtc = JsonConverters.fromJson(json['dateUtc'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'item': JsonConverters.toJson(item,'Item',context!),
        'totalClicks': totalClicks,
        'clicks': clicks,
        'junkClicks': junkClicks,
        'spiderClicks': spiderClicks,
        'dateUtc': JsonConverters.toJson(dateUtc,'DateTime',context!)
    };

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

// @DataContract
class Error implements IConvertible
{
    // @DataMember(Name="code")
    String? code;

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

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

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

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

// @DataContract
class Report implements IConvertible
{
    // @DataMember(Name="data")
    List<ReportData>? data;

    // @DataMember(Name="executionTimeMs")
    int? executionTimeMs;

    // @DataMember(Name="totalItems")
    int? totalItems;

    // @DataMember(Name="errors")
    List<Error>? errors;

    // @DataMember(Name="request")
    ReportRequest? request;

    // @DataMember(Name="totalClicks")
    int? totalClicks;

    Report({this.data,this.executionTimeMs,this.totalItems,this.errors,this.request,this.totalClicks});
    Report.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        data = JsonConverters.fromJson(json['data'],'List<ReportData>',context!);
        executionTimeMs = json['executionTimeMs'];
        totalItems = json['totalItems'];
        errors = JsonConverters.fromJson(json['errors'],'List<Error>',context!);
        request = JsonConverters.fromJson(json['request'],'ReportRequest',context!);
        totalClicks = json['totalClicks'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'data': JsonConverters.toJson(data,'List<ReportData>',context!),
        'executionTimeMs': executionTimeMs,
        'totalItems': totalItems,
        'errors': JsonConverters.toJson(errors,'List<Error>',context!),
        'request': JsonConverters.toJson(request,'ReportRequest',context!),
        'totalClicks': totalClicks
    };

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

// @DataContract
class PostLinkReportResponse implements IConvertible
{
    // @DataMember(Name="responseStatus")
    ResponseStatus? responseStatus;

    // @DataMember(Name="reports")
    List<Report>? reports;

    PostLinkReportResponse({this.responseStatus,this.reports});
    PostLinkReportResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
        reports = JsonConverters.fromJson(json['reports'],'List<Report>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!),
        'reports': JsonConverters.toJson(reports,'List<Report>',context!)
    };

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

// @Route("/v4/report/links", "POST")
// @Route("/v3.5/report/links", "POST")
// @DataContract
class PostLinkReportRequest implements IReturn<PostLinkReportResponse>, IConvertible, IPost
{
    // @DataMember(Name="reports")
    List<ReportRequest>? reports;

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

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

    Map<String, dynamic> toJson() => {
        'reports': JsonConverters.toJson(reports,'List<ReportRequest>',context!)
    };

    createResponse() => PostLinkReportResponse();
    getResponseTypeName() => "PostLinkReportResponse";
    getTypeName() => "PostLinkReportRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'geniuslink_api_zane.dev.platform.georiot.com', types: <String, TypeInfo> {
    'GroupBy': TypeInfo(TypeOf.Enum, enumValues:GroupBy.values),
    'ReportType': TypeInfo(TypeOf.Enum, enumValues:ReportType.values),
    'ReportRequest': TypeInfo(TypeOf.Class, create:() => ReportRequest()),
    'List<GroupBy>': TypeInfo(TypeOf.Class, create:() => <GroupBy>[]),
    'Item': TypeInfo(TypeOf.Class, create:() => Item()),
    'ReportData': TypeInfo(TypeOf.Class, create:() => ReportData()),
    'Error': TypeInfo(TypeOf.Class, create:() => Error()),
    'Report': TypeInfo(TypeOf.Class, create:() => Report()),
    'List<ReportData>': TypeInfo(TypeOf.Class, create:() => <ReportData>[]),
    'List<Error>': TypeInfo(TypeOf.Class, create:() => <Error>[]),
    'PostLinkReportResponse': TypeInfo(TypeOf.Class, create:() => PostLinkReportResponse()),
    'List<Report>': TypeInfo(TypeOf.Class, create:() => <Report>[]),
    'PostLinkReportRequest': TypeInfo(TypeOf.Class, create:() => PostLinkReportRequest()),
    'List<ReportRequest>': TypeInfo(TypeOf.Class, create:() => <ReportRequest>[]),
});