/* Options:
Date: 2026-09-23 01:37:12
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: EstimateRevisionCompareRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

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

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 RevisionLineDelta implements IConvertible
{
    String? ItemNo;
    String? Description;
    String? Unit;
    String? Change;
    double? QuantityA;
    double? QuantityB;
    double? UnitPriceA;
    double? UnitPriceB;
    double? ExtensionA;
    double? ExtensionB;
    double? QuantityDelta;
    double? UnitPriceDelta;
    double? ExtensionDelta;

    RevisionLineDelta({this.ItemNo,this.Description,this.Unit,this.Change,this.QuantityA,this.QuantityB,this.UnitPriceA,this.UnitPriceB,this.ExtensionA,this.ExtensionB,this.QuantityDelta,this.UnitPriceDelta,this.ExtensionDelta});
    RevisionLineDelta.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ItemNo = json['ItemNo'];
        Description = json['Description'];
        Unit = json['Unit'];
        Change = json['Change'];
        QuantityA = JsonConverters.toDouble(json['QuantityA']);
        QuantityB = JsonConverters.toDouble(json['QuantityB']);
        UnitPriceA = JsonConverters.toDouble(json['UnitPriceA']);
        UnitPriceB = JsonConverters.toDouble(json['UnitPriceB']);
        ExtensionA = JsonConverters.toDouble(json['ExtensionA']);
        ExtensionB = JsonConverters.toDouble(json['ExtensionB']);
        QuantityDelta = JsonConverters.toDouble(json['QuantityDelta']);
        UnitPriceDelta = JsonConverters.toDouble(json['UnitPriceDelta']);
        ExtensionDelta = JsonConverters.toDouble(json['ExtensionDelta']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ItemNo': ItemNo,
        'Description': Description,
        'Unit': Unit,
        'Change': Change,
        'QuantityA': QuantityA,
        'QuantityB': QuantityB,
        'UnitPriceA': UnitPriceA,
        'UnitPriceB': UnitPriceB,
        'ExtensionA': ExtensionA,
        'ExtensionB': ExtensionB,
        'QuantityDelta': QuantityDelta,
        'UnitPriceDelta': UnitPriceDelta,
        'ExtensionDelta': ExtensionDelta
    };

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

class EstimateRevisionCompareResult implements IConvertible
{
    int? RevisionA;
    int? RevisionB;
    String? LabelA;
    String? LabelB;
    double? TotalA;
    double? TotalB;
    double? TotalDelta;
    double? BidTotalA;
    double? BidTotalB;
    int? Added;
    int? Removed;
    int? Changed;
    int? Unchanged;
    List<RevisionLineDelta>? Lines = [];
    ProposalDiff? Scope;
    String? Summary;

    EstimateRevisionCompareResult({this.RevisionA,this.RevisionB,this.LabelA,this.LabelB,this.TotalA,this.TotalB,this.TotalDelta,this.BidTotalA,this.BidTotalB,this.Added,this.Removed,this.Changed,this.Unchanged,this.Lines,this.Scope,this.Summary});
    EstimateRevisionCompareResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RevisionA = json['RevisionA'];
        RevisionB = json['RevisionB'];
        LabelA = json['LabelA'];
        LabelB = json['LabelB'];
        TotalA = JsonConverters.toDouble(json['TotalA']);
        TotalB = JsonConverters.toDouble(json['TotalB']);
        TotalDelta = JsonConverters.toDouble(json['TotalDelta']);
        BidTotalA = JsonConverters.toDouble(json['BidTotalA']);
        BidTotalB = JsonConverters.toDouble(json['BidTotalB']);
        Added = json['Added'];
        Removed = json['Removed'];
        Changed = json['Changed'];
        Unchanged = json['Unchanged'];
        Lines = JsonConverters.fromJson(json['Lines'],'List<RevisionLineDelta>',context!);
        Scope = JsonConverters.fromJson(json['Scope'],'ProposalDiff',context!);
        Summary = json['Summary'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RevisionA': RevisionA,
        'RevisionB': RevisionB,
        'LabelA': LabelA,
        'LabelB': LabelB,
        'TotalA': TotalA,
        'TotalB': TotalB,
        'TotalDelta': TotalDelta,
        'BidTotalA': BidTotalA,
        'BidTotalB': BidTotalB,
        'Added': Added,
        'Removed': Removed,
        'Changed': Changed,
        'Unchanged': Unchanged,
        'Lines': JsonConverters.toJson(Lines,'List<RevisionLineDelta>',context!),
        'Scope': JsonConverters.toJson(Scope,'ProposalDiff',context!),
        'Summary': Summary
    };

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

class EstimateRevisionCompareResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    EstimateRevisionCompareResult? Compare;

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

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

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

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

// @Route("/v1/Rfp/{RfpDocumentUID}/Estimate/Revisions/{RevisionA}/Compare/{RevisionB}", "GET,OPTIONS")
class EstimateRevisionCompareRequest implements IReturn<EstimateRevisionCompareResponse>, IConvertible, IGet
{
    String? RfpDocumentUID;
    int? RevisionA;
    int? RevisionB;

    EstimateRevisionCompareRequest({this.RfpDocumentUID,this.RevisionA,this.RevisionB});
    EstimateRevisionCompareRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

    createResponse() => EstimateRevisionCompareResponse();
    getResponseTypeName() => "EstimateRevisionCompareResponse";
    getTypeName() => "EstimateRevisionCompareRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'TaskDiff': TypeInfo(TypeOf.Class, create:() => TaskDiff()),
    'ProposalDiff': TypeInfo(TypeOf.Class, create:() => ProposalDiff()),
    'List<TaskDiff>': TypeInfo(TypeOf.Class, create:() => <TaskDiff>[]),
    'RevisionLineDelta': TypeInfo(TypeOf.Class, create:() => RevisionLineDelta()),
    'EstimateRevisionCompareResult': TypeInfo(TypeOf.Class, create:() => EstimateRevisionCompareResult()),
    'List<RevisionLineDelta>': TypeInfo(TypeOf.Class, create:() => <RevisionLineDelta>[]),
    'EstimateRevisionCompareResponse': TypeInfo(TypeOf.Class, create:() => EstimateRevisionCompareResponse()),
    'EstimateRevisionCompareRequest': TypeInfo(TypeOf.Class, create:() => EstimateRevisionCompareRequest()),
});