/* Options:
Date: 2025-08-05 02:01:10
Version: 8.0
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://www.asg.com.au/RestApi

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

import 'package:servicestack/servicestack.dart';

class MetricItemDTO implements IConvertible
{
    String? Name;
    String? DisplayName;
    double? Value;
    String? Unit;
    String? DenominatorMetricName;
    String? NominatorMetricName;
    bool? ShowInSelector;

    MetricItemDTO({this.Name,this.DisplayName,this.Value,this.Unit,this.DenominatorMetricName,this.NominatorMetricName,this.ShowInSelector});
    MetricItemDTO.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        DisplayName = json['DisplayName'];
        Value = JsonConverters.toDouble(json['Value']);
        Unit = json['Unit'];
        DenominatorMetricName = json['DenominatorMetricName'];
        NominatorMetricName = json['NominatorMetricName'];
        ShowInSelector = json['ShowInSelector'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'DisplayName': DisplayName,
        'Value': Value,
        'Unit': Unit,
        'DenominatorMetricName': DenominatorMetricName,
        'NominatorMetricName': NominatorMetricName,
        'ShowInSelector': ShowInSelector
    };

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

enum Dimension
{
    Browser,
    BrowserVersion,
    City,
    Continent,
    VisitCount,
    Country,
    Date,
    Day,
    DaysSinceLastSession,
    FlashVersion,
    Hostname,
    Hour,
    DeviceCategory,
    JavaEnabled,
    Language,
    Latitude,
    Longitude,
    Month,
    NetworkDomain,
    NetworkLocation,
    PageDepth,
    OperatingSystem,
    OperatingSystemVersion,
    Region,
    ScreenColors,
    ScreenResolution,
    SubContinent,
    UserDefinedValue,
    UserType,
    Week,
    Year,
    AdContent,
    AdGroup,
    AdSlot,
    Campaign,
    Keyword,
    Medium,
    ReferralPath,
    Source,
    ExitPagePath,
    LandingPagePath,
    PagePath,
    PageTitle,
    Affiliation,
    DaysToTransaction,
    ProductCategory,
    ProductName,
    ProductSku,
    TransactionId,
    SearchCategory,
    SearchDestinationPage,
    SearchKeyword,
    SearchKeywordRefinement,
    SearchStartPage,
    SearchUsed,
    EventCategory,
    EventAction,
    EventLabel,
}

// @DataContract
class DimensionItem implements IConvertible
{
    // @DataMember
    String? Value;

    // @DataMember
    String? Name;

    DimensionItem({this.Value,this.Name});
    DimensionItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class SingleSerie implements IConvertible
{
    MetricItemDTO? MainMetric;
    String? CategoryFormat;
    bool? Batch;
    bool? IsCategory;
    String? SeriesName;
    List<DimensionItem>? SeriesDimensions;
    String? RelatedDimension;

    SingleSerie({this.MainMetric,this.CategoryFormat,this.Batch,this.IsCategory,this.SeriesName,this.SeriesDimensions,this.RelatedDimension});
    SingleSerie.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MainMetric = JsonConverters.fromJson(json['MainMetric'],'MetricItemDTO',context!);
        CategoryFormat = json['CategoryFormat'];
        Batch = json['Batch'];
        IsCategory = json['IsCategory'];
        SeriesName = json['SeriesName'];
        SeriesDimensions = JsonConverters.fromJson(json['SeriesDimensions'],'List<DimensionItem>',context!);
        RelatedDimension = json['RelatedDimension'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MainMetric': JsonConverters.toJson(MainMetric,'MetricItemDTO',context!),
        'CategoryFormat': CategoryFormat,
        'Batch': Batch,
        'IsCategory': IsCategory,
        'SeriesName': SeriesName,
        'SeriesDimensions': JsonConverters.toJson(SeriesDimensions,'List<DimensionItem>',context!),
        'RelatedDimension': RelatedDimension
    };

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

class DashBoardControl implements IConvertible
{
    String? ControlType;
    Map<String,String?>? attributes;
    String? PlaceholderId;
    String? DisplayName;
    List<SingleSerie>? Series;
    String? DimensionName;
    List<String>? RelatedDimension;
    String? SortbyField;
    bool? SortAsc;

    DashBoardControl({this.ControlType,this.attributes,this.PlaceholderId,this.DisplayName,this.Series,this.DimensionName,this.RelatedDimension,this.SortbyField,this.SortAsc});
    DashBoardControl.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ControlType = json['ControlType'];
        attributes = JsonConverters.toStringMap(json['attributes']);
        PlaceholderId = json['PlaceholderId'];
        DisplayName = json['DisplayName'];
        Series = JsonConverters.fromJson(json['Series'],'List<SingleSerie>',context!);
        DimensionName = json['DimensionName'];
        RelatedDimension = JsonConverters.fromJson(json['RelatedDimension'],'List<String>',context!);
        SortbyField = json['SortbyField'];
        SortAsc = json['SortAsc'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ControlType': ControlType,
        'attributes': attributes,
        'PlaceholderId': PlaceholderId,
        'DisplayName': DisplayName,
        'Series': JsonConverters.toJson(Series,'List<SingleSerie>',context!),
        'DimensionName': DimensionName,
        'RelatedDimension': JsonConverters.toJson(RelatedDimension,'List<String>',context!),
        'SortbyField': SortbyField,
        'SortAsc': SortAsc
    };

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

class KendoItem implements IConvertible
{
    String? category;
    Map<String,double?>? values;
    String? group;
    String? tooltip;
    Map<String,String?>? Dimensions;

    KendoItem({this.category,this.values,this.group,this.tooltip,this.Dimensions});
    KendoItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        category = json['category'];
        values = JsonConverters.fromJson(json['values'],'Map<String,double?>',context!);
        group = json['group'];
        tooltip = json['tooltip'];
        Dimensions = JsonConverters.toStringMap(json['Dimensions']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'category': category,
        'values': JsonConverters.toJson(values,'Map<String,double?>',context!),
        'group': group,
        'tooltip': tooltip,
        'Dimensions': Dimensions
    };

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

class GetDashboardData implements IConvertible
{
    List<DashBoardControl>? Controls;
    String? LayoutTemplateName;
    String? GroupBy;
    List<MetricItemDTO>? MetricNames;
    String? ErrorMessage;
    bool? NeedsGrouping;
    bool? IsDrillDown;
    List<KendoItem>? DateItems;
    List<KendoItem>? NonDateItems;
    KendoItem? TotalsItem;
    List<String>? MapDataTable;
    bool? IsMapRequest;
    Map<String,List<String>?>? SeriesSources;
    int? StatusCode;
    bool? SuppressMultipleSeries;

    GetDashboardData({this.Controls,this.LayoutTemplateName,this.GroupBy,this.MetricNames,this.ErrorMessage,this.NeedsGrouping,this.IsDrillDown,this.DateItems,this.NonDateItems,this.TotalsItem,this.MapDataTable,this.IsMapRequest,this.SeriesSources,this.StatusCode,this.SuppressMultipleSeries});
    GetDashboardData.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Controls = JsonConverters.fromJson(json['Controls'],'List<DashBoardControl>',context!);
        LayoutTemplateName = json['LayoutTemplateName'];
        GroupBy = json['GroupBy'];
        MetricNames = JsonConverters.fromJson(json['MetricNames'],'List<MetricItemDTO>',context!);
        ErrorMessage = json['ErrorMessage'];
        NeedsGrouping = json['NeedsGrouping'];
        IsDrillDown = json['IsDrillDown'];
        DateItems = JsonConverters.fromJson(json['DateItems'],'List<KendoItem>',context!);
        NonDateItems = JsonConverters.fromJson(json['NonDateItems'],'List<KendoItem>',context!);
        TotalsItem = JsonConverters.fromJson(json['TotalsItem'],'KendoItem',context!);
        MapDataTable = JsonConverters.fromJson(json['MapDataTable'],'List<String>',context!);
        IsMapRequest = json['IsMapRequest'];
        SeriesSources = JsonConverters.fromJson(json['SeriesSources'],'Map<String,List<String>?>',context!);
        StatusCode = json['StatusCode'];
        SuppressMultipleSeries = json['SuppressMultipleSeries'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Controls': JsonConverters.toJson(Controls,'List<DashBoardControl>',context!),
        'LayoutTemplateName': LayoutTemplateName,
        'GroupBy': GroupBy,
        'MetricNames': JsonConverters.toJson(MetricNames,'List<MetricItemDTO>',context!),
        'ErrorMessage': ErrorMessage,
        'NeedsGrouping': NeedsGrouping,
        'IsDrillDown': IsDrillDown,
        'DateItems': JsonConverters.toJson(DateItems,'List<KendoItem>',context!),
        'NonDateItems': JsonConverters.toJson(NonDateItems,'List<KendoItem>',context!),
        'TotalsItem': JsonConverters.toJson(TotalsItem,'KendoItem',context!),
        'MapDataTable': JsonConverters.toJson(MapDataTable,'List<String>',context!),
        'IsMapRequest': IsMapRequest,
        'SeriesSources': JsonConverters.toJson(SeriesSources,'Map<String,List<String>?>',context!),
        'StatusCode': StatusCode,
        'SuppressMultipleSeries': SuppressMultipleSeries
    };

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

// @Route("/Sitefinity/Analytics/GetMapData")
// @Route("/GetMapData")
class MapDataRequest implements IReturn<GetDashboardData>, IConvertible, IPost
{
    String? DashboardId;
    String? RelatedDashboardId;
    List<MetricItemDTO>? Metrics;
    String? Filter;
    Dimension? Dimension;
    String? jsStartDate;
    String? jsEndDate;
    String? SelectedMetric;
    String? Region;
    String? SiteId;
    DateTime? StartDate;
    DateTime? EndDate;

    MapDataRequest({this.DashboardId,this.RelatedDashboardId,this.Metrics,this.Filter,this.Dimension,this.jsStartDate,this.jsEndDate,this.SelectedMetric,this.Region,this.SiteId,this.StartDate,this.EndDate});
    MapDataRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        DashboardId = json['DashboardId'];
        RelatedDashboardId = json['RelatedDashboardId'];
        Metrics = JsonConverters.fromJson(json['Metrics'],'List<MetricItemDTO>',context!);
        Filter = json['Filter'];
        Dimension = JsonConverters.fromJson(json['Dimension'],'Dimension',context!);
        jsStartDate = json['jsStartDate'];
        jsEndDate = json['jsEndDate'];
        SelectedMetric = json['SelectedMetric'];
        Region = json['Region'];
        SiteId = json['SiteId'];
        StartDate = JsonConverters.fromJson(json['StartDate'],'DateTime',context!);
        EndDate = JsonConverters.fromJson(json['EndDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'DashboardId': DashboardId,
        'RelatedDashboardId': RelatedDashboardId,
        'Metrics': JsonConverters.toJson(Metrics,'List<MetricItemDTO>',context!),
        'Filter': Filter,
        'Dimension': JsonConverters.toJson(Dimension,'Dimension',context!),
        'jsStartDate': jsStartDate,
        'jsEndDate': jsEndDate,
        'SelectedMetric': SelectedMetric,
        'Region': Region,
        'SiteId': SiteId,
        'StartDate': JsonConverters.toJson(StartDate,'DateTime',context!),
        'EndDate': JsonConverters.toJson(EndDate,'DateTime',context!)
    };

    createResponse() => GetDashboardData();
    getResponseTypeName() => "GetDashboardData";
    getTypeName() => "MapDataRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'www.asg.com.au', types: <String, TypeInfo> {
    'MetricItemDTO': TypeInfo(TypeOf.Class, create:() => MetricItemDTO()),
    'Dimension': TypeInfo(TypeOf.Enum, enumValues:Dimension.values),
    'DimensionItem': TypeInfo(TypeOf.Class, create:() => DimensionItem()),
    'SingleSerie': TypeInfo(TypeOf.Class, create:() => SingleSerie()),
    'List<DimensionItem>': TypeInfo(TypeOf.Class, create:() => <DimensionItem>[]),
    'DashBoardControl': TypeInfo(TypeOf.Class, create:() => DashBoardControl()),
    'List<SingleSerie>': TypeInfo(TypeOf.Class, create:() => <SingleSerie>[]),
    'KendoItem': TypeInfo(TypeOf.Class, create:() => KendoItem()),
    'Map<String,double?>': TypeInfo(TypeOf.Class, create:() => Map<String,double?>()),
    'GetDashboardData': TypeInfo(TypeOf.Class, create:() => GetDashboardData()),
    'List<DashBoardControl>': TypeInfo(TypeOf.Class, create:() => <DashBoardControl>[]),
    'List<MetricItemDTO>': TypeInfo(TypeOf.Class, create:() => <MetricItemDTO>[]),
    'List<KendoItem>': TypeInfo(TypeOf.Class, create:() => <KendoItem>[]),
    'Map<String,List<String>?>': TypeInfo(TypeOf.Class, create:() => Map<String,List<String>?>()),
    'MapDataRequest': TypeInfo(TypeOf.Class, create:() => MapDataRequest()),
});