/* Options:
Date: 2026-07-08 20:18:11
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: RfpRefineRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

class ResourcedPosition implements IConvertible
{
    String? PositionTag;
    double? Hours;
    int? Headcount;
    String? SourceReference;
    String? Notes;
    bool? IsInCatalog;
    int? ContactID;

    ResourcedPosition({this.PositionTag,this.Hours,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']);
        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,
        '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;
    String? SourceReference;
    String? Notes;
    bool? IsInCatalog;
    int? SuggestedEquipmentID;
    String? SuggestedEquipmentName;

    ResourcedEquipment({this.EquipmentID,this.EquipmentName,this.MakeModel,this.Quantity,this.DurationDays,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']);
        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,
        '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;
    String? Unit;
    String? SourceReference;
    String? Notes;
    bool? IsInCatalog;
    int? SuggestedMaterialID;
    String? SuggestedMaterialName;

    ResourcedMaterial({this.MaterialID,this.MaterialName,this.MakeModel,this.Quantity,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']);
        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,
        '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 = [];

    TaskResourcing({this.Positions,this.Equipment,this.Materials});
    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!);
        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!)
    };

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

class ProposedTask implements IConvertible
{
    int? Seq;
    String? Name;
    String? Category;
    double? Quantity;
    String? Unit;
    String? SourceItemNumber;
    String? SourceReference;
    String? Notes;
    TaskResourcing? Resourcing;
    double? DurationDays;
    List<int>? DependsOn = [];
    DateTime? EstimatedStartDate;
    DateTime? EstimatedEndDate;

    ProposedTask({this.Seq,this.Name,this.Category,this.Quantity,this.Unit,this.SourceItemNumber,this.SourceReference,this.Notes,this.Resourcing,this.DurationDays,this.DependsOn,this.EstimatedStartDate,this.EstimatedEndDate});
    ProposedTask.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Seq = json['Seq'];
        Name = json['Name'];
        Category = json['Category'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        Unit = json['Unit'];
        SourceItemNumber = json['SourceItemNumber'];
        SourceReference = json['SourceReference'];
        Notes = json['Notes'];
        Resourcing = JsonConverters.fromJson(json['Resourcing'],'TaskResourcing',context!);
        DurationDays = JsonConverters.toDouble(json['DurationDays']);
        DependsOn = JsonConverters.fromJson(json['DependsOn'],'List<int>',context!);
        EstimatedStartDate = JsonConverters.fromJson(json['EstimatedStartDate'],'DateTime',context!);
        EstimatedEndDate = JsonConverters.fromJson(json['EstimatedEndDate'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Seq': Seq,
        'Name': Name,
        'Category': Category,
        'Quantity': Quantity,
        'Unit': Unit,
        'SourceItemNumber': SourceItemNumber,
        'SourceReference': SourceReference,
        'Notes': Notes,
        'Resourcing': JsonConverters.toJson(Resourcing,'TaskResourcing',context!),
        'DurationDays': DurationDays,
        'DependsOn': JsonConverters.toJson(DependsOn,'List<int>',context!),
        'EstimatedStartDate': JsonConverters.toJson(EstimatedStartDate,'DateTime',context!),
        'EstimatedEndDate': JsonConverters.toJson(EstimatedEndDate,'DateTime',context!)
    };

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

class ProjectProposal implements IConvertible
{
    int? RfpDocumentID;
    String? Mode;
    int? ProjectID;
    int? ChangeOrderID;
    String? ProjectName;
    String? ClientName;
    String? ProjectType;
    String? ProjectLocation;
    String? Scope;
    String? ProjectDescription;
    int? ContractDurationDays;
    String? BidDueDate;
    DateTime? EstimatedStartDate;
    DateTime? EstimatedEndDate;
    List<ProposedTask>? Tasks = [];

    ProjectProposal({this.RfpDocumentID,this.Mode,this.ProjectID,this.ChangeOrderID,this.ProjectName,this.ClientName,this.ProjectType,this.ProjectLocation,this.Scope,this.ProjectDescription,this.ContractDurationDays,this.BidDueDate,this.EstimatedStartDate,this.EstimatedEndDate,this.Tasks});
    ProjectProposal.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RfpDocumentID = json['RfpDocumentID'];
        Mode = json['Mode'];
        ProjectID = json['ProjectID'];
        ChangeOrderID = json['ChangeOrderID'];
        ProjectName = json['ProjectName'];
        ClientName = json['ClientName'];
        ProjectType = json['ProjectType'];
        ProjectLocation = json['ProjectLocation'];
        Scope = json['Scope'];
        ProjectDescription = json['ProjectDescription'];
        ContractDurationDays = json['ContractDurationDays'];
        BidDueDate = json['BidDueDate'];
        EstimatedStartDate = JsonConverters.fromJson(json['EstimatedStartDate'],'DateTime',context!);
        EstimatedEndDate = JsonConverters.fromJson(json['EstimatedEndDate'],'DateTime',context!);
        Tasks = JsonConverters.fromJson(json['Tasks'],'List<ProposedTask>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RfpDocumentID': RfpDocumentID,
        'Mode': Mode,
        'ProjectID': ProjectID,
        'ChangeOrderID': ChangeOrderID,
        'ProjectName': ProjectName,
        'ClientName': ClientName,
        'ProjectType': ProjectType,
        'ProjectLocation': ProjectLocation,
        'Scope': Scope,
        'ProjectDescription': ProjectDescription,
        'ContractDurationDays': ContractDurationDays,
        'BidDueDate': BidDueDate,
        'EstimatedStartDate': JsonConverters.toJson(EstimatedStartDate,'DateTime',context!),
        'EstimatedEndDate': JsonConverters.toJson(EstimatedEndDate,'DateTime',context!),
        'Tasks': JsonConverters.toJson(Tasks,'List<ProposedTask>',context!)
    };

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

class RfpLocation implements IConvertible
{
    String? Description;
    String? City;
    String? State;
    String? Identifier;

    RfpLocation({this.Description,this.City,this.State,this.Identifier});
    RfpLocation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Description = json['Description'];
        City = json['City'];
        State = json['State'];
        Identifier = json['Identifier'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Description': Description,
        'City': City,
        'State': State,
        'Identifier': Identifier
    };

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

class RfpSchedule implements IConvertible
{
    String? BidDueDate;
    String? EstimatedStartDate;
    String? QuestionsDueDate;
    int? ContractDurationDays;
    String? Notes;

    RfpSchedule({this.BidDueDate,this.EstimatedStartDate,this.QuestionsDueDate,this.ContractDurationDays,this.Notes});
    RfpSchedule.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        BidDueDate = json['BidDueDate'];
        EstimatedStartDate = json['EstimatedStartDate'];
        QuestionsDueDate = json['QuestionsDueDate'];
        ContractDurationDays = json['ContractDurationDays'];
        Notes = json['Notes'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'BidDueDate': BidDueDate,
        'EstimatedStartDate': EstimatedStartDate,
        'QuestionsDueDate': QuestionsDueDate,
        'ContractDurationDays': ContractDurationDays,
        'Notes': Notes
    };

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

class RfpLineItem implements IConvertible
{
    String? ItemNumber;
    String? Description;
    double? Quantity;
    String? Unit;
    String? Category;
    String? SourceReference;

    RfpLineItem({this.ItemNumber,this.Description,this.Quantity,this.Unit,this.Category,this.SourceReference});
    RfpLineItem.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ItemNumber = json['ItemNumber'];
        Description = json['Description'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        Unit = json['Unit'];
        Category = json['Category'];
        SourceReference = json['SourceReference'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ItemNumber': ItemNumber,
        'Description': Description,
        'Quantity': Quantity,
        'Unit': Unit,
        'Category': Category,
        'SourceReference': SourceReference
    };

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

class RfpBidConstraint implements IConvertible
{
    String? Constraint;
    String? Detail;

    RfpBidConstraint({this.Constraint,this.Detail});
    RfpBidConstraint.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Constraint': Constraint,
        'Detail': Detail
    };

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

class RfpBrief implements IConvertible
{
    String? ProjectTitle;
    String? SolicitationNumber;
    String? IssuingOrganization;
    String? ProjectType;
    String? Summary;
    List<RfpLocation>? Locations = [];
    RfpSchedule? Schedule;
    List<RfpLineItem>? LineItems = [];
    List<RfpBidConstraint>? BidConstraints = [];
    List<String>? SpecialRequirements = [];

    RfpBrief({this.ProjectTitle,this.SolicitationNumber,this.IssuingOrganization,this.ProjectType,this.Summary,this.Locations,this.Schedule,this.LineItems,this.BidConstraints,this.SpecialRequirements});
    RfpBrief.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ProjectTitle = json['ProjectTitle'];
        SolicitationNumber = json['SolicitationNumber'];
        IssuingOrganization = json['IssuingOrganization'];
        ProjectType = json['ProjectType'];
        Summary = json['Summary'];
        Locations = JsonConverters.fromJson(json['Locations'],'List<RfpLocation>',context!);
        Schedule = JsonConverters.fromJson(json['Schedule'],'RfpSchedule',context!);
        LineItems = JsonConverters.fromJson(json['LineItems'],'List<RfpLineItem>',context!);
        BidConstraints = JsonConverters.fromJson(json['BidConstraints'],'List<RfpBidConstraint>',context!);
        SpecialRequirements = JsonConverters.fromJson(json['SpecialRequirements'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ProjectTitle': ProjectTitle,
        'SolicitationNumber': SolicitationNumber,
        'IssuingOrganization': IssuingOrganization,
        'ProjectType': ProjectType,
        'Summary': Summary,
        'Locations': JsonConverters.toJson(Locations,'List<RfpLocation>',context!),
        'Schedule': JsonConverters.toJson(Schedule,'RfpSchedule',context!),
        'LineItems': JsonConverters.toJson(LineItems,'List<RfpLineItem>',context!),
        'BidConstraints': JsonConverters.toJson(BidConstraints,'List<RfpBidConstraint>',context!),
        'SpecialRequirements': JsonConverters.toJson(SpecialRequirements,'List<String>',context!)
    };

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

class CrewPlanLine implements IConvertible
{
    String? PositionTag;
    int? Needed;
    int? NaiveTotal;
    int? TaskAssignments;

    CrewPlanLine({this.PositionTag,this.Needed,this.NaiveTotal,this.TaskAssignments});
    CrewPlanLine.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PositionTag = json['PositionTag'];
        Needed = json['Needed'];
        NaiveTotal = json['NaiveTotal'];
        TaskAssignments = json['TaskAssignments'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PositionTag': PositionTag,
        'Needed': Needed,
        'NaiveTotal': NaiveTotal,
        'TaskAssignments': TaskAssignments
    };

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

class CostRange implements IConvertible
{
    double? Min;
    double? Max;
    double? Mid;

    CostRange({this.Min,this.Max,this.Mid});
    CostRange.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Min': Min,
        'Max': Max,
        'Mid': Mid
    };

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

class PricedPosition implements IConvertible
{
    String? PositionTag;
    double? Hours;
    bool? HasInternalRate;
    double? RateMin;
    double? RateMax;
    double? RateAvg;
    int? ContactCount;
    CostRange? Cost;
    double? MarketRateReference;

    PricedPosition({this.PositionTag,this.Hours,this.HasInternalRate,this.RateMin,this.RateMax,this.RateAvg,this.ContactCount,this.Cost,this.MarketRateReference});
    PricedPosition.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PositionTag = json['PositionTag'];
        Hours = JsonConverters.toDouble(json['Hours']);
        HasInternalRate = json['HasInternalRate'];
        RateMin = JsonConverters.toDouble(json['RateMin']);
        RateMax = JsonConverters.toDouble(json['RateMax']);
        RateAvg = JsonConverters.toDouble(json['RateAvg']);
        ContactCount = json['ContactCount'];
        Cost = JsonConverters.fromJson(json['Cost'],'CostRange',context!);
        MarketRateReference = JsonConverters.toDouble(json['MarketRateReference']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PositionTag': PositionTag,
        'Hours': Hours,
        'HasInternalRate': HasInternalRate,
        'RateMin': RateMin,
        'RateMax': RateMax,
        'RateAvg': RateAvg,
        'ContactCount': ContactCount,
        'Cost': JsonConverters.toJson(Cost,'CostRange',context!),
        'MarketRateReference': MarketRateReference
    };

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

class PricedEquipment implements IConvertible
{
    int? EquipmentID;
    String? EquipmentName;
    double? Quantity;
    double? DurationDays;
    String? RateType;
    double? BilledRate;
    double? CostRate;
    bool? HasRate;
    bool? IsInCatalog;
    double? Cost;
    double? CompanyCost;
    double? Margin;

    PricedEquipment({this.EquipmentID,this.EquipmentName,this.Quantity,this.DurationDays,this.RateType,this.BilledRate,this.CostRate,this.HasRate,this.IsInCatalog,this.Cost,this.CompanyCost,this.Margin});
    PricedEquipment.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        EquipmentID = json['EquipmentID'];
        EquipmentName = json['EquipmentName'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        DurationDays = JsonConverters.toDouble(json['DurationDays']);
        RateType = json['RateType'];
        BilledRate = JsonConverters.toDouble(json['BilledRate']);
        CostRate = JsonConverters.toDouble(json['CostRate']);
        HasRate = json['HasRate'];
        IsInCatalog = json['IsInCatalog'];
        Cost = JsonConverters.toDouble(json['Cost']);
        CompanyCost = JsonConverters.toDouble(json['CompanyCost']);
        Margin = JsonConverters.toDouble(json['Margin']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'EquipmentID': EquipmentID,
        'EquipmentName': EquipmentName,
        'Quantity': Quantity,
        'DurationDays': DurationDays,
        'RateType': RateType,
        'BilledRate': BilledRate,
        'CostRate': CostRate,
        'HasRate': HasRate,
        'IsInCatalog': IsInCatalog,
        'Cost': Cost,
        'CompanyCost': CompanyCost,
        'Margin': Margin
    };

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

class PricedMaterial implements IConvertible
{
    int? MaterialID;
    String? MaterialName;
    double? Quantity;
    double? UnitCost;
    bool? HasRate;
    bool? IsInCatalog;
    double? Cost;

    PricedMaterial({this.MaterialID,this.MaterialName,this.Quantity,this.UnitCost,this.HasRate,this.IsInCatalog,this.Cost});
    PricedMaterial.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        MaterialID = json['MaterialID'];
        MaterialName = json['MaterialName'];
        Quantity = JsonConverters.toDouble(json['Quantity']);
        UnitCost = JsonConverters.toDouble(json['UnitCost']);
        HasRate = json['HasRate'];
        IsInCatalog = json['IsInCatalog'];
        Cost = JsonConverters.toDouble(json['Cost']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'MaterialID': MaterialID,
        'MaterialName': MaterialName,
        'Quantity': Quantity,
        'UnitCost': UnitCost,
        'HasRate': HasRate,
        'IsInCatalog': IsInCatalog,
        'Cost': Cost
    };

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

class PricedTask implements IConvertible
{
    String? Name;
    String? Category;
    List<PricedPosition>? Positions = [];
    List<PricedEquipment>? Equipment = [];
    List<PricedMaterial>? Materials = [];
    CostRange? Subtotal;

    PricedTask({this.Name,this.Category,this.Positions,this.Equipment,this.Materials,this.Subtotal});
    PricedTask.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Name = json['Name'];
        Category = json['Category'];
        Positions = JsonConverters.fromJson(json['Positions'],'List<PricedPosition>',context!);
        Equipment = JsonConverters.fromJson(json['Equipment'],'List<PricedEquipment>',context!);
        Materials = JsonConverters.fromJson(json['Materials'],'List<PricedMaterial>',context!);
        Subtotal = JsonConverters.fromJson(json['Subtotal'],'CostRange',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Name': Name,
        'Category': Category,
        'Positions': JsonConverters.toJson(Positions,'List<PricedPosition>',context!),
        'Equipment': JsonConverters.toJson(Equipment,'List<PricedEquipment>',context!),
        'Materials': JsonConverters.toJson(Materials,'List<PricedMaterial>',context!),
        'Subtotal': JsonConverters.toJson(Subtotal,'CostRange',context!)
    };

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

class PricedProposal implements IConvertible
{
    int? RfpDocumentID;
    String? ProjectName;
    String? Currency;
    List<PricedTask>? Tasks = [];
    CostRange? Total;
    int? PositionsNeedingRate;
    int? EquipmentNotInCatalog;
    int? MaterialsNotInCatalog;
    int? PositionsNotInCatalog;
    double? EquipmentMargin;

    PricedProposal({this.RfpDocumentID,this.ProjectName,this.Currency,this.Tasks,this.Total,this.PositionsNeedingRate,this.EquipmentNotInCatalog,this.MaterialsNotInCatalog,this.PositionsNotInCatalog,this.EquipmentMargin});
    PricedProposal.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RfpDocumentID = json['RfpDocumentID'];
        ProjectName = json['ProjectName'];
        Currency = json['Currency'];
        Tasks = JsonConverters.fromJson(json['Tasks'],'List<PricedTask>',context!);
        Total = JsonConverters.fromJson(json['Total'],'CostRange',context!);
        PositionsNeedingRate = json['PositionsNeedingRate'];
        EquipmentNotInCatalog = json['EquipmentNotInCatalog'];
        MaterialsNotInCatalog = json['MaterialsNotInCatalog'];
        PositionsNotInCatalog = json['PositionsNotInCatalog'];
        EquipmentMargin = JsonConverters.toDouble(json['EquipmentMargin']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RfpDocumentID': RfpDocumentID,
        'ProjectName': ProjectName,
        'Currency': Currency,
        'Tasks': JsonConverters.toJson(Tasks,'List<PricedTask>',context!),
        'Total': JsonConverters.toJson(Total,'CostRange',context!),
        'PositionsNeedingRate': PositionsNeedingRate,
        'EquipmentNotInCatalog': EquipmentNotInCatalog,
        'MaterialsNotInCatalog': MaterialsNotInCatalog,
        'PositionsNotInCatalog': PositionsNotInCatalog,
        'EquipmentMargin': EquipmentMargin
    };

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

class RfpRefineResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    int? RfpDocumentID;
    String? Layer;
    String? Mode;
    int? TurnCount;
    RfpBrief? Brief;
    ProjectProposal? Proposal;
    PricedProposal? Pricing;
    List<CrewPlanLine>? CrewPlan = [];
    int? CacheReadTokens;
    int? CacheCreationTokens;
    int? InputTokens;

    RfpRefineResponse({this.ResponseStatus,this.RfpDocumentID,this.Layer,this.Mode,this.TurnCount,this.Brief,this.Proposal,this.Pricing,this.CrewPlan,this.CacheReadTokens,this.CacheCreationTokens,this.InputTokens});
    RfpRefineResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        RfpDocumentID = json['RfpDocumentID'];
        Layer = json['Layer'];
        Mode = json['Mode'];
        TurnCount = json['TurnCount'];
        Brief = JsonConverters.fromJson(json['Brief'],'RfpBrief',context!);
        Proposal = JsonConverters.fromJson(json['Proposal'],'ProjectProposal',context!);
        Pricing = JsonConverters.fromJson(json['Pricing'],'PricedProposal',context!);
        CrewPlan = JsonConverters.fromJson(json['CrewPlan'],'List<CrewPlanLine>',context!);
        CacheReadTokens = json['CacheReadTokens'];
        CacheCreationTokens = json['CacheCreationTokens'];
        InputTokens = json['InputTokens'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!),
        'RfpDocumentID': RfpDocumentID,
        'Layer': Layer,
        'Mode': Mode,
        'TurnCount': TurnCount,
        'Brief': JsonConverters.toJson(Brief,'RfpBrief',context!),
        'Proposal': JsonConverters.toJson(Proposal,'ProjectProposal',context!),
        'Pricing': JsonConverters.toJson(Pricing,'PricedProposal',context!),
        'CrewPlan': JsonConverters.toJson(CrewPlan,'List<CrewPlanLine>',context!),
        'CacheReadTokens': CacheReadTokens,
        'CacheCreationTokens': CacheCreationTokens,
        'InputTokens': InputTokens
    };

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

// @Route("/v1/Rfp/{RfpDocumentUID}/Refine", "POST,OPTIONS")
class RfpRefineRequest implements IReturn<RfpRefineResponse>, IConvertible, IPost
{
    String? RfpDocumentUID;
    String? Layer;
    String? Mode;
    String? Instruction;

    RfpRefineRequest({this.RfpDocumentUID,this.Layer,this.Mode,this.Instruction});
    RfpRefineRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'RfpDocumentUID': RfpDocumentUID,
        'Layer': Layer,
        'Mode': Mode,
        'Instruction': Instruction
    };

    createResponse() => RfpRefineResponse();
    getResponseTypeName() => "RfpRefineResponse";
    getTypeName() => "RfpRefineRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    '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>[]),
    'ProposedTask': TypeInfo(TypeOf.Class, create:() => ProposedTask()),
    'ProjectProposal': TypeInfo(TypeOf.Class, create:() => ProjectProposal()),
    'List<ProposedTask>': TypeInfo(TypeOf.Class, create:() => <ProposedTask>[]),
    'RfpLocation': TypeInfo(TypeOf.Class, create:() => RfpLocation()),
    'RfpSchedule': TypeInfo(TypeOf.Class, create:() => RfpSchedule()),
    'RfpLineItem': TypeInfo(TypeOf.Class, create:() => RfpLineItem()),
    'RfpBidConstraint': TypeInfo(TypeOf.Class, create:() => RfpBidConstraint()),
    'RfpBrief': TypeInfo(TypeOf.Class, create:() => RfpBrief()),
    'List<RfpLocation>': TypeInfo(TypeOf.Class, create:() => <RfpLocation>[]),
    'List<RfpLineItem>': TypeInfo(TypeOf.Class, create:() => <RfpLineItem>[]),
    'List<RfpBidConstraint>': TypeInfo(TypeOf.Class, create:() => <RfpBidConstraint>[]),
    'CrewPlanLine': TypeInfo(TypeOf.Class, create:() => CrewPlanLine()),
    'CostRange': TypeInfo(TypeOf.Class, create:() => CostRange()),
    'PricedPosition': TypeInfo(TypeOf.Class, create:() => PricedPosition()),
    'PricedEquipment': TypeInfo(TypeOf.Class, create:() => PricedEquipment()),
    'PricedMaterial': TypeInfo(TypeOf.Class, create:() => PricedMaterial()),
    'PricedTask': TypeInfo(TypeOf.Class, create:() => PricedTask()),
    'List<PricedPosition>': TypeInfo(TypeOf.Class, create:() => <PricedPosition>[]),
    'List<PricedEquipment>': TypeInfo(TypeOf.Class, create:() => <PricedEquipment>[]),
    'List<PricedMaterial>': TypeInfo(TypeOf.Class, create:() => <PricedMaterial>[]),
    'PricedProposal': TypeInfo(TypeOf.Class, create:() => PricedProposal()),
    'List<PricedTask>': TypeInfo(TypeOf.Class, create:() => <PricedTask>[]),
    'RfpRefineResponse': TypeInfo(TypeOf.Class, create:() => RfpRefineResponse()),
    'List<CrewPlanLine>': TypeInfo(TypeOf.Class, create:() => <CrewPlanLine>[]),
    'RfpRefineRequest': TypeInfo(TypeOf.Class, create:() => RfpRefineRequest()),
});