/* Options:
Date: 2026-08-01 04:25:46
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: PlanningRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

class OtRow implements IConvertible
{
    int? ContactID;
    String? WorkerName;
    String? ClassCode;
    String? Crew;
    String? Job;
    String? PatternLabel;
    double? ProjHours;
    double? OtHours;
    double? DtHours;
    double? OtCost;
    String? State;
    String? Tone;

    OtRow({this.ContactID,this.WorkerName,this.ClassCode,this.Crew,this.Job,this.PatternLabel,this.ProjHours,this.OtHours,this.DtHours,this.OtCost,this.State,this.Tone});
    OtRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ContactID = json['ContactID'];
        WorkerName = json['WorkerName'];
        ClassCode = json['ClassCode'];
        Crew = json['Crew'];
        Job = json['Job'];
        PatternLabel = json['PatternLabel'];
        ProjHours = JsonConverters.toDouble(json['ProjHours']);
        OtHours = JsonConverters.toDouble(json['OtHours']);
        DtHours = JsonConverters.toDouble(json['DtHours']);
        OtCost = JsonConverters.toDouble(json['OtCost']);
        State = json['State'];
        Tone = json['Tone'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ContactID': ContactID,
        'WorkerName': WorkerName,
        'ClassCode': ClassCode,
        'Crew': Crew,
        'Job': Job,
        'PatternLabel': PatternLabel,
        'ProjHours': ProjHours,
        'OtHours': OtHours,
        'DtHours': DtHours,
        'OtCost': OtCost,
        'State': State,
        'Tone': Tone
    };

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

class OtExposureBoard implements IConvertible
{
    double? TotalOtCost;
    double? TotalOtHours;
    int? OverCount;
    int? WorkerCount;
    List<OtRow>? Rows = [];

    OtExposureBoard({this.TotalOtCost,this.TotalOtHours,this.OverCount,this.WorkerCount,this.Rows});
    OtExposureBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TotalOtCost = JsonConverters.toDouble(json['TotalOtCost']);
        TotalOtHours = JsonConverters.toDouble(json['TotalOtHours']);
        OverCount = json['OverCount'];
        WorkerCount = json['WorkerCount'];
        Rows = JsonConverters.fromJson(json['Rows'],'List<OtRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TotalOtCost': TotalOtCost,
        'TotalOtHours': TotalOtHours,
        'OverCount': OverCount,
        'WorkerCount': WorkerCount,
        'Rows': JsonConverters.toJson(Rows,'List<OtRow>',context!)
    };

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

class PerDiemJobRow implements IConvertible
{
    String? Job;
    double? Total;
    double? NonTax;
    double? Tax;
    int? Days;
    int? AwayCount;
    bool? DayRateFlag;

    PerDiemJobRow({this.Job,this.Total,this.NonTax,this.Tax,this.Days,this.AwayCount,this.DayRateFlag});
    PerDiemJobRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Job = json['Job'];
        Total = JsonConverters.toDouble(json['Total']);
        NonTax = JsonConverters.toDouble(json['NonTax']);
        Tax = JsonConverters.toDouble(json['Tax']);
        Days = json['Days'];
        AwayCount = json['AwayCount'];
        DayRateFlag = json['DayRateFlag'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Job': Job,
        'Total': Total,
        'NonTax': NonTax,
        'Tax': Tax,
        'Days': Days,
        'AwayCount': AwayCount,
        'DayRateFlag': DayRateFlag
    };

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

class PerDiemBoard implements IConvertible
{
    double? TotalCost;
    double? NonTaxable;
    double? Taxable;
    int? AwayCount;
    List<PerDiemJobRow>? Jobs = [];

    PerDiemBoard({this.TotalCost,this.NonTaxable,this.Taxable,this.AwayCount,this.Jobs});
    PerDiemBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TotalCost = JsonConverters.toDouble(json['TotalCost']);
        NonTaxable = JsonConverters.toDouble(json['NonTaxable']);
        Taxable = JsonConverters.toDouble(json['Taxable']);
        AwayCount = json['AwayCount'];
        Jobs = JsonConverters.fromJson(json['Jobs'],'List<PerDiemJobRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TotalCost': TotalCost,
        'NonTaxable': NonTaxable,
        'Taxable': Taxable,
        'AwayCount': AwayCount,
        'Jobs': JsonConverters.toJson(Jobs,'List<PerDiemJobRow>',context!)
    };

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

class MarginJobRow implements IConvertible
{
    String? Job;
    double? BasePct;
    double? ProjPct;
    double? FadePts;
    String? Severity;
    double? OtCost;
    double? PerDiem;

    MarginJobRow({this.Job,this.BasePct,this.ProjPct,this.FadePts,this.Severity,this.OtCost,this.PerDiem});
    MarginJobRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Job = json['Job'];
        BasePct = JsonConverters.toDouble(json['BasePct']);
        ProjPct = JsonConverters.toDouble(json['ProjPct']);
        FadePts = JsonConverters.toDouble(json['FadePts']);
        Severity = json['Severity'];
        OtCost = JsonConverters.toDouble(json['OtCost']);
        PerDiem = JsonConverters.toDouble(json['PerDiem']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Job': Job,
        'BasePct': BasePct,
        'ProjPct': ProjPct,
        'FadePts': FadePts,
        'Severity': Severity,
        'OtCost': OtCost,
        'PerDiem': PerDiem
    };

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

class MarginBoard implements IConvertible
{
    int? JobCount;
    double? TotalFade;
    List<MarginJobRow>? Jobs = [];

    MarginBoard({this.JobCount,this.TotalFade,this.Jobs});
    MarginBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        JobCount = json['JobCount'];
        TotalFade = JsonConverters.toDouble(json['TotalFade']);
        Jobs = JsonConverters.fromJson(json['Jobs'],'List<MarginJobRow>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'JobCount': JobCount,
        'TotalFade': TotalFade,
        'Jobs': JsonConverters.toJson(Jobs,'List<MarginJobRow>',context!)
    };

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

class UtilRow implements IConvertible
{
    int? ContactID;
    String? WorkerName;
    String? Crew;
    double? ProjHours;
    double? BaselineHours;
    double? Pct;
    String? Band;

    UtilRow({this.ContactID,this.WorkerName,this.Crew,this.ProjHours,this.BaselineHours,this.Pct,this.Band});
    UtilRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ContactID = json['ContactID'];
        WorkerName = json['WorkerName'];
        Crew = json['Crew'];
        ProjHours = JsonConverters.toDouble(json['ProjHours']);
        BaselineHours = JsonConverters.toDouble(json['BaselineHours']);
        Pct = JsonConverters.toDouble(json['Pct']);
        Band = json['Band'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ContactID': ContactID,
        'WorkerName': WorkerName,
        'Crew': Crew,
        'ProjHours': ProjHours,
        'BaselineHours': BaselineHours,
        'Pct': Pct,
        'Band': Band
    };

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

class UtilizationBoard implements IConvertible
{
    int? UnderCount;
    int? OverCount;
    List<UtilRow>? Rows = [];

    UtilizationBoard({this.UnderCount,this.OverCount,this.Rows});
    UtilizationBoard.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'UnderCount': UnderCount,
        'OverCount': OverCount,
        'Rows': JsonConverters.toJson(Rows,'List<UtilRow>',context!)
    };

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

class PlanningSuggestion implements IConvertible
{
    String? Id;
    String? Kind;
    String? Title;
    String? Detail;
    String? SaveText;
    String? Effect;
    String? RuleId;
    String? LegalNote;
    String? ApplyLabel;
    String? Severity;

    PlanningSuggestion({this.Id,this.Kind,this.Title,this.Detail,this.SaveText,this.Effect,this.RuleId,this.LegalNote,this.ApplyLabel,this.Severity});
    PlanningSuggestion.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Kind = json['Kind'];
        Title = json['Title'];
        Detail = json['Detail'];
        SaveText = json['SaveText'];
        Effect = json['Effect'];
        RuleId = json['RuleId'];
        LegalNote = json['LegalNote'];
        ApplyLabel = json['ApplyLabel'];
        Severity = json['Severity'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Kind': Kind,
        'Title': Title,
        'Detail': Detail,
        'SaveText': SaveText,
        'Effect': Effect,
        'RuleId': RuleId,
        'LegalNote': LegalNote,
        'ApplyLabel': ApplyLabel,
        'Severity': Severity
    };

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

class PlanningSurface implements IConvertible
{
    String? WeekLabel;
    DateTime? WeekStart;
    int? WorkerCount;
    OtExposureBoard? Ot;
    PerDiemBoard? PerDiem;
    MarginBoard? Margin;
    UtilizationBoard? Utilization;
    List<PlanningSuggestion>? Suggestions = [];

    PlanningSurface({this.WeekLabel,this.WeekStart,this.WorkerCount,this.Ot,this.PerDiem,this.Margin,this.Utilization,this.Suggestions});
    PlanningSurface.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        WeekLabel = json['WeekLabel'];
        WeekStart = JsonConverters.fromJson(json['WeekStart'],'DateTime',context!);
        WorkerCount = json['WorkerCount'];
        Ot = JsonConverters.fromJson(json['Ot'],'OtExposureBoard',context!);
        PerDiem = JsonConverters.fromJson(json['PerDiem'],'PerDiemBoard',context!);
        Margin = JsonConverters.fromJson(json['Margin'],'MarginBoard',context!);
        Utilization = JsonConverters.fromJson(json['Utilization'],'UtilizationBoard',context!);
        Suggestions = JsonConverters.fromJson(json['Suggestions'],'List<PlanningSuggestion>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'WeekLabel': WeekLabel,
        'WeekStart': JsonConverters.toJson(WeekStart,'DateTime',context!),
        'WorkerCount': WorkerCount,
        'Ot': JsonConverters.toJson(Ot,'OtExposureBoard',context!),
        'PerDiem': JsonConverters.toJson(PerDiem,'PerDiemBoard',context!),
        'Margin': JsonConverters.toJson(Margin,'MarginBoard',context!),
        'Utilization': JsonConverters.toJson(Utilization,'UtilizationBoard',context!),
        'Suggestions': JsonConverters.toJson(Suggestions,'List<PlanningSuggestion>',context!)
    };

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

class PlanningResponse implements IConvertible
{
    PlanningSurface? Surface;
    bool? CanSeePay;
    ResponseStatus? ResponseStatus;

    PlanningResponse({this.Surface,this.CanSeePay,this.ResponseStatus});
    PlanningResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

// @Route("/v1/workforce/planning", "GET")
class PlanningRequest implements IReturn<PlanningResponse>, IConvertible, IGet
{
    DateTime? AsOf;

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

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

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

    createResponse() => PlanningResponse();
    getResponseTypeName() => "PlanningResponse";
    getTypeName() => "PlanningRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'OtRow': TypeInfo(TypeOf.Class, create:() => OtRow()),
    'OtExposureBoard': TypeInfo(TypeOf.Class, create:() => OtExposureBoard()),
    'List<OtRow>': TypeInfo(TypeOf.Class, create:() => <OtRow>[]),
    'PerDiemJobRow': TypeInfo(TypeOf.Class, create:() => PerDiemJobRow()),
    'PerDiemBoard': TypeInfo(TypeOf.Class, create:() => PerDiemBoard()),
    'List<PerDiemJobRow>': TypeInfo(TypeOf.Class, create:() => <PerDiemJobRow>[]),
    'MarginJobRow': TypeInfo(TypeOf.Class, create:() => MarginJobRow()),
    'MarginBoard': TypeInfo(TypeOf.Class, create:() => MarginBoard()),
    'List<MarginJobRow>': TypeInfo(TypeOf.Class, create:() => <MarginJobRow>[]),
    'UtilRow': TypeInfo(TypeOf.Class, create:() => UtilRow()),
    'UtilizationBoard': TypeInfo(TypeOf.Class, create:() => UtilizationBoard()),
    'List<UtilRow>': TypeInfo(TypeOf.Class, create:() => <UtilRow>[]),
    'PlanningSuggestion': TypeInfo(TypeOf.Class, create:() => PlanningSuggestion()),
    'PlanningSurface': TypeInfo(TypeOf.Class, create:() => PlanningSurface()),
    'List<PlanningSuggestion>': TypeInfo(TypeOf.Class, create:() => <PlanningSuggestion>[]),
    'PlanningResponse': TypeInfo(TypeOf.Class, create:() => PlanningResponse()),
    'PlanningRequest': TypeInfo(TypeOf.Class, create:() => PlanningRequest()),
});