/* Options:
Date: 2026-07-08 20:42:57
Version: 8.80
Tip: To override a DTO option, remove "//" prefix before updating
BaseUrl: https://api.dev.dynamics.trendsic.com

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

import 'package:servicestack/servicestack.dart';

class ExecKpi implements IConvertible
{
    String? Key;
    String? Label;
    String? Value;
    String? Sub_;
    String? Delta;
    bool? DeltaUp;
    bool? HasDelta;
    bool? Good;

    ExecKpi({this.Key,this.Label,this.Value,this.Sub_,this.Delta,this.DeltaUp,this.HasDelta,this.Good});
    ExecKpi.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Key = json['Key'];
        Label = json['Label'];
        Value = json['Value'];
        Sub_ = json['Sub_'];
        Delta = json['Delta'];
        DeltaUp = json['DeltaUp'];
        HasDelta = json['HasDelta'];
        Good = json['Good'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Key': Key,
        'Label': Label,
        'Value': Value,
        'Sub_': Sub_,
        'Delta': Delta,
        'DeltaUp': DeltaUp,
        'HasDelta': HasDelta,
        'Good': Good
    };

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

class ExecCostCategory implements IConvertible
{
    String? Name;
    double? CostUSD;
    double? BilledUSD;

    ExecCostCategory({this.Name,this.CostUSD,this.BilledUSD});
    ExecCostCategory.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class ExecMonthPoint implements IConvertible
{
    String? Month;
    double? RevenueUSD;
    double? CostUSD;

    ExecMonthPoint({this.Month,this.RevenueUSD,this.CostUSD});
    ExecMonthPoint.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Month': Month,
        'RevenueUSD': RevenueUSD,
        'CostUSD': CostUSD
    };

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

class ExecBacklogYear implements IConvertible
{
    String? Year;
    double? ValueUSD;

    ExecBacklogYear({this.Year,this.ValueUSD});
    ExecBacklogYear.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class ExecBacklog implements IConvertible
{
    double? TotalUSD;
    double? MonthsAhead;
    double? AwardsYtdUSD;
    double? BurnYtdUSD;
    List<ExecBacklogYear>? ByYear = [];

    ExecBacklog({this.TotalUSD,this.MonthsAhead,this.AwardsYtdUSD,this.BurnYtdUSD,this.ByYear});
    ExecBacklog.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TotalUSD = JsonConverters.toDouble(json['TotalUSD']);
        MonthsAhead = JsonConverters.toDouble(json['MonthsAhead']);
        AwardsYtdUSD = JsonConverters.toDouble(json['AwardsYtdUSD']);
        BurnYtdUSD = JsonConverters.toDouble(json['BurnYtdUSD']);
        ByYear = JsonConverters.fromJson(json['ByYear'],'List<ExecBacklogYear>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TotalUSD': TotalUSD,
        'MonthsAhead': MonthsAhead,
        'AwardsYtdUSD': AwardsYtdUSD,
        'BurnYtdUSD': BurnYtdUSD,
        'ByYear': JsonConverters.toJson(ByYear,'List<ExecBacklogYear>',context!)
    };

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

class ExecWipRow implements IConvertible
{
    int? ContractId;
    String? Name;
    String? Owner;
    double? ValueUSD;
    double? PctComplete;
    double? BilledUSD;
    double? OverUnderUSD;
    double? MarginPct;
    double? FadePts;

    ExecWipRow({this.ContractId,this.Name,this.Owner,this.ValueUSD,this.PctComplete,this.BilledUSD,this.OverUnderUSD,this.MarginPct,this.FadePts});
    ExecWipRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ContractId = json['ContractId'];
        Name = json['Name'];
        Owner = json['Owner'];
        ValueUSD = JsonConverters.toDouble(json['ValueUSD']);
        PctComplete = JsonConverters.toDouble(json['PctComplete']);
        BilledUSD = JsonConverters.toDouble(json['BilledUSD']);
        OverUnderUSD = JsonConverters.toDouble(json['OverUnderUSD']);
        MarginPct = JsonConverters.toDouble(json['MarginPct']);
        FadePts = JsonConverters.toDouble(json['FadePts']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ContractId': ContractId,
        'Name': Name,
        'Owner': Owner,
        'ValueUSD': ValueUSD,
        'PctComplete': PctComplete,
        'BilledUSD': BilledUSD,
        'OverUnderUSD': OverUnderUSD,
        'MarginPct': MarginPct,
        'FadePts': FadePts
    };

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

class ExecPipelineStage implements IConvertible
{
    String? Stage;
    double? ValueUSD;
    int? Count;

    ExecPipelineStage({this.Stage,this.ValueUSD,this.Count});
    ExecPipelineStage.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Stage': Stage,
        'ValueUSD': ValueUSD,
        'Count': Count
    };

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

class ExecAgingBucket implements IConvertible
{
    String? Bucket;
    double? AmountUSD;
    bool? IsRetainage;

    ExecAgingBucket({this.Bucket,this.AmountUSD,this.IsRetainage});
    ExecAgingBucket.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Bucket': Bucket,
        'AmountUSD': AmountUSD,
        'IsRetainage': IsRetainage
    };

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

class ExecSafetyMetric implements IConvertible
{
    String? Label;
    String? Value;
    String? Sub_;
    bool? Good;

    ExecSafetyMetric({this.Label,this.Value,this.Sub_,this.Good});
    ExecSafetyMetric.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

class ExecutiveDashboard implements IConvertible
{
    String? Period;
    DateTime? FromDate;
    DateTime? ToDate;
    int? Fy;
    List<ExecKpi>? Kpis = [];
    List<ExecCostCategory>? CostVsBilling = [];
    List<ExecMonthPoint>? Monthly = [];
    ExecBacklog? Backlog;
    List<ExecWipRow>? Wip = [];
    List<ExecPipelineStage>? Pipeline = [];
    double? WinRatePct;
    List<ExecAgingBucket>? Receivables = [];
    double? RetainageUSD;
    int? DsoDays;
    List<ExecSafetyMetric>? Safety = [];

    ExecutiveDashboard({this.Period,this.FromDate,this.ToDate,this.Fy,this.Kpis,this.CostVsBilling,this.Monthly,this.Backlog,this.Wip,this.Pipeline,this.WinRatePct,this.Receivables,this.RetainageUSD,this.DsoDays,this.Safety});
    ExecutiveDashboard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Period = json['Period'];
        FromDate = JsonConverters.fromJson(json['FromDate'],'DateTime',context!);
        ToDate = JsonConverters.fromJson(json['ToDate'],'DateTime',context!);
        Fy = json['Fy'];
        Kpis = JsonConverters.fromJson(json['Kpis'],'List<ExecKpi>',context!);
        CostVsBilling = JsonConverters.fromJson(json['CostVsBilling'],'List<ExecCostCategory>',context!);
        Monthly = JsonConverters.fromJson(json['Monthly'],'List<ExecMonthPoint>',context!);
        Backlog = JsonConverters.fromJson(json['Backlog'],'ExecBacklog',context!);
        Wip = JsonConverters.fromJson(json['Wip'],'List<ExecWipRow>',context!);
        Pipeline = JsonConverters.fromJson(json['Pipeline'],'List<ExecPipelineStage>',context!);
        WinRatePct = JsonConverters.toDouble(json['WinRatePct']);
        Receivables = JsonConverters.fromJson(json['Receivables'],'List<ExecAgingBucket>',context!);
        RetainageUSD = JsonConverters.toDouble(json['RetainageUSD']);
        DsoDays = json['DsoDays'];
        Safety = JsonConverters.fromJson(json['Safety'],'List<ExecSafetyMetric>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Period': Period,
        'FromDate': JsonConverters.toJson(FromDate,'DateTime',context!),
        'ToDate': JsonConverters.toJson(ToDate,'DateTime',context!),
        'Fy': Fy,
        'Kpis': JsonConverters.toJson(Kpis,'List<ExecKpi>',context!),
        'CostVsBilling': JsonConverters.toJson(CostVsBilling,'List<ExecCostCategory>',context!),
        'Monthly': JsonConverters.toJson(Monthly,'List<ExecMonthPoint>',context!),
        'Backlog': JsonConverters.toJson(Backlog,'ExecBacklog',context!),
        'Wip': JsonConverters.toJson(Wip,'List<ExecWipRow>',context!),
        'Pipeline': JsonConverters.toJson(Pipeline,'List<ExecPipelineStage>',context!),
        'WinRatePct': WinRatePct,
        'Receivables': JsonConverters.toJson(Receivables,'List<ExecAgingBucket>',context!),
        'RetainageUSD': RetainageUSD,
        'DsoDays': DsoDays,
        'Safety': JsonConverters.toJson(Safety,'List<ExecSafetyMetric>',context!)
    };

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

class ExecutiveDashboardResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    ExecutiveDashboard? Dashboard;

    ExecutiveDashboardResponse({this.ResponseStatus,this.Dashboard});
    ExecutiveDashboardResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!),
        'Dashboard': JsonConverters.toJson(Dashboard,'ExecutiveDashboard',context!)
    };

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

// @Route("/v1/dashboards/executive", "GET,OPTIONS")
class ExecutiveDashboardRequest implements IReturn<ExecutiveDashboardResponse>, IConvertible, IGet
{
    String? Period;
    String? Region;
    int? Fy;

    ExecutiveDashboardRequest({this.Period,this.Region,this.Fy});
    ExecutiveDashboardRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Period': Period,
        'Region': Region,
        'Fy': Fy
    };

    createResponse() => ExecutiveDashboardResponse();
    getResponseTypeName() => "ExecutiveDashboardResponse";
    getTypeName() => "ExecutiveDashboardRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'ExecKpi': TypeInfo(TypeOf.Class, create:() => ExecKpi()),
    'ExecCostCategory': TypeInfo(TypeOf.Class, create:() => ExecCostCategory()),
    'ExecMonthPoint': TypeInfo(TypeOf.Class, create:() => ExecMonthPoint()),
    'ExecBacklogYear': TypeInfo(TypeOf.Class, create:() => ExecBacklogYear()),
    'ExecBacklog': TypeInfo(TypeOf.Class, create:() => ExecBacklog()),
    'List<ExecBacklogYear>': TypeInfo(TypeOf.Class, create:() => <ExecBacklogYear>[]),
    'ExecWipRow': TypeInfo(TypeOf.Class, create:() => ExecWipRow()),
    'ExecPipelineStage': TypeInfo(TypeOf.Class, create:() => ExecPipelineStage()),
    'ExecAgingBucket': TypeInfo(TypeOf.Class, create:() => ExecAgingBucket()),
    'ExecSafetyMetric': TypeInfo(TypeOf.Class, create:() => ExecSafetyMetric()),
    'ExecutiveDashboard': TypeInfo(TypeOf.Class, create:() => ExecutiveDashboard()),
    'List<ExecKpi>': TypeInfo(TypeOf.Class, create:() => <ExecKpi>[]),
    'List<ExecCostCategory>': TypeInfo(TypeOf.Class, create:() => <ExecCostCategory>[]),
    'List<ExecMonthPoint>': TypeInfo(TypeOf.Class, create:() => <ExecMonthPoint>[]),
    'List<ExecWipRow>': TypeInfo(TypeOf.Class, create:() => <ExecWipRow>[]),
    'List<ExecPipelineStage>': TypeInfo(TypeOf.Class, create:() => <ExecPipelineStage>[]),
    'List<ExecAgingBucket>': TypeInfo(TypeOf.Class, create:() => <ExecAgingBucket>[]),
    'List<ExecSafetyMetric>': TypeInfo(TypeOf.Class, create:() => <ExecSafetyMetric>[]),
    'ExecutiveDashboardResponse': TypeInfo(TypeOf.Class, create:() => ExecutiveDashboardResponse()),
    'ExecutiveDashboardRequest': TypeInfo(TypeOf.Class, create:() => ExecutiveDashboardRequest()),
});