/* Options:
Date: 2026-09-23 00:21:10
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: ApplyAssemblyRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

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

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 ResourcedPosition implements IConvertible
{
    String? PositionTag;
    double? Hours;
    double? CrewSize;
    double? Utilization;
    double? FixedDays;
    int? Headcount;
    String? SourceReference;
    String? Notes;
    bool? IsInCatalog;
    int? ContactID;

    ResourcedPosition({this.PositionTag,this.Hours,this.CrewSize,this.Utilization,this.FixedDays,this.Headcount,this.SourceReference,this.Notes,this.IsInCatalog,this.ContactID});
    ResourcedPosition.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PositionTag = json['PositionTag'];
        Hours = JsonConverters.toDouble(json['Hours']);
        CrewSize = JsonConverters.toDouble(json['CrewSize']);
        Utilization = JsonConverters.toDouble(json['Utilization']);
        FixedDays = JsonConverters.toDouble(json['FixedDays']);
        Headcount = json['Headcount'];
        SourceReference = json['SourceReference'];
        Notes = json['Notes'];
        IsInCatalog = json['IsInCatalog'];
        ContactID = json['ContactID'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PositionTag': PositionTag,
        'Hours': Hours,
        'CrewSize': CrewSize,
        'Utilization': Utilization,
        'FixedDays': FixedDays,
        'Headcount': Headcount,
        'SourceReference': SourceReference,
        'Notes': Notes,
        'IsInCatalog': IsInCatalog,
        'ContactID': ContactID
    };

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

class ResourcedEquipment implements IConvertible
{
    int? EquipmentID;
    String? EquipmentName;
    String? MakeModel;
    double? Quantity;
    double? DurationDays;
    double? Utilization;
    double? FixedDays;
    String? SourceReference;
    String? Notes;
    bool? IsInCatalog;
    int? SuggestedEquipmentID;
    String? SuggestedEquipmentName;

    ResourcedEquipment({this.EquipmentID,this.EquipmentName,this.MakeModel,this.Quantity,this.DurationDays,this.Utilization,this.FixedDays,this.SourceReference,this.Notes,this.IsInCatalog,this.SuggestedEquipmentID,this.SuggestedEquipmentName});
    ResourcedEquipment.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        EquipmentID = json['EquipmentID'];
        EquipmentName = json['EquipmentName'];
        MakeModel = json['MakeModel'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        DurationDays = JsonConverters.toDouble(json['DurationDays']);
        Utilization = JsonConverters.toDouble(json['Utilization']);
        FixedDays = JsonConverters.toDouble(json['FixedDays']);
        SourceReference = json['SourceReference'];
        Notes = json['Notes'];
        IsInCatalog = json['IsInCatalog'];
        SuggestedEquipmentID = json['SuggestedEquipmentID'];
        SuggestedEquipmentName = json['SuggestedEquipmentName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'EquipmentID': EquipmentID,
        'EquipmentName': EquipmentName,
        'MakeModel': MakeModel,
        'Quantity': Quantity,
        'DurationDays': DurationDays,
        'Utilization': Utilization,
        'FixedDays': FixedDays,
        'SourceReference': SourceReference,
        'Notes': Notes,
        'IsInCatalog': IsInCatalog,
        'SuggestedEquipmentID': SuggestedEquipmentID,
        'SuggestedEquipmentName': SuggestedEquipmentName
    };

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

class ResourcedMaterial implements IConvertible
{
    int? MaterialID;
    String? MaterialName;
    String? MakeModel;
    double? Quantity;
    double? QuantityPerUnit;
    String? Unit;
    String? SourceReference;
    String? Notes;
    bool? IsInCatalog;
    int? SuggestedMaterialID;
    String? SuggestedMaterialName;

    ResourcedMaterial({this.MaterialID,this.MaterialName,this.MakeModel,this.Quantity,this.QuantityPerUnit,this.Unit,this.SourceReference,this.Notes,this.IsInCatalog,this.SuggestedMaterialID,this.SuggestedMaterialName});
    ResourcedMaterial.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MaterialID = json['MaterialID'];
        MaterialName = json['MaterialName'];
        MakeModel = json['MakeModel'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        QuantityPerUnit = JsonConverters.toDouble(json['QuantityPerUnit']);
        Unit = json['Unit'];
        SourceReference = json['SourceReference'];
        Notes = json['Notes'];
        IsInCatalog = json['IsInCatalog'];
        SuggestedMaterialID = json['SuggestedMaterialID'];
        SuggestedMaterialName = json['SuggestedMaterialName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MaterialID': MaterialID,
        'MaterialName': MaterialName,
        'MakeModel': MakeModel,
        'Quantity': Quantity,
        'QuantityPerUnit': QuantityPerUnit,
        'Unit': Unit,
        'SourceReference': SourceReference,
        'Notes': Notes,
        'IsInCatalog': IsInCatalog,
        'SuggestedMaterialID': SuggestedMaterialID,
        'SuggestedMaterialName': SuggestedMaterialName
    };

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

class TaskResourcing implements IConvertible
{
    List<ResourcedPosition>? Positions = [];
    List<ResourcedEquipment>? Equipment = [];
    List<ResourcedMaterial>? Materials = [];
    double? ResourcedForQuantity;
    double? ProductionRatePerDay;
    double? FixedDays;

    TaskResourcing({this.Positions,this.Equipment,this.Materials,this.ResourcedForQuantity,this.ProductionRatePerDay,this.FixedDays});
    TaskResourcing.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Positions = JsonConverters.fromJson(json['Positions'],'List<ResourcedPosition>',context!);
        Equipment = JsonConverters.fromJson(json['Equipment'],'List<ResourcedEquipment>',context!);
        Materials = JsonConverters.fromJson(json['Materials'],'List<ResourcedMaterial>',context!);
        ResourcedForQuantity = JsonConverters.toDouble(json['ResourcedForQuantity']);
        ProductionRatePerDay = JsonConverters.toDouble(json['ProductionRatePerDay']);
        FixedDays = JsonConverters.toDouble(json['FixedDays']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Positions': JsonConverters.toJson(Positions,'List<ResourcedPosition>',context!),
        'Equipment': JsonConverters.toJson(Equipment,'List<ResourcedEquipment>',context!),
        'Materials': JsonConverters.toJson(Materials,'List<ResourcedMaterial>',context!),
        'ResourcedForQuantity': ResourcedForQuantity,
        'ProductionRatePerDay': ProductionRatePerDay,
        'FixedDays': FixedDays
    };

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

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

    EstimateCrewLineResult({this.Role,this.Hours,this.StHours,this.OtHours,this.Rrop,this.StCost,this.OtCost,this.Cost,this.FringeCost,this.PremiumApplied,this.HasOt,this.NeedsRate});
    EstimateCrewLineResult.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']);
        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']);
        PremiumApplied = json['PremiumApplied'];
        HasOt = json['HasOt'];
        NeedsRate = json['NeedsRate'];
        return this;
    }

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

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

class EstimateEquipmentLineResult 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? RentalExplain;
    double? UsageDays;
    double? BilledDays;

    EstimateEquipmentLineResult({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.RentalExplain,this.UsageDays,this.BilledDays});
    EstimateEquipmentLineResult.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'];
        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,
        'RentalExplain': RentalExplain,
        'UsageDays': UsageDays,
        'BilledDays': BilledDays
    };

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

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

    EstimateMaterialLineResult({this.Name,this.Quantity,this.Unit,this.Rate,this.NeedsRate,this.Cost,this.RateKey});
    EstimateMaterialLineResult.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'];
        return this;
    }

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

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

class EstimateSubcontractLine implements IConvertible
{
    String? Vendor;
    double? Amount;
    String? Scope;

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

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

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

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

class EstimateJobResult implements IConvertible
{
    int? Seq;
    List<int>? DependsOn = [];
    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;
    WorkPackageView? WorkPackage;
    List<EstimateCrewLineResult>? Crew = [];
    List<EstimateEquipmentLineResult>? Equipment = [];
    List<EstimateMaterialLineResult>? Materials = [];
    List<EstimateSubcontractLine>? Subcontracts = [];
    double? CrewCost;
    double? FringeCost;
    double? EquipmentCost;
    double? MaterialCost;
    double? SubcontractCost;
    double? Direct;
    String? PricingBasis;
    String? PricingRuleId;
    double? PricingBandP25;
    double? PricingBandP75;
    int? PricingBandN;
    String? PricingBandLabel;
    double? BenchmarkUnitPrice;
    double? BenchmarkRateMin;
    double? BenchmarkRateMax;
    int? BenchmarkSampleSize;
    double? BenchmarkP25;
    double? BenchmarkP75;
    String? BenchmarkBasis;
    double? UnitPriceOverride;
    String? OverrideBasis;
    double? ReferencePrice;
    double? ReferenceRangeMin;
    double? ReferenceRangeMax;
    int? ReferenceN;
    DateTime? ReferenceDate;
    String? ReferenceBasis;
    String? ReferenceUrl;

    EstimateJobResult({this.Seq,this.DependsOn,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.WorkPackage,this.Crew,this.Equipment,this.Materials,this.Subcontracts,this.CrewCost,this.FringeCost,this.EquipmentCost,this.MaterialCost,this.SubcontractCost,this.Direct,this.PricingBasis,this.PricingRuleId,this.PricingBandP25,this.PricingBandP75,this.PricingBandN,this.PricingBandLabel,this.BenchmarkUnitPrice,this.BenchmarkRateMin,this.BenchmarkRateMax,this.BenchmarkSampleSize,this.BenchmarkP25,this.BenchmarkP75,this.BenchmarkBasis,this.UnitPriceOverride,this.OverrideBasis,this.ReferencePrice,this.ReferenceRangeMin,this.ReferenceRangeMax,this.ReferenceN,this.ReferenceDate,this.ReferenceBasis,this.ReferenceUrl});
    EstimateJobResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Seq = json['Seq'];
        DependsOn = JsonConverters.fromJson(json['DependsOn'],'List<int>',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'];
        WorkPackage = JsonConverters.fromJson(json['WorkPackage'],'WorkPackageView',context!);
        Crew = JsonConverters.fromJson(json['Crew'],'List<EstimateCrewLineResult>',context!);
        Equipment = JsonConverters.fromJson(json['Equipment'],'List<EstimateEquipmentLineResult>',context!);
        Materials = JsonConverters.fromJson(json['Materials'],'List<EstimateMaterialLineResult>',context!);
        Subcontracts = JsonConverters.fromJson(json['Subcontracts'],'List<EstimateSubcontractLine>',context!);
        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'];
        PricingRuleId = json['PricingRuleId'];
        PricingBandP25 = JsonConverters.toDouble(json['PricingBandP25']);
        PricingBandP75 = JsonConverters.toDouble(json['PricingBandP75']);
        PricingBandN = json['PricingBandN'];
        PricingBandLabel = json['PricingBandLabel'];
        BenchmarkUnitPrice = JsonConverters.toDouble(json['BenchmarkUnitPrice']);
        BenchmarkRateMin = JsonConverters.toDouble(json['BenchmarkRateMin']);
        BenchmarkRateMax = JsonConverters.toDouble(json['BenchmarkRateMax']);
        BenchmarkSampleSize = json['BenchmarkSampleSize'];
        BenchmarkP25 = JsonConverters.toDouble(json['BenchmarkP25']);
        BenchmarkP75 = JsonConverters.toDouble(json['BenchmarkP75']);
        BenchmarkBasis = json['BenchmarkBasis'];
        UnitPriceOverride = JsonConverters.toDouble(json['UnitPriceOverride']);
        OverrideBasis = json['OverrideBasis'];
        ReferencePrice = JsonConverters.toDouble(json['ReferencePrice']);
        ReferenceRangeMin = JsonConverters.toDouble(json['ReferenceRangeMin']);
        ReferenceRangeMax = JsonConverters.toDouble(json['ReferenceRangeMax']);
        ReferenceN = json['ReferenceN'];
        ReferenceDate = JsonConverters.fromJson(json['ReferenceDate'],'DateTime',context!);
        ReferenceBasis = json['ReferenceBasis'];
        ReferenceUrl = json['ReferenceUrl'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Seq': Seq,
        'DependsOn': JsonConverters.toJson(DependsOn,'List<int>',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,
        'WorkPackage': JsonConverters.toJson(WorkPackage,'WorkPackageView',context!),
        'Crew': JsonConverters.toJson(Crew,'List<EstimateCrewLineResult>',context!),
        'Equipment': JsonConverters.toJson(Equipment,'List<EstimateEquipmentLineResult>',context!),
        'Materials': JsonConverters.toJson(Materials,'List<EstimateMaterialLineResult>',context!),
        'Subcontracts': JsonConverters.toJson(Subcontracts,'List<EstimateSubcontractLine>',context!),
        'CrewCost': CrewCost,
        'FringeCost': FringeCost,
        'EquipmentCost': EquipmentCost,
        'MaterialCost': MaterialCost,
        'SubcontractCost': SubcontractCost,
        'Direct': Direct,
        'PricingBasis': PricingBasis,
        'PricingRuleId': PricingRuleId,
        'PricingBandP25': PricingBandP25,
        'PricingBandP75': PricingBandP75,
        'PricingBandN': PricingBandN,
        'PricingBandLabel': PricingBandLabel,
        'BenchmarkUnitPrice': BenchmarkUnitPrice,
        'BenchmarkRateMin': BenchmarkRateMin,
        'BenchmarkRateMax': BenchmarkRateMax,
        'BenchmarkSampleSize': BenchmarkSampleSize,
        'BenchmarkP25': BenchmarkP25,
        'BenchmarkP75': BenchmarkP75,
        'BenchmarkBasis': BenchmarkBasis,
        'UnitPriceOverride': UnitPriceOverride,
        'OverrideBasis': OverrideBasis,
        'ReferencePrice': ReferencePrice,
        'ReferenceRangeMin': ReferenceRangeMin,
        'ReferenceRangeMax': ReferenceRangeMax,
        'ReferenceN': ReferenceN,
        'ReferenceDate': JsonConverters.toJson(ReferenceDate,'DateTime',context!),
        'ReferenceBasis': ReferenceBasis,
        'ReferenceUrl': ReferenceUrl
    };

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

class ApplyAssemblyResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    int? TaskSeq;
    String? TemplateUID;
    String? TemplateName;
    double? Quantity;
    String? Unit;
    TaskResourcing? Resourcing;
    EstimateJobResult? Job;
    String? Headline;

    ApplyAssemblyResponse({this.ResponseStatus,this.TaskSeq,this.TemplateUID,this.TemplateName,this.Quantity,this.Unit,this.Resourcing,this.Job,this.Headline});
    ApplyAssemblyResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        TaskSeq = json['TaskSeq'];
        TemplateUID = json['TemplateUID'];
        TemplateName = json['TemplateName'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        Unit = json['Unit'];
        Resourcing = JsonConverters.fromJson(json['Resourcing'],'TaskResourcing',context!);
        Job = JsonConverters.fromJson(json['Job'],'EstimateJobResult',context!);
        Headline = json['Headline'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!),
        'TaskSeq': TaskSeq,
        'TemplateUID': TemplateUID,
        'TemplateName': TemplateName,
        'Quantity': Quantity,
        'Unit': Unit,
        'Resourcing': JsonConverters.toJson(Resourcing,'TaskResourcing',context!),
        'Job': JsonConverters.toJson(Job,'EstimateJobResult',context!),
        'Headline': Headline
    };

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

// @Route("/v1/Rfp/{RfpDocumentUID}/Estimate/Jobs/{TaskSeq}/assembly", "POST,OPTIONS")
class ApplyAssemblyRequest implements IReturn<ApplyAssemblyResponse>, IConvertible, IPost
{
    String? RfpDocumentUID;
    int? TaskSeq;
    String? TemplateUID;

    ApplyAssemblyRequest({this.RfpDocumentUID,this.TaskSeq,this.TemplateUID});
    ApplyAssemblyRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'RfpDocumentUID': RfpDocumentUID,
        'TaskSeq': TaskSeq,
        'TemplateUID': TemplateUID
    };

    createResponse() => ApplyAssemblyResponse();
    getResponseTypeName() => "ApplyAssemblyResponse";
    getTypeName() => "ApplyAssemblyRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    '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>[]),
    'ResourcedPosition': TypeInfo(TypeOf.Class, create:() => ResourcedPosition()),
    'ResourcedEquipment': TypeInfo(TypeOf.Class, create:() => ResourcedEquipment()),
    'ResourcedMaterial': TypeInfo(TypeOf.Class, create:() => ResourcedMaterial()),
    'TaskResourcing': TypeInfo(TypeOf.Class, create:() => TaskResourcing()),
    'List<ResourcedPosition>': TypeInfo(TypeOf.Class, create:() => <ResourcedPosition>[]),
    'List<ResourcedEquipment>': TypeInfo(TypeOf.Class, create:() => <ResourcedEquipment>[]),
    'List<ResourcedMaterial>': TypeInfo(TypeOf.Class, create:() => <ResourcedMaterial>[]),
    'EstimateCrewLineResult': TypeInfo(TypeOf.Class, create:() => EstimateCrewLineResult()),
    'EstimateEquipmentLineResult': TypeInfo(TypeOf.Class, create:() => EstimateEquipmentLineResult()),
    'EstimateMaterialLineResult': TypeInfo(TypeOf.Class, create:() => EstimateMaterialLineResult()),
    'EstimateSubcontractLine': TypeInfo(TypeOf.Class, create:() => EstimateSubcontractLine()),
    'EstimateJobResult': TypeInfo(TypeOf.Class, create:() => EstimateJobResult()),
    'List<EstimateCrewLineResult>': TypeInfo(TypeOf.Class, create:() => <EstimateCrewLineResult>[]),
    'List<EstimateEquipmentLineResult>': TypeInfo(TypeOf.Class, create:() => <EstimateEquipmentLineResult>[]),
    'List<EstimateMaterialLineResult>': TypeInfo(TypeOf.Class, create:() => <EstimateMaterialLineResult>[]),
    'List<EstimateSubcontractLine>': TypeInfo(TypeOf.Class, create:() => <EstimateSubcontractLine>[]),
    'ApplyAssemblyResponse': TypeInfo(TypeOf.Class, create:() => ApplyAssemblyResponse()),
    'ApplyAssemblyRequest': TypeInfo(TypeOf.Class, create:() => ApplyAssemblyRequest()),
});