/* Options:
Date: 2026-08-01 10:03: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: RfpApproveRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

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

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 WorkPackageSpecRef implements IConvertible
{
    String? Section;
    String? Title;

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

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

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

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

class TaskWorkPackage implements IConvertible
{
    String? Scope;
    String? LimitsOfWork;
    List<WorkPackageSpecRef>? SpecRefs = [];
    List<String>? Constraints = [];
    List<String>? HoldPoints = [];
    List<String>? DefinitionOfDone = [];
    String? SafetyNote;
    String? RfpRef;
    int? Confidence;
    String? SpecBook;
    String? UserScope;
    List<int>? DodRemoved = [];
    List<String>? DodExtra = [];
    bool? UserEdited;
    List<String>? DodChecked = [];
    String? RedraftNote;

    TaskWorkPackage({this.Scope,this.LimitsOfWork,this.SpecRefs,this.Constraints,this.HoldPoints,this.DefinitionOfDone,this.SafetyNote,this.RfpRef,this.Confidence,this.SpecBook,this.UserScope,this.DodRemoved,this.DodExtra,this.UserEdited,this.DodChecked,this.RedraftNote});
    TaskWorkPackage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Scope = json['Scope'];
        LimitsOfWork = json['LimitsOfWork'];
        SpecRefs = JsonConverters.fromJson(json['SpecRefs'],'List<WorkPackageSpecRef>',context!);
        Constraints = JsonConverters.fromJson(json['Constraints'],'List<String>',context!);
        HoldPoints = JsonConverters.fromJson(json['HoldPoints'],'List<String>',context!);
        DefinitionOfDone = JsonConverters.fromJson(json['DefinitionOfDone'],'List<String>',context!);
        SafetyNote = json['SafetyNote'];
        RfpRef = json['RfpRef'];
        Confidence = json['Confidence'];
        SpecBook = json['SpecBook'];
        UserScope = json['UserScope'];
        DodRemoved = JsonConverters.fromJson(json['DodRemoved'],'List<int>',context!);
        DodExtra = JsonConverters.fromJson(json['DodExtra'],'List<String>',context!);
        UserEdited = json['UserEdited'];
        DodChecked = JsonConverters.fromJson(json['DodChecked'],'List<String>',context!);
        RedraftNote = json['RedraftNote'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Scope': Scope,
        'LimitsOfWork': LimitsOfWork,
        'SpecRefs': JsonConverters.toJson(SpecRefs,'List<WorkPackageSpecRef>',context!),
        'Constraints': JsonConverters.toJson(Constraints,'List<String>',context!),
        'HoldPoints': JsonConverters.toJson(HoldPoints,'List<String>',context!),
        'DefinitionOfDone': JsonConverters.toJson(DefinitionOfDone,'List<String>',context!),
        'SafetyNote': SafetyNote,
        'RfpRef': RfpRef,
        'Confidence': Confidence,
        'SpecBook': SpecBook,
        'UserScope': UserScope,
        'DodRemoved': JsonConverters.toJson(DodRemoved,'List<int>',context!),
        'DodExtra': JsonConverters.toJson(DodExtra,'List<String>',context!),
        'UserEdited': UserEdited,
        'DodChecked': JsonConverters.toJson(DodChecked,'List<String>',context!),
        'RedraftNote': RedraftNote
    };

    getTypeName() => "TaskWorkPackage";
    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;
    TaskWorkPackage? WorkPackage;
    int? CreatedJobID;

    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,this.WorkPackage,this.CreatedJobID});
    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!);
        WorkPackage = JsonConverters.fromJson(json['WorkPackage'],'TaskWorkPackage',context!);
        CreatedJobID = json['CreatedJobID'];
        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!),
        'WorkPackage': JsonConverters.toJson(WorkPackage,'TaskWorkPackage',context!),
        'CreatedJobID': CreatedJobID
    };

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

class AddendaChange implements IConvertible
{
    String? ChangeId;
    String? ChangeType;
    int? TargetSeq;
    String? ItemNumber;
    String? ItemName;
    String? Field;
    String? OldValue;
    String? NewValue;
    String? Description;
    String? Status;

    AddendaChange({this.ChangeId,this.ChangeType,this.TargetSeq,this.ItemNumber,this.ItemName,this.Field,this.OldValue,this.NewValue,this.Description,this.Status});
    AddendaChange.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ChangeId = json['ChangeId'];
        ChangeType = json['ChangeType'];
        TargetSeq = json['TargetSeq'];
        ItemNumber = json['ItemNumber'];
        ItemName = json['ItemName'];
        Field = json['Field'];
        OldValue = json['OldValue'];
        NewValue = json['NewValue'];
        Description = json['Description'];
        Status = json['Status'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ChangeId': ChangeId,
        'ChangeType': ChangeType,
        'TargetSeq': TargetSeq,
        'ItemNumber': ItemNumber,
        'ItemName': ItemName,
        'Field': Field,
        'OldValue': OldValue,
        'NewValue': NewValue,
        'Description': Description,
        'Status': Status
    };

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

class AddendaChangeSet implements IConvertible
{
    String? ChangeSetId;
    int? SourceRfpDocumentID;
    String? SourceFileName;
    String? DocumentType;
    DateTime? ExtractedAtUtc;
    String? Summary;
    List<AddendaChange>? Changes = [];

    AddendaChangeSet({this.ChangeSetId,this.SourceRfpDocumentID,this.SourceFileName,this.DocumentType,this.ExtractedAtUtc,this.Summary,this.Changes});
    AddendaChangeSet.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ChangeSetId = json['ChangeSetId'];
        SourceRfpDocumentID = json['SourceRfpDocumentID'];
        SourceFileName = json['SourceFileName'];
        DocumentType = json['DocumentType'];
        ExtractedAtUtc = JsonConverters.fromJson(json['ExtractedAtUtc'],'DateTime',context!);
        Summary = json['Summary'];
        Changes = JsonConverters.fromJson(json['Changes'],'List<AddendaChange>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ChangeSetId': ChangeSetId,
        'SourceRfpDocumentID': SourceRfpDocumentID,
        'SourceFileName': SourceFileName,
        'DocumentType': DocumentType,
        'ExtractedAtUtc': JsonConverters.toJson(ExtractedAtUtc,'DateTime',context!),
        'Summary': Summary,
        'Changes': JsonConverters.toJson(Changes,'List<AddendaChange>',context!)
    };

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

class WageClassification implements IConvertible
{
    String? Title;
    double? BaseRate;
    double? FringeRate;
    String? ParishNote;
    String? SourceLine;
    double? BenchmarkFringeRate;
    String? FringeCompareNote;

    WageClassification({this.Title,this.BaseRate,this.FringeRate,this.ParishNote,this.SourceLine,this.BenchmarkFringeRate,this.FringeCompareNote});
    WageClassification.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Title = json['Title'];
        BaseRate = JsonConverters.toDouble(json['BaseRate']);
        FringeRate = JsonConverters.toDouble(json['FringeRate']);
        ParishNote = json['ParishNote'];
        SourceLine = json['SourceLine'];
        BenchmarkFringeRate = JsonConverters.toDouble(json['BenchmarkFringeRate']);
        FringeCompareNote = json['FringeCompareNote'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Title': Title,
        'BaseRate': BaseRate,
        'FringeRate': FringeRate,
        'ParishNote': ParishNote,
        'SourceLine': SourceLine,
        'BenchmarkFringeRate': BenchmarkFringeRate,
        'FringeCompareNote': FringeCompareNote
    };

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

class WageDeterminationResult implements IConvertible
{
    int? SourceRfpDocumentID;
    String? SourceFileName;
    String? WdNumber;
    DateTime? ExtractedAtUtc;
    List<WageClassification>? Classifications = [];
    String? Source;
    bool? IsTrustworthy;
    double? ExecutiveOrderFloor;
    String? PublishedDate;
    String? ProjectParish;
    List<String>? Warnings = [];

    WageDeterminationResult({this.SourceRfpDocumentID,this.SourceFileName,this.WdNumber,this.ExtractedAtUtc,this.Classifications,this.Source,this.IsTrustworthy,this.ExecutiveOrderFloor,this.PublishedDate,this.ProjectParish,this.Warnings});
    WageDeterminationResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        SourceRfpDocumentID = json['SourceRfpDocumentID'];
        SourceFileName = json['SourceFileName'];
        WdNumber = json['WdNumber'];
        ExtractedAtUtc = JsonConverters.fromJson(json['ExtractedAtUtc'],'DateTime',context!);
        Classifications = JsonConverters.fromJson(json['Classifications'],'List<WageClassification>',context!);
        Source = json['Source'];
        IsTrustworthy = json['IsTrustworthy'];
        ExecutiveOrderFloor = JsonConverters.toDouble(json['ExecutiveOrderFloor']);
        PublishedDate = json['PublishedDate'];
        ProjectParish = json['ProjectParish'];
        Warnings = JsonConverters.fromJson(json['Warnings'],'List<String>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'SourceRfpDocumentID': SourceRfpDocumentID,
        'SourceFileName': SourceFileName,
        'WdNumber': WdNumber,
        'ExtractedAtUtc': JsonConverters.toJson(ExtractedAtUtc,'DateTime',context!),
        'Classifications': JsonConverters.toJson(Classifications,'List<WageClassification>',context!),
        'Source': Source,
        'IsTrustworthy': IsTrustworthy,
        'ExecutiveOrderFloor': ExecutiveOrderFloor,
        'PublishedDate': PublishedDate,
        'ProjectParish': ProjectParish,
        'Warnings': JsonConverters.toJson(Warnings,'List<String>',context!)
    };

    getTypeName() => "WageDeterminationResult";
    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 = [];
    List<AddendaChangeSet>? PendingAddendaDiffs = [];
    List<WageDeterminationResult>? WageDeterminations = [];

    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,this.PendingAddendaDiffs,this.WageDeterminations});
    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!);
        PendingAddendaDiffs = JsonConverters.fromJson(json['PendingAddendaDiffs'],'List<AddendaChangeSet>',context!);
        WageDeterminations = JsonConverters.fromJson(json['WageDeterminations'],'List<WageDeterminationResult>',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!),
        'PendingAddendaDiffs': JsonConverters.toJson(PendingAddendaDiffs,'List<AddendaChangeSet>',context!),
        'WageDeterminations': JsonConverters.toJson(WageDeterminations,'List<WageDeterminationResult>',context!)
    };

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

class TaskDiff implements IConvertible
{
    String? TaskName;
    List<String>? PositionsAdded = [];
    List<String>? PositionsRemoved = [];
    List<String>? PositionsStaffed = [];
    List<int>? EquipmentAdded = [];
    List<int>? EquipmentRemoved = [];
    List<int>? MaterialsAdded = [];
    List<int>? MaterialsRemoved = [];
    bool? HasChanges;

    TaskDiff({this.TaskName,this.PositionsAdded,this.PositionsRemoved,this.PositionsStaffed,this.EquipmentAdded,this.EquipmentRemoved,this.MaterialsAdded,this.MaterialsRemoved,this.HasChanges});
    TaskDiff.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TaskName = json['TaskName'];
        PositionsAdded = JsonConverters.fromJson(json['PositionsAdded'],'List<String>',context!);
        PositionsRemoved = JsonConverters.fromJson(json['PositionsRemoved'],'List<String>',context!);
        PositionsStaffed = JsonConverters.fromJson(json['PositionsStaffed'],'List<String>',context!);
        EquipmentAdded = JsonConverters.fromJson(json['EquipmentAdded'],'List<int>',context!);
        EquipmentRemoved = JsonConverters.fromJson(json['EquipmentRemoved'],'List<int>',context!);
        MaterialsAdded = JsonConverters.fromJson(json['MaterialsAdded'],'List<int>',context!);
        MaterialsRemoved = JsonConverters.fromJson(json['MaterialsRemoved'],'List<int>',context!);
        HasChanges = json['HasChanges'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TaskName': TaskName,
        'PositionsAdded': JsonConverters.toJson(PositionsAdded,'List<String>',context!),
        'PositionsRemoved': JsonConverters.toJson(PositionsRemoved,'List<String>',context!),
        'PositionsStaffed': JsonConverters.toJson(PositionsStaffed,'List<String>',context!),
        'EquipmentAdded': JsonConverters.toJson(EquipmentAdded,'List<int>',context!),
        'EquipmentRemoved': JsonConverters.toJson(EquipmentRemoved,'List<int>',context!),
        'MaterialsAdded': JsonConverters.toJson(MaterialsAdded,'List<int>',context!),
        'MaterialsRemoved': JsonConverters.toJson(MaterialsRemoved,'List<int>',context!),
        'HasChanges': HasChanges
    };

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

class ProposalDiff implements IConvertible
{
    List<String>? TasksAdded = [];
    List<String>? TasksRemoved = [];
    List<TaskDiff>? Tasks = [];
    bool? HasChanges;

    ProposalDiff({this.TasksAdded,this.TasksRemoved,this.Tasks,this.HasChanges});
    ProposalDiff.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TasksAdded = JsonConverters.fromJson(json['TasksAdded'],'List<String>',context!);
        TasksRemoved = JsonConverters.fromJson(json['TasksRemoved'],'List<String>',context!);
        Tasks = JsonConverters.fromJson(json['Tasks'],'List<TaskDiff>',context!);
        HasChanges = json['HasChanges'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TasksAdded': JsonConverters.toJson(TasksAdded,'List<String>',context!),
        'TasksRemoved': JsonConverters.toJson(TasksRemoved,'List<String>',context!),
        'Tasks': JsonConverters.toJson(Tasks,'List<TaskDiff>',context!),
        'HasChanges': HasChanges
    };

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

class RfpApproveResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    int? RfpDocumentID;
    int? ProjectID;
    String? ProjectUID;
    int? RfpApprovalID;
    List<int>? JobIDs = [];
    int? OpenPositionCount;
    ProposalDiff? Diff;

    RfpApproveResponse({this.ResponseStatus,this.RfpDocumentID,this.ProjectID,this.ProjectUID,this.RfpApprovalID,this.JobIDs,this.OpenPositionCount,this.Diff});
    RfpApproveResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        RfpDocumentID = json['RfpDocumentID'];
        ProjectID = json['ProjectID'];
        ProjectUID = json['ProjectUID'];
        RfpApprovalID = json['RfpApprovalID'];
        JobIDs = JsonConverters.fromJson(json['JobIDs'],'List<int>',context!);
        OpenPositionCount = json['OpenPositionCount'];
        Diff = JsonConverters.fromJson(json['Diff'],'ProposalDiff',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!),
        'RfpDocumentID': RfpDocumentID,
        'ProjectID': ProjectID,
        'ProjectUID': ProjectUID,
        'RfpApprovalID': RfpApprovalID,
        'JobIDs': JsonConverters.toJson(JobIDs,'List<int>',context!),
        'OpenPositionCount': OpenPositionCount,
        'Diff': JsonConverters.toJson(Diff,'ProposalDiff',context!)
    };

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

// @Route("/v1/Rfp/{RfpDocumentUID}/Approve", "POST,OPTIONS")
class RfpApproveRequest implements IReturn<RfpApproveResponse>, IConvertible, IPost
{
    String? RfpDocumentUID;
    ProjectProposal? Proposal;

    RfpApproveRequest({this.RfpDocumentUID,this.Proposal});
    RfpApproveRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'RfpDocumentUID': RfpDocumentUID,
        'Proposal': JsonConverters.toJson(Proposal,'ProjectProposal',context!)
    };

    createResponse() => RfpApproveResponse();
    getResponseTypeName() => "RfpApproveResponse";
    getTypeName() => "RfpApproveRequest";
    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>[]),
    'WorkPackageSpecRef': TypeInfo(TypeOf.Class, create:() => WorkPackageSpecRef()),
    'TaskWorkPackage': TypeInfo(TypeOf.Class, create:() => TaskWorkPackage()),
    'List<WorkPackageSpecRef>': TypeInfo(TypeOf.Class, create:() => <WorkPackageSpecRef>[]),
    'ProposedTask': TypeInfo(TypeOf.Class, create:() => ProposedTask()),
    'AddendaChange': TypeInfo(TypeOf.Class, create:() => AddendaChange()),
    'AddendaChangeSet': TypeInfo(TypeOf.Class, create:() => AddendaChangeSet()),
    'List<AddendaChange>': TypeInfo(TypeOf.Class, create:() => <AddendaChange>[]),
    'WageClassification': TypeInfo(TypeOf.Class, create:() => WageClassification()),
    'WageDeterminationResult': TypeInfo(TypeOf.Class, create:() => WageDeterminationResult()),
    'List<WageClassification>': TypeInfo(TypeOf.Class, create:() => <WageClassification>[]),
    'ProjectProposal': TypeInfo(TypeOf.Class, create:() => ProjectProposal()),
    'List<ProposedTask>': TypeInfo(TypeOf.Class, create:() => <ProposedTask>[]),
    'List<AddendaChangeSet>': TypeInfo(TypeOf.Class, create:() => <AddendaChangeSet>[]),
    'List<WageDeterminationResult>': TypeInfo(TypeOf.Class, create:() => <WageDeterminationResult>[]),
    'TaskDiff': TypeInfo(TypeOf.Class, create:() => TaskDiff()),
    'ProposalDiff': TypeInfo(TypeOf.Class, create:() => ProposalDiff()),
    'List<TaskDiff>': TypeInfo(TypeOf.Class, create:() => <TaskDiff>[]),
    'RfpApproveResponse': TypeInfo(TypeOf.Class, create:() => RfpApproveResponse()),
    'RfpApproveRequest': TypeInfo(TypeOf.Class, create:() => RfpApproveRequest()),
});