/* Options:
Date: 2026-08-01 06:30:24
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: EstimateCalendarPutRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

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

class EstimateSettingsView implements IConvertible
{
    int? RfpEstimateID;
    DateTime? StartDate;
    DateTime? DeadlineDate;
    int? WorkdaysPerWeek;
    double? HoursPerDay;
    double? WeatherPct;
    double? OhpPct;
    double? ContingencyPct;
    double? BondPct;
    List<DateTime>? Holidays = [];
    DateTime? AppliedStartDate;

    EstimateSettingsView({this.RfpEstimateID,this.StartDate,this.DeadlineDate,this.WorkdaysPerWeek,this.HoursPerDay,this.WeatherPct,this.OhpPct,this.ContingencyPct,this.BondPct,this.Holidays,this.AppliedStartDate});
    EstimateSettingsView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RfpEstimateID = json['RfpEstimateID'];
        StartDate = JsonConverters.fromJson(json['StartDate'],'DateTime',context!);
        DeadlineDate = JsonConverters.fromJson(json['DeadlineDate'],'DateTime',context!);
        WorkdaysPerWeek = json['WorkdaysPerWeek'];
        HoursPerDay = JsonConverters.toDouble(json['HoursPerDay']);
        WeatherPct = JsonConverters.toDouble(json['WeatherPct']);
        OhpPct = JsonConverters.toDouble(json['OhpPct']);
        ContingencyPct = JsonConverters.toDouble(json['ContingencyPct']);
        BondPct = JsonConverters.toDouble(json['BondPct']);
        Holidays = JsonConverters.fromJson(json['Holidays'],'List<DateTime>',context!);
        AppliedStartDate = JsonConverters.fromJson(json['AppliedStartDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RfpEstimateID': RfpEstimateID,
        'StartDate': JsonConverters.toJson(StartDate,'DateTime',context!),
        'DeadlineDate': JsonConverters.toJson(DeadlineDate,'DateTime',context!),
        'WorkdaysPerWeek': WorkdaysPerWeek,
        'HoursPerDay': HoursPerDay,
        'WeatherPct': WeatherPct,
        'OhpPct': OhpPct,
        'ContingencyPct': ContingencyPct,
        'BondPct': BondPct,
        'Holidays': JsonConverters.toJson(Holidays,'List<DateTime>',context!),
        'AppliedStartDate': JsonConverters.toJson(AppliedStartDate,'DateTime',context!)
    };

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

class SpecRefView implements IConvertible
{
    String? Section;
    String? Title;
    String? Url;

    SpecRefView({this.Section,this.Title,this.Url});
    SpecRefView.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Section': Section,
        'Title': Title,
        'Url': Url
    };

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

class DodItemView implements IConvertible
{
    String? Key;
    String? Text;
    bool? Checked;
    String? Source;

    DodItemView({this.Key,this.Text,this.Checked,this.Source});
    DodItemView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Key = json['Key'];
        Text = json['Text'];
        Checked = json['Checked'];
        Source = json['Source'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Key': Key,
        'Text': Text,
        'Checked': Checked,
        'Source': Source
    };

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

class WorkPackageView implements IConvertible
{
    bool? HasPackage;
    String? Scope;
    String? LimitsOfWork;
    List<SpecRefView>? SpecRefs = [];
    List<String>? Constraints = [];
    List<String>? HoldPoints = [];
    List<DodItemView>? Dod = [];
    String? SafetyNote;
    String? Provenance;
    String? SpecBook;
    bool? UserEdited;
    String? RedraftNote;

    WorkPackageView({this.HasPackage,this.Scope,this.LimitsOfWork,this.SpecRefs,this.Constraints,this.HoldPoints,this.Dod,this.SafetyNote,this.Provenance,this.SpecBook,this.UserEdited,this.RedraftNote});
    WorkPackageView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        HasPackage = json['HasPackage'];
        Scope = json['Scope'];
        LimitsOfWork = json['LimitsOfWork'];
        SpecRefs = JsonConverters.fromJson(json['SpecRefs'],'List<SpecRefView>',context!);
        Constraints = JsonConverters.fromJson(json['Constraints'],'List<String>',context!);
        HoldPoints = JsonConverters.fromJson(json['HoldPoints'],'List<String>',context!);
        Dod = JsonConverters.fromJson(json['Dod'],'List<DodItemView>',context!);
        SafetyNote = json['SafetyNote'];
        Provenance = json['Provenance'];
        SpecBook = json['SpecBook'];
        UserEdited = json['UserEdited'];
        RedraftNote = json['RedraftNote'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'HasPackage': HasPackage,
        'Scope': Scope,
        'LimitsOfWork': LimitsOfWork,
        'SpecRefs': JsonConverters.toJson(SpecRefs,'List<SpecRefView>',context!),
        'Constraints': JsonConverters.toJson(Constraints,'List<String>',context!),
        'HoldPoints': JsonConverters.toJson(HoldPoints,'List<String>',context!),
        'Dod': JsonConverters.toJson(Dod,'List<DodItemView>',context!),
        'SafetyNote': SafetyNote,
        'Provenance': Provenance,
        'SpecBook': SpecBook,
        'UserEdited': UserEdited,
        'RedraftNote': RedraftNote
    };

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

class EstimateCrewLineView implements IConvertible
{
    String? Role;
    double? Hours;
    double? StHours;
    double? OtHours;
    bool? HasOt;
    bool? PremiumApplied;
    bool? NeedsRate;
    String? RateKey;
    String? Chip;
    double? Rrop;
    double? StCost;
    double? OtCost;
    double? Cost;
    double? FringeCost;

    EstimateCrewLineView({this.Role,this.Hours,this.StHours,this.OtHours,this.HasOt,this.PremiumApplied,this.NeedsRate,this.RateKey,this.Chip,this.Rrop,this.StCost,this.OtCost,this.Cost,this.FringeCost});
    EstimateCrewLineView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Role = json['Role'];
        Hours = JsonConverters.toDouble(json['Hours']);
        StHours = JsonConverters.toDouble(json['StHours']);
        OtHours = JsonConverters.toDouble(json['OtHours']);
        HasOt = json['HasOt'];
        PremiumApplied = json['PremiumApplied'];
        NeedsRate = json['NeedsRate'];
        RateKey = json['RateKey'];
        Chip = json['Chip'];
        Rrop = JsonConverters.toDouble(json['Rrop']);
        StCost = JsonConverters.toDouble(json['StCost']);
        OtCost = JsonConverters.toDouble(json['OtCost']);
        Cost = JsonConverters.toDouble(json['Cost']);
        FringeCost = JsonConverters.toDouble(json['FringeCost']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Role': Role,
        'Hours': Hours,
        'StHours': StHours,
        'OtHours': OtHours,
        'HasOt': HasOt,
        'PremiumApplied': PremiumApplied,
        'NeedsRate': NeedsRate,
        'RateKey': RateKey,
        'Chip': Chip,
        'Rrop': Rrop,
        'StCost': StCost,
        'OtCost': OtCost,
        'Cost': Cost,
        'FringeCost': FringeCost
    };

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

class EstimateEquipmentLineView implements IConvertible
{
    String? Name;
    double? Quantity;
    double? Rate;
    bool? NeedsRate;
    double? MobCost;
    double? Cost;
    bool? IsAvailabilityTracked;
    bool? IsOwned;
    String? AvailabilityLabel;
    String? FreedFromProject;
    DateTime? AvailableFrom;
    String? RateKey;
    String? Chip;
    String? RentalExplain;
    double? UsageDays;
    double? BilledDays;

    EstimateEquipmentLineView({this.Name,this.Quantity,this.Rate,this.NeedsRate,this.MobCost,this.Cost,this.IsAvailabilityTracked,this.IsOwned,this.AvailabilityLabel,this.FreedFromProject,this.AvailableFrom,this.RateKey,this.Chip,this.RentalExplain,this.UsageDays,this.BilledDays});
    EstimateEquipmentLineView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        Rate = JsonConverters.toDouble(json['Rate']);
        NeedsRate = json['NeedsRate'];
        MobCost = JsonConverters.toDouble(json['MobCost']);
        Cost = JsonConverters.toDouble(json['Cost']);
        IsAvailabilityTracked = json['IsAvailabilityTracked'];
        IsOwned = json['IsOwned'];
        AvailabilityLabel = json['AvailabilityLabel'];
        FreedFromProject = json['FreedFromProject'];
        AvailableFrom = JsonConverters.fromJson(json['AvailableFrom'],'DateTime',context!);
        RateKey = json['RateKey'];
        Chip = json['Chip'];
        RentalExplain = json['RentalExplain'];
        UsageDays = JsonConverters.toDouble(json['UsageDays']);
        BilledDays = JsonConverters.toDouble(json['BilledDays']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Quantity': Quantity,
        'Rate': Rate,
        'NeedsRate': NeedsRate,
        'MobCost': MobCost,
        'Cost': Cost,
        'IsAvailabilityTracked': IsAvailabilityTracked,
        'IsOwned': IsOwned,
        'AvailabilityLabel': AvailabilityLabel,
        'FreedFromProject': FreedFromProject,
        'AvailableFrom': JsonConverters.toJson(AvailableFrom,'DateTime',context!),
        'RateKey': RateKey,
        'Chip': Chip,
        'RentalExplain': RentalExplain,
        'UsageDays': UsageDays,
        'BilledDays': BilledDays
    };

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

class EstimateMaterialLineView implements IConvertible
{
    String? Name;
    double? Quantity;
    String? Unit;
    double? Rate;
    bool? NeedsRate;
    double? Cost;
    String? RateKey;
    String? Chip;

    EstimateMaterialLineView({this.Name,this.Quantity,this.Unit,this.Rate,this.NeedsRate,this.Cost,this.RateKey,this.Chip});
    EstimateMaterialLineView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        Unit = json['Unit'];
        Rate = JsonConverters.toDouble(json['Rate']);
        NeedsRate = json['NeedsRate'];
        Cost = JsonConverters.toDouble(json['Cost']);
        RateKey = json['RateKey'];
        Chip = json['Chip'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Quantity': Quantity,
        'Unit': Unit,
        'Rate': Rate,
        'NeedsRate': NeedsRate,
        'Cost': Cost,
        'RateKey': RateKey,
        'Chip': Chip
    };

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

class EstimateSubcontractView implements IConvertible
{
    int? EstimateSubcontractID;
    int? TaskSeq;
    String? Vendor;
    double? Amount;
    String? Scope;

    EstimateSubcontractView({this.EstimateSubcontractID,this.TaskSeq,this.Vendor,this.Amount,this.Scope});
    EstimateSubcontractView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        EstimateSubcontractID = json['EstimateSubcontractID'];
        TaskSeq = json['TaskSeq'];
        Vendor = json['Vendor'];
        Amount = JsonConverters.toDouble(json['Amount']);
        Scope = json['Scope'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'EstimateSubcontractID': EstimateSubcontractID,
        'TaskSeq': TaskSeq,
        'Vendor': Vendor,
        'Amount': Amount,
        'Scope': Scope
    };

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

class EstimateJobView implements IConvertible
{
    int? Seq;
    WorkPackageView? WorkPackage;
    String? ItemNo;
    String? Name;
    String? Category;
    String? SourceRef;
    String? Unit;
    double? Quantity;
    String? PatternCode;
    int? Workdays;
    double? HoursPerDay;
    bool? IsNight;
    double? WeeklyHours;
    double? OtFraction;
    double? Days;
    double? EffectiveProdPerDay;
    bool? CrewPremiumApplied;
    double? CrewCost;
    double? FringeCost;
    double? EquipmentCost;
    double? MaterialCost;
    double? SubcontractCost;
    double? Direct;
    String? PricingBasis;
    double? BenchmarkUnitPrice;
    List<EstimateCrewLineView>? Crew = [];
    List<EstimateEquipmentLineView>? Equipment = [];
    List<EstimateMaterialLineView>? Materials = [];
    List<EstimateSubcontractView>? Subcontracts = [];

    EstimateJobView({this.Seq,this.WorkPackage,this.ItemNo,this.Name,this.Category,this.SourceRef,this.Unit,this.Quantity,this.PatternCode,this.Workdays,this.HoursPerDay,this.IsNight,this.WeeklyHours,this.OtFraction,this.Days,this.EffectiveProdPerDay,this.CrewPremiumApplied,this.CrewCost,this.FringeCost,this.EquipmentCost,this.MaterialCost,this.SubcontractCost,this.Direct,this.PricingBasis,this.BenchmarkUnitPrice,this.Crew,this.Equipment,this.Materials,this.Subcontracts});
    EstimateJobView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Seq = json['Seq'];
        WorkPackage = JsonConverters.fromJson(json['WorkPackage'],'WorkPackageView',context!);
        ItemNo = json['ItemNo'];
        Name = json['Name'];
        Category = json['Category'];
        SourceRef = json['SourceRef'];
        Unit = json['Unit'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        PatternCode = json['PatternCode'];
        Workdays = json['Workdays'];
        HoursPerDay = JsonConverters.toDouble(json['HoursPerDay']);
        IsNight = json['IsNight'];
        WeeklyHours = JsonConverters.toDouble(json['WeeklyHours']);
        OtFraction = JsonConverters.toDouble(json['OtFraction']);
        Days = JsonConverters.toDouble(json['Days']);
        EffectiveProdPerDay = JsonConverters.toDouble(json['EffectiveProdPerDay']);
        CrewPremiumApplied = json['CrewPremiumApplied'];
        CrewCost = JsonConverters.toDouble(json['CrewCost']);
        FringeCost = JsonConverters.toDouble(json['FringeCost']);
        EquipmentCost = JsonConverters.toDouble(json['EquipmentCost']);
        MaterialCost = JsonConverters.toDouble(json['MaterialCost']);
        SubcontractCost = JsonConverters.toDouble(json['SubcontractCost']);
        Direct = JsonConverters.toDouble(json['Direct']);
        PricingBasis = json['PricingBasis'];
        BenchmarkUnitPrice = JsonConverters.toDouble(json['BenchmarkUnitPrice']);
        Crew = JsonConverters.fromJson(json['Crew'],'List<EstimateCrewLineView>',context!);
        Equipment = JsonConverters.fromJson(json['Equipment'],'List<EstimateEquipmentLineView>',context!);
        Materials = JsonConverters.fromJson(json['Materials'],'List<EstimateMaterialLineView>',context!);
        Subcontracts = JsonConverters.fromJson(json['Subcontracts'],'List<EstimateSubcontractView>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Seq': Seq,
        'WorkPackage': JsonConverters.toJson(WorkPackage,'WorkPackageView',context!),
        'ItemNo': ItemNo,
        'Name': Name,
        'Category': Category,
        'SourceRef': SourceRef,
        'Unit': Unit,
        'Quantity': Quantity,
        'PatternCode': PatternCode,
        'Workdays': Workdays,
        'HoursPerDay': HoursPerDay,
        'IsNight': IsNight,
        'WeeklyHours': WeeklyHours,
        'OtFraction': OtFraction,
        'Days': Days,
        'EffectiveProdPerDay': EffectiveProdPerDay,
        'CrewPremiumApplied': CrewPremiumApplied,
        'CrewCost': CrewCost,
        'FringeCost': FringeCost,
        'EquipmentCost': EquipmentCost,
        'MaterialCost': MaterialCost,
        'SubcontractCost': SubcontractCost,
        'Direct': Direct,
        'PricingBasis': PricingBasis,
        'BenchmarkUnitPrice': BenchmarkUnitPrice,
        'Crew': JsonConverters.toJson(Crew,'List<EstimateCrewLineView>',context!),
        'Equipment': JsonConverters.toJson(Equipment,'List<EstimateEquipmentLineView>',context!),
        'Materials': JsonConverters.toJson(Materials,'List<EstimateMaterialLineView>',context!),
        'Subcontracts': JsonConverters.toJson(Subcontracts,'List<EstimateSubcontractView>',context!)
    };

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

class BidScheduleLine implements IConvertible
{
    String? ItemNo;
    String? Description;
    String? Unit;
    double? Quantity;
    double? UnitPrice;
    double? Extension;
    String? PricingBasis;
    double? BenchmarkDeltaPct;
    bool? BenchmarkFlagged;

    BidScheduleLine({this.ItemNo,this.Description,this.Unit,this.Quantity,this.UnitPrice,this.Extension,this.PricingBasis,this.BenchmarkDeltaPct,this.BenchmarkFlagged});
    BidScheduleLine.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ItemNo = json['ItemNo'];
        Description = json['Description'];
        Unit = json['Unit'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        UnitPrice = JsonConverters.toDouble(json['UnitPrice']);
        Extension = JsonConverters.toDouble(json['Extension']);
        PricingBasis = json['PricingBasis'];
        BenchmarkDeltaPct = JsonConverters.toDouble(json['BenchmarkDeltaPct']);
        BenchmarkFlagged = json['BenchmarkFlagged'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ItemNo': ItemNo,
        'Description': Description,
        'Unit': Unit,
        'Quantity': Quantity,
        'UnitPrice': UnitPrice,
        'Extension': Extension,
        'PricingBasis': PricingBasis,
        'BenchmarkDeltaPct': BenchmarkDeltaPct,
        'BenchmarkFlagged': BenchmarkFlagged
    };

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

class EstimateVarianceLine implements IConvertible
{
    int? Seq;
    String? ItemNo;
    String? Name;
    String? Unit;
    double? Quantity;
    double? OurUnitPrice;
    double? OurTotal;
    double? BenchmarkUnitPrice;
    double? MarketTotal;
    double? DeltaPct;
    double? RateMin;
    double? RateMax;
    int? SampleSize;
    bool? OutsideRange;
    bool? IsFloor;
    String? Severity;
    String? Note;

    EstimateVarianceLine({this.Seq,this.ItemNo,this.Name,this.Unit,this.Quantity,this.OurUnitPrice,this.OurTotal,this.BenchmarkUnitPrice,this.MarketTotal,this.DeltaPct,this.RateMin,this.RateMax,this.SampleSize,this.OutsideRange,this.IsFloor,this.Severity,this.Note});
    EstimateVarianceLine.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Seq = json['Seq'];
        ItemNo = json['ItemNo'];
        Name = json['Name'];
        Unit = json['Unit'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        OurUnitPrice = JsonConverters.toDouble(json['OurUnitPrice']);
        OurTotal = JsonConverters.toDouble(json['OurTotal']);
        BenchmarkUnitPrice = JsonConverters.toDouble(json['BenchmarkUnitPrice']);
        MarketTotal = JsonConverters.toDouble(json['MarketTotal']);
        DeltaPct = JsonConverters.toDouble(json['DeltaPct']);
        RateMin = JsonConverters.toDouble(json['RateMin']);
        RateMax = JsonConverters.toDouble(json['RateMax']);
        SampleSize = json['SampleSize'];
        OutsideRange = json['OutsideRange'];
        IsFloor = json['IsFloor'];
        Severity = json['Severity'];
        Note = json['Note'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Seq': Seq,
        'ItemNo': ItemNo,
        'Name': Name,
        'Unit': Unit,
        'Quantity': Quantity,
        'OurUnitPrice': OurUnitPrice,
        'OurTotal': OurTotal,
        'BenchmarkUnitPrice': BenchmarkUnitPrice,
        'MarketTotal': MarketTotal,
        'DeltaPct': DeltaPct,
        'RateMin': RateMin,
        'RateMax': RateMax,
        'SampleSize': SampleSize,
        'OutsideRange': OutsideRange,
        'IsFloor': IsFloor,
        'Severity': Severity,
        'Note': Note
    };

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

class EstimateVarianceView implements IConvertible
{
    List<EstimateVarianceLine>? Lines = [];
    int? ItemsTotal;
    int? ItemsBenchmarked;
    double? CoverageValuePct;
    double? OursTotal;
    double? MarketTotal;
    double? AggregateDeltaPct;
    int? FlooredCount;
    int? WatchCount;
    int? OutlierCount;
    int? CriticalCount;
    String? Note;

    EstimateVarianceView({this.Lines,this.ItemsTotal,this.ItemsBenchmarked,this.CoverageValuePct,this.OursTotal,this.MarketTotal,this.AggregateDeltaPct,this.FlooredCount,this.WatchCount,this.OutlierCount,this.CriticalCount,this.Note});
    EstimateVarianceView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Lines = JsonConverters.fromJson(json['Lines'],'List<EstimateVarianceLine>',context!);
        ItemsTotal = json['ItemsTotal'];
        ItemsBenchmarked = json['ItemsBenchmarked'];
        CoverageValuePct = JsonConverters.toDouble(json['CoverageValuePct']);
        OursTotal = JsonConverters.toDouble(json['OursTotal']);
        MarketTotal = JsonConverters.toDouble(json['MarketTotal']);
        AggregateDeltaPct = JsonConverters.toDouble(json['AggregateDeltaPct']);
        FlooredCount = json['FlooredCount'];
        WatchCount = json['WatchCount'];
        OutlierCount = json['OutlierCount'];
        CriticalCount = json['CriticalCount'];
        Note = json['Note'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Lines': JsonConverters.toJson(Lines,'List<EstimateVarianceLine>',context!),
        'ItemsTotal': ItemsTotal,
        'ItemsBenchmarked': ItemsBenchmarked,
        'CoverageValuePct': CoverageValuePct,
        'OursTotal': OursTotal,
        'MarketTotal': MarketTotal,
        'AggregateDeltaPct': AggregateDeltaPct,
        'FlooredCount': FlooredCount,
        'WatchCount': WatchCount,
        'OutlierCount': OutlierCount,
        'CriticalCount': CriticalCount,
        'Note': Note
    };

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

class IndicativeLine implements IConvertible
{
    int? Seq;
    String? ItemNo;
    String? Name;
    String? Unit;
    double? Quantity;
    String? Source;
    double? UnitPrice;
    double? LineTotal;

    IndicativeLine({this.Seq,this.ItemNo,this.Name,this.Unit,this.Quantity,this.Source,this.UnitPrice,this.LineTotal});
    IndicativeLine.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Seq = json['Seq'];
        ItemNo = json['ItemNo'];
        Name = json['Name'];
        Unit = json['Unit'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        Source = json['Source'];
        UnitPrice = JsonConverters.toDouble(json['UnitPrice']);
        LineTotal = JsonConverters.toDouble(json['LineTotal']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Seq': Seq,
        'ItemNo': ItemNo,
        'Name': Name,
        'Unit': Unit,
        'Quantity': Quantity,
        'Source': Source,
        'UnitPrice': UnitPrice,
        'LineTotal': LineTotal
    };

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

class IndicativeBidView implements IConvertible
{
    List<IndicativeLine>? Lines = [];
    int? BottomUpCount;
    double? BottomUpTotal;
    int? BenchmarkCount;
    double? BenchmarkTotal;
    int? UncoveredCount;
    double? UncoveredFloorTotal;
    double? IndicativeTotal;
    double? FloorTotal;
    String? Note;

    IndicativeBidView({this.Lines,this.BottomUpCount,this.BottomUpTotal,this.BenchmarkCount,this.BenchmarkTotal,this.UncoveredCount,this.UncoveredFloorTotal,this.IndicativeTotal,this.FloorTotal,this.Note});
    IndicativeBidView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Lines = JsonConverters.fromJson(json['Lines'],'List<IndicativeLine>',context!);
        BottomUpCount = json['BottomUpCount'];
        BottomUpTotal = JsonConverters.toDouble(json['BottomUpTotal']);
        BenchmarkCount = json['BenchmarkCount'];
        BenchmarkTotal = JsonConverters.toDouble(json['BenchmarkTotal']);
        UncoveredCount = json['UncoveredCount'];
        UncoveredFloorTotal = JsonConverters.toDouble(json['UncoveredFloorTotal']);
        IndicativeTotal = JsonConverters.toDouble(json['IndicativeTotal']);
        FloorTotal = JsonConverters.toDouble(json['FloorTotal']);
        Note = json['Note'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Lines': JsonConverters.toJson(Lines,'List<IndicativeLine>',context!),
        'BottomUpCount': BottomUpCount,
        'BottomUpTotal': BottomUpTotal,
        'BenchmarkCount': BenchmarkCount,
        'BenchmarkTotal': BenchmarkTotal,
        'UncoveredCount': UncoveredCount,
        'UncoveredFloorTotal': UncoveredFloorTotal,
        'IndicativeTotal': IndicativeTotal,
        'FloorTotal': FloorTotal,
        'Note': Note
    };

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

class EstimateSummaryView implements IConvertible
{
    double? Direct;
    double? OhpPct;
    double? OhpAmount;
    double? BondPct;
    double? BondAmount;
    double? ContingencyPct;
    double? ContingencyAmount;
    double? BidTotal;
    double? LoadFactor;
    double? MarginPct;

    EstimateSummaryView({this.Direct,this.OhpPct,this.OhpAmount,this.BondPct,this.BondAmount,this.ContingencyPct,this.ContingencyAmount,this.BidTotal,this.LoadFactor,this.MarginPct});
    EstimateSummaryView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Direct = JsonConverters.toDouble(json['Direct']);
        OhpPct = JsonConverters.toDouble(json['OhpPct']);
        OhpAmount = JsonConverters.toDouble(json['OhpAmount']);
        BondPct = JsonConverters.toDouble(json['BondPct']);
        BondAmount = JsonConverters.toDouble(json['BondAmount']);
        ContingencyPct = JsonConverters.toDouble(json['ContingencyPct']);
        ContingencyAmount = JsonConverters.toDouble(json['ContingencyAmount']);
        BidTotal = JsonConverters.toDouble(json['BidTotal']);
        LoadFactor = JsonConverters.toDouble(json['LoadFactor']);
        MarginPct = JsonConverters.toDouble(json['MarginPct']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Direct': Direct,
        'OhpPct': OhpPct,
        'OhpAmount': OhpAmount,
        'BondPct': BondPct,
        'BondAmount': BondAmount,
        'ContingencyPct': ContingencyPct,
        'ContingencyAmount': ContingencyAmount,
        'BidTotal': BidTotal,
        'LoadFactor': LoadFactor,
        'MarginPct': MarginPct
    };

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

class EstimateTimingView implements IConvertible
{
    double? TotalWorkdays;
    int? CalendarDays;
    DateTime? Finish;
    bool? Feasible;
    DateTime? Deadline;

    EstimateTimingView({this.TotalWorkdays,this.CalendarDays,this.Finish,this.Feasible,this.Deadline});
    EstimateTimingView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TotalWorkdays = JsonConverters.toDouble(json['TotalWorkdays']);
        CalendarDays = json['CalendarDays'];
        Finish = JsonConverters.fromJson(json['Finish'],'DateTime',context!);
        Feasible = json['Feasible'];
        Deadline = JsonConverters.fromJson(json['Deadline'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TotalWorkdays': TotalWorkdays,
        'CalendarDays': CalendarDays,
        'Finish': JsonConverters.toJson(Finish,'DateTime',context!),
        'Feasible': Feasible,
        'Deadline': JsonConverters.toJson(Deadline,'DateTime',context!)
    };

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

class EstimateReviewItemView implements IConvertible
{
    int? TaskSeq;
    String? TaskName;
    String? Reason;
    String? Status;

    EstimateReviewItemView({this.TaskSeq,this.TaskName,this.Reason,this.Status});
    EstimateReviewItemView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TaskSeq = json['TaskSeq'];
        TaskName = json['TaskName'];
        Reason = json['Reason'];
        Status = json['Status'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TaskSeq': TaskSeq,
        'TaskName': TaskName,
        'Reason': Reason,
        'Status': Status
    };

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

class EstimatingView implements IConvertible
{
    int? RfpDocumentID;
    String? ProjectName;
    String? ClientName;
    String? BidDueDate;
    String? ProjectType;
    EstimateSettingsView? Settings;
    List<EstimateJobView>? Jobs = [];
    List<BidScheduleLine>? Schedule = [];
    double? ScheduleTotal;
    EstimateVarianceView? Variance;
    IndicativeBidView? Indicative;
    EstimateSummaryView? Summary;
    EstimateTimingView? Timing;
    int? NeedsRateCount;
    List<String>? NeedsRateKeys = [];
    List<EstimateReviewItemView>? ReviewItems = [];
    int? NeedsReviewCount;
    bool? CanApprove;
    bool? CanSeePay;

    EstimatingView({this.RfpDocumentID,this.ProjectName,this.ClientName,this.BidDueDate,this.ProjectType,this.Settings,this.Jobs,this.Schedule,this.ScheduleTotal,this.Variance,this.Indicative,this.Summary,this.Timing,this.NeedsRateCount,this.NeedsRateKeys,this.ReviewItems,this.NeedsReviewCount,this.CanApprove,this.CanSeePay});
    EstimatingView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RfpDocumentID = json['RfpDocumentID'];
        ProjectName = json['ProjectName'];
        ClientName = json['ClientName'];
        BidDueDate = json['BidDueDate'];
        ProjectType = json['ProjectType'];
        Settings = JsonConverters.fromJson(json['Settings'],'EstimateSettingsView',context!);
        Jobs = JsonConverters.fromJson(json['Jobs'],'List<EstimateJobView>',context!);
        Schedule = JsonConverters.fromJson(json['Schedule'],'List<BidScheduleLine>',context!);
        ScheduleTotal = JsonConverters.toDouble(json['ScheduleTotal']);
        Variance = JsonConverters.fromJson(json['Variance'],'EstimateVarianceView',context!);
        Indicative = JsonConverters.fromJson(json['Indicative'],'IndicativeBidView',context!);
        Summary = JsonConverters.fromJson(json['Summary'],'EstimateSummaryView',context!);
        Timing = JsonConverters.fromJson(json['Timing'],'EstimateTimingView',context!);
        NeedsRateCount = json['NeedsRateCount'];
        NeedsRateKeys = JsonConverters.fromJson(json['NeedsRateKeys'],'List<String>',context!);
        ReviewItems = JsonConverters.fromJson(json['ReviewItems'],'List<EstimateReviewItemView>',context!);
        NeedsReviewCount = json['NeedsReviewCount'];
        CanApprove = json['CanApprove'];
        CanSeePay = json['CanSeePay'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RfpDocumentID': RfpDocumentID,
        'ProjectName': ProjectName,
        'ClientName': ClientName,
        'BidDueDate': BidDueDate,
        'ProjectType': ProjectType,
        'Settings': JsonConverters.toJson(Settings,'EstimateSettingsView',context!),
        'Jobs': JsonConverters.toJson(Jobs,'List<EstimateJobView>',context!),
        'Schedule': JsonConverters.toJson(Schedule,'List<BidScheduleLine>',context!),
        'ScheduleTotal': ScheduleTotal,
        'Variance': JsonConverters.toJson(Variance,'EstimateVarianceView',context!),
        'Indicative': JsonConverters.toJson(Indicative,'IndicativeBidView',context!),
        'Summary': JsonConverters.toJson(Summary,'EstimateSummaryView',context!),
        'Timing': JsonConverters.toJson(Timing,'EstimateTimingView',context!),
        'NeedsRateCount': NeedsRateCount,
        'NeedsRateKeys': JsonConverters.toJson(NeedsRateKeys,'List<String>',context!),
        'ReviewItems': JsonConverters.toJson(ReviewItems,'List<EstimateReviewItemView>',context!),
        'NeedsReviewCount': NeedsReviewCount,
        'CanApprove': CanApprove,
        'CanSeePay': CanSeePay
    };

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

class EstimateResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    EstimatingView? View;

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

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

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

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

// @Route("/v1/Rfp/{RfpDocumentUID}/Estimate/Calendar", "PUT,OPTIONS")
class EstimateCalendarPutRequest implements IReturn<EstimateResponse>, IConvertible, IPut
{
    String? RfpDocumentUID;
    DateTime? StartDate;
    DateTime? DeadlineDate;
    int? WorkdaysPerWeek;
    double? HoursPerDay;
    double? WeatherPct;
    List<DateTime>? Holidays = [];

    EstimateCalendarPutRequest({this.RfpDocumentUID,this.StartDate,this.DeadlineDate,this.WorkdaysPerWeek,this.HoursPerDay,this.WeatherPct,this.Holidays});
    EstimateCalendarPutRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RfpDocumentUID = json['RfpDocumentUID'];
        StartDate = JsonConverters.fromJson(json['StartDate'],'DateTime',context!);
        DeadlineDate = JsonConverters.fromJson(json['DeadlineDate'],'DateTime',context!);
        WorkdaysPerWeek = json['WorkdaysPerWeek'];
        HoursPerDay = JsonConverters.toDouble(json['HoursPerDay']);
        WeatherPct = JsonConverters.toDouble(json['WeatherPct']);
        Holidays = JsonConverters.fromJson(json['Holidays'],'List<DateTime>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RfpDocumentUID': RfpDocumentUID,
        'StartDate': JsonConverters.toJson(StartDate,'DateTime',context!),
        'DeadlineDate': JsonConverters.toJson(DeadlineDate,'DateTime',context!),
        'WorkdaysPerWeek': WorkdaysPerWeek,
        'HoursPerDay': HoursPerDay,
        'WeatherPct': WeatherPct,
        'Holidays': JsonConverters.toJson(Holidays,'List<DateTime>',context!)
    };

    createResponse() => EstimateResponse();
    getResponseTypeName() => "EstimateResponse";
    getTypeName() => "EstimateCalendarPutRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'EstimateSettingsView': TypeInfo(TypeOf.Class, create:() => EstimateSettingsView()),
    'List<DateTime>': TypeInfo(TypeOf.Class, create:() => <DateTime>[]),
    'SpecRefView': TypeInfo(TypeOf.Class, create:() => SpecRefView()),
    'DodItemView': TypeInfo(TypeOf.Class, create:() => DodItemView()),
    'WorkPackageView': TypeInfo(TypeOf.Class, create:() => WorkPackageView()),
    'List<SpecRefView>': TypeInfo(TypeOf.Class, create:() => <SpecRefView>[]),
    'List<DodItemView>': TypeInfo(TypeOf.Class, create:() => <DodItemView>[]),
    'EstimateCrewLineView': TypeInfo(TypeOf.Class, create:() => EstimateCrewLineView()),
    'EstimateEquipmentLineView': TypeInfo(TypeOf.Class, create:() => EstimateEquipmentLineView()),
    'EstimateMaterialLineView': TypeInfo(TypeOf.Class, create:() => EstimateMaterialLineView()),
    'EstimateSubcontractView': TypeInfo(TypeOf.Class, create:() => EstimateSubcontractView()),
    'EstimateJobView': TypeInfo(TypeOf.Class, create:() => EstimateJobView()),
    'List<EstimateCrewLineView>': TypeInfo(TypeOf.Class, create:() => <EstimateCrewLineView>[]),
    'List<EstimateEquipmentLineView>': TypeInfo(TypeOf.Class, create:() => <EstimateEquipmentLineView>[]),
    'List<EstimateMaterialLineView>': TypeInfo(TypeOf.Class, create:() => <EstimateMaterialLineView>[]),
    'List<EstimateSubcontractView>': TypeInfo(TypeOf.Class, create:() => <EstimateSubcontractView>[]),
    'BidScheduleLine': TypeInfo(TypeOf.Class, create:() => BidScheduleLine()),
    'EstimateVarianceLine': TypeInfo(TypeOf.Class, create:() => EstimateVarianceLine()),
    'EstimateVarianceView': TypeInfo(TypeOf.Class, create:() => EstimateVarianceView()),
    'List<EstimateVarianceLine>': TypeInfo(TypeOf.Class, create:() => <EstimateVarianceLine>[]),
    'IndicativeLine': TypeInfo(TypeOf.Class, create:() => IndicativeLine()),
    'IndicativeBidView': TypeInfo(TypeOf.Class, create:() => IndicativeBidView()),
    'List<IndicativeLine>': TypeInfo(TypeOf.Class, create:() => <IndicativeLine>[]),
    'EstimateSummaryView': TypeInfo(TypeOf.Class, create:() => EstimateSummaryView()),
    'EstimateTimingView': TypeInfo(TypeOf.Class, create:() => EstimateTimingView()),
    'EstimateReviewItemView': TypeInfo(TypeOf.Class, create:() => EstimateReviewItemView()),
    'EstimatingView': TypeInfo(TypeOf.Class, create:() => EstimatingView()),
    'List<EstimateJobView>': TypeInfo(TypeOf.Class, create:() => <EstimateJobView>[]),
    'List<BidScheduleLine>': TypeInfo(TypeOf.Class, create:() => <BidScheduleLine>[]),
    'List<EstimateReviewItemView>': TypeInfo(TypeOf.Class, create:() => <EstimateReviewItemView>[]),
    'EstimateResponse': TypeInfo(TypeOf.Class, create:() => EstimateResponse()),
    'EstimateCalendarPutRequest': TypeInfo(TypeOf.Class, create:() => EstimateCalendarPutRequest()),
});