/* Options:
Date: 2026-08-20 13:07:34
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: DispatchAutopilotRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

class DispatchPackConfigView implements IConvertible
{
    String? PackId;
    bool? HasQuotas;
    bool? IsInverted;
    int? LoadLimitMins;
    String? TicketSource;
    String? PayBasis;
    String? DayBoundary;

    DispatchPackConfigView({this.PackId,this.HasQuotas,this.IsInverted,this.LoadLimitMins,this.TicketSource,this.PayBasis,this.DayBoundary});
    DispatchPackConfigView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PackId = json['PackId'];
        HasQuotas = json['HasQuotas'];
        IsInverted = json['IsInverted'];
        LoadLimitMins = json['LoadLimitMins'];
        TicketSource = json['TicketSource'];
        PayBasis = json['PayBasis'];
        DayBoundary = json['DayBoundary'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PackId': PackId,
        'HasQuotas': HasQuotas,
        'IsInverted': IsInverted,
        'LoadLimitMins': LoadLimitMins,
        'TicketSource': TicketSource,
        'PayBasis': PayBasis,
        'DayBoundary': DayBoundary
    };

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

class DispatchHaulConfigView implements IConvertible
{
    int? QueueMax;
    int? DumpBays;
    int? SlotCap;
    bool? Paused;
    int? FeedRate;

    DispatchHaulConfigView({this.QueueMax,this.DumpBays,this.SlotCap,this.Paused,this.FeedRate});
    DispatchHaulConfigView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        QueueMax = json['QueueMax'];
        DumpBays = json['DumpBays'];
        SlotCap = json['SlotCap'];
        Paused = json['Paused'];
        FeedRate = json['FeedRate'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'QueueMax': QueueMax,
        'DumpBays': DumpBays,
        'SlotCap': SlotCap,
        'Paused': Paused,
        'FeedRate': FeedRate
    };

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

class DispatchOfflineWindowView implements IConvertible
{
    int? OfflineWindowId;
    String? FromHour;
    String? ToHour;

    DispatchOfflineWindowView({this.OfflineWindowId,this.FromHour,this.ToHour});
    DispatchOfflineWindowView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        OfflineWindowId = json['OfflineWindowId'];
        FromHour = json['FromHour'];
        ToHour = json['ToHour'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'OfflineWindowId': OfflineWindowId,
        'FromHour': FromHour,
        'ToHour': ToHour
    };

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

class DispatchSiteView implements IConvertible
{
    int? SiteId;
    int? SupplierId;
    String? SupplierCode;
    String? Name;
    int? Acres;
    double? StandingVolume;
    int? SortOrder;

    DispatchSiteView({this.SiteId,this.SupplierId,this.SupplierCode,this.Name,this.Acres,this.StandingVolume,this.SortOrder});
    DispatchSiteView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        SiteId = json['SiteId'];
        SupplierId = json['SupplierId'];
        SupplierCode = json['SupplierCode'];
        Name = json['Name'];
        Acres = json['Acres'];
        StandingVolume = JsonConverters.toDouble(json['StandingVolume']);
        SortOrder = json['SortOrder'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'SiteId': SiteId,
        'SupplierId': SupplierId,
        'SupplierCode': SupplierCode,
        'Name': Name,
        'Acres': Acres,
        'StandingVolume': StandingVolume,
        'SortOrder': SortOrder
    };

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

class DispatchSupplierView implements IConvertible
{
    int? SupplierId;
    String? Code;
    String? Name;
    String? Region;
    bool? OwnHauler;
    double? SeasonAllotment;
    double? Delivered;
    double? WeekCap;
    double? WeekDelivered;
    int? SortOrder;
    List<DispatchSiteView>? Sites = [];

    DispatchSupplierView({this.SupplierId,this.Code,this.Name,this.Region,this.OwnHauler,this.SeasonAllotment,this.Delivered,this.WeekCap,this.WeekDelivered,this.SortOrder,this.Sites});
    DispatchSupplierView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        SupplierId = json['SupplierId'];
        Code = json['Code'];
        Name = json['Name'];
        Region = json['Region'];
        OwnHauler = json['OwnHauler'];
        SeasonAllotment = JsonConverters.toDouble(json['SeasonAllotment']);
        Delivered = JsonConverters.toDouble(json['Delivered']);
        WeekCap = JsonConverters.toDouble(json['WeekCap']);
        WeekDelivered = JsonConverters.toDouble(json['WeekDelivered']);
        SortOrder = json['SortOrder'];
        Sites = JsonConverters.fromJson(json['Sites'],'List<DispatchSiteView>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'SupplierId': SupplierId,
        'Code': Code,
        'Name': Name,
        'Region': Region,
        'OwnHauler': OwnHauler,
        'SeasonAllotment': SeasonAllotment,
        'Delivered': Delivered,
        'WeekCap': WeekCap,
        'WeekDelivered': WeekDelivered,
        'SortOrder': SortOrder,
        'Sites': JsonConverters.toJson(Sites,'List<DispatchSiteView>',context!)
    };

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

class DispatchTruckView implements IConvertible
{
    int? TruckId;
    String? Code;
    String? DriverName;
    String? Phone;
    String? EmployerCode;
    String? SupplierCode;
    String? SiteName;
    double? EstLoad;
    String? Stage;
    int? StageSince;
    int? CycleStart;
    int? StageMinsAgo;
    int? CycleMinsAgo;
    String? Slot;
    int? LoadsToday;
    double? NetToday;
    int? LastPingMins;
    String? CycleMins;
    bool? IsInteractive;
    String? NextSupplierCode;
    String? NextSiteName;

    DispatchTruckView({this.TruckId,this.Code,this.DriverName,this.Phone,this.EmployerCode,this.SupplierCode,this.SiteName,this.EstLoad,this.Stage,this.StageSince,this.CycleStart,this.StageMinsAgo,this.CycleMinsAgo,this.Slot,this.LoadsToday,this.NetToday,this.LastPingMins,this.CycleMins,this.IsInteractive,this.NextSupplierCode,this.NextSiteName});
    DispatchTruckView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TruckId = json['TruckId'];
        Code = json['Code'];
        DriverName = json['DriverName'];
        Phone = json['Phone'];
        EmployerCode = json['EmployerCode'];
        SupplierCode = json['SupplierCode'];
        SiteName = json['SiteName'];
        EstLoad = JsonConverters.toDouble(json['EstLoad']);
        Stage = json['Stage'];
        StageSince = json['StageSince'];
        CycleStart = json['CycleStart'];
        StageMinsAgo = json['StageMinsAgo'];
        CycleMinsAgo = json['CycleMinsAgo'];
        Slot = json['Slot'];
        LoadsToday = json['LoadsToday'];
        NetToday = JsonConverters.toDouble(json['NetToday']);
        LastPingMins = json['LastPingMins'];
        CycleMins = json['CycleMins'];
        IsInteractive = json['IsInteractive'];
        NextSupplierCode = json['NextSupplierCode'];
        NextSiteName = json['NextSiteName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TruckId': TruckId,
        'Code': Code,
        'DriverName': DriverName,
        'Phone': Phone,
        'EmployerCode': EmployerCode,
        'SupplierCode': SupplierCode,
        'SiteName': SiteName,
        'EstLoad': EstLoad,
        'Stage': Stage,
        'StageSince': StageSince,
        'CycleStart': CycleStart,
        'StageMinsAgo': StageMinsAgo,
        'CycleMinsAgo': CycleMinsAgo,
        'Slot': Slot,
        'LoadsToday': LoadsToday,
        'NetToday': NetToday,
        'LastPingMins': LastPingMins,
        'CycleMins': CycleMins,
        'IsInteractive': IsInteractive,
        'NextSupplierCode': NextSupplierCode,
        'NextSiteName': NextSiteName
    };

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

class DispatchSlotView implements IConvertible
{
    int? SlotId;
    String? Hour;
    int? BaseBooked;
    int? SortOrder;

    DispatchSlotView({this.SlotId,this.Hour,this.BaseBooked,this.SortOrder});
    DispatchSlotView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        SlotId = json['SlotId'];
        Hour = json['Hour'];
        BaseBooked = json['BaseBooked'];
        SortOrder = json['SortOrder'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'SlotId': SlotId,
        'Hour': Hour,
        'BaseBooked': BaseBooked,
        'SortOrder': SortOrder
    };

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

class DispatchTicketView implements IConvertible
{
    int? TicketId;
    String? Code;
    String? TruckCode;
    String? SupplierCode;
    double? NetQty;
    DateTime? TicketedAt;
    int? TicketedMin;
    String? Source;
    int? MinsAgo;

    DispatchTicketView({this.TicketId,this.Code,this.TruckCode,this.SupplierCode,this.NetQty,this.TicketedAt,this.TicketedMin,this.Source,this.MinsAgo});
    DispatchTicketView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        TicketId = json['TicketId'];
        Code = json['Code'];
        TruckCode = json['TruckCode'];
        SupplierCode = json['SupplierCode'];
        NetQty = JsonConverters.toDouble(json['NetQty']);
        TicketedAt = JsonConverters.fromJson(json['TicketedAt'],'DateTime',context!);
        TicketedMin = json['TicketedMin'];
        Source = json['Source'];
        MinsAgo = json['MinsAgo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'TicketId': TicketId,
        'Code': Code,
        'TruckCode': TruckCode,
        'SupplierCode': SupplierCode,
        'NetQty': NetQty,
        'TicketedAt': JsonConverters.toJson(TicketedAt,'DateTime',context!),
        'TicketedMin': TicketedMin,
        'Source': Source,
        'MinsAgo': MinsAgo
    };

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

class DispatchLogView implements IConvertible
{
    int? LogId;
    DateTime? LoggedAt;
    int? LoggedMin;
    String? LogText;
    String? Kind;
    int? MinsAgo;

    DispatchLogView({this.LogId,this.LoggedAt,this.LoggedMin,this.LogText,this.Kind,this.MinsAgo});
    DispatchLogView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        LogId = json['LogId'];
        LoggedAt = JsonConverters.fromJson(json['LoggedAt'],'DateTime',context!);
        LoggedMin = json['LoggedMin'];
        LogText = json['LogText'];
        Kind = json['Kind'];
        MinsAgo = json['MinsAgo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'LogId': LogId,
        'LoggedAt': JsonConverters.toJson(LoggedAt,'DateTime',context!),
        'LoggedMin': LoggedMin,
        'LogText': LogText,
        'Kind': Kind,
        'MinsAgo': MinsAgo
    };

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

class DispatchAutopilotView implements IConvertible
{
    bool? IsOn;
    bool? RuleSlot;
    bool? RuleRoute;
    bool? RuleRelease;
    bool? RuleTract;
    bool? RuleThrottle;
    bool? RuleOffline;
    int? ThStaged;
    int? ThWait;
    int? ThBand;
    int? ThStall;
    int? ThFeed;

    DispatchAutopilotView({this.IsOn,this.RuleSlot,this.RuleRoute,this.RuleRelease,this.RuleTract,this.RuleThrottle,this.RuleOffline,this.ThStaged,this.ThWait,this.ThBand,this.ThStall,this.ThFeed});
    DispatchAutopilotView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        IsOn = json['IsOn'];
        RuleSlot = json['RuleSlot'];
        RuleRoute = json['RuleRoute'];
        RuleRelease = json['RuleRelease'];
        RuleTract = json['RuleTract'];
        RuleThrottle = json['RuleThrottle'];
        RuleOffline = json['RuleOffline'];
        ThStaged = json['ThStaged'];
        ThWait = json['ThWait'];
        ThBand = json['ThBand'];
        ThStall = json['ThStall'];
        ThFeed = json['ThFeed'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'IsOn': IsOn,
        'RuleSlot': RuleSlot,
        'RuleRoute': RuleRoute,
        'RuleRelease': RuleRelease,
        'RuleTract': RuleTract,
        'RuleThrottle': RuleThrottle,
        'RuleOffline': RuleOffline,
        'ThStaged': ThStaged,
        'ThWait': ThWait,
        'ThBand': ThBand,
        'ThStall': ThStall,
        'ThFeed': ThFeed
    };

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

class DispatchExceptionView implements IConvertible
{
    String? Code;
    String? Kind;
    String? Severity;
    String? TruckCode;
    String? SupplierCode;
    DateTime? RaisedAt;
    String? RaisedLabel;
    int? MinsAgo;

    DispatchExceptionView({this.Code,this.Kind,this.Severity,this.TruckCode,this.SupplierCode,this.RaisedAt,this.RaisedLabel,this.MinsAgo});
    DispatchExceptionView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Code = json['Code'];
        Kind = json['Kind'];
        Severity = json['Severity'];
        TruckCode = json['TruckCode'];
        SupplierCode = json['SupplierCode'];
        RaisedAt = JsonConverters.fromJson(json['RaisedAt'],'DateTime',context!);
        RaisedLabel = json['RaisedLabel'];
        MinsAgo = json['MinsAgo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Code': Code,
        'Kind': Kind,
        'Severity': Severity,
        'TruckCode': TruckCode,
        'SupplierCode': SupplierCode,
        'RaisedAt': JsonConverters.toJson(RaisedAt,'DateTime',context!),
        'RaisedLabel': RaisedLabel,
        'MinsAgo': MinsAgo
    };

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

class DispatchFeedView implements IConvertible
{
    int? FeedId;
    DateTime? EntryAt;
    String? EntryLabel;
    String? Channel;
    String? Kind;
    String? TruckCode;
    String? SupplierCode;
    String? OverrideText;
    int? MinsAgo;

    DispatchFeedView({this.FeedId,this.EntryAt,this.EntryLabel,this.Channel,this.Kind,this.TruckCode,this.SupplierCode,this.OverrideText,this.MinsAgo});
    DispatchFeedView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        FeedId = json['FeedId'];
        EntryAt = JsonConverters.fromJson(json['EntryAt'],'DateTime',context!);
        EntryLabel = json['EntryLabel'];
        Channel = json['Channel'];
        Kind = json['Kind'];
        TruckCode = json['TruckCode'];
        SupplierCode = json['SupplierCode'];
        OverrideText = json['OverrideText'];
        MinsAgo = json['MinsAgo'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'FeedId': FeedId,
        'EntryAt': JsonConverters.toJson(EntryAt,'DateTime',context!),
        'EntryLabel': EntryLabel,
        'Channel': Channel,
        'Kind': Kind,
        'TruckCode': TruckCode,
        'SupplierCode': SupplierCode,
        'OverrideText': OverrideText,
        'MinsAgo': MinsAgo
    };

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

class DispatchRigView implements IConvertible
{
    int? RigId;
    String? Code;
    String? Name;
    String? DriverName;
    String? Phone;
    String? RigType;
    bool? IsFree;
    int? MatchRank;

    DispatchRigView({this.RigId,this.Code,this.Name,this.DriverName,this.Phone,this.RigType,this.IsFree,this.MatchRank});
    DispatchRigView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RigId = json['RigId'];
        Code = json['Code'];
        Name = json['Name'];
        DriverName = json['DriverName'];
        Phone = json['Phone'];
        RigType = json['RigType'];
        IsFree = json['IsFree'];
        MatchRank = json['MatchRank'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RigId': RigId,
        'Code': Code,
        'Name': Name,
        'DriverName': DriverName,
        'Phone': Phone,
        'RigType': RigType,
        'IsFree': IsFree,
        'MatchRank': MatchRank
    };

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

class DispatchJobView implements IConvertible
{
    int? JobId;
    String? Code;
    String? Cargo;
    String? Customer;
    String? CustomerPhone;
    String? HoldContact;
    String? HoldPhone;
    String? FromLoc;
    String? ToLoc;
    int? Miles;
    String? WindowText;
    String? Stage;
    double? Rate;
    String? RequiredRig;
    String? DriverLabel;
    String? EtaText;
    String? OfferRigIds;
    int? OfferExpiresMin;
    bool? OfferExpired;
    bool? Declined;

    DispatchJobView({this.JobId,this.Code,this.Cargo,this.Customer,this.CustomerPhone,this.HoldContact,this.HoldPhone,this.FromLoc,this.ToLoc,this.Miles,this.WindowText,this.Stage,this.Rate,this.RequiredRig,this.DriverLabel,this.EtaText,this.OfferRigIds,this.OfferExpiresMin,this.OfferExpired,this.Declined});
    DispatchJobView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        JobId = json['JobId'];
        Code = json['Code'];
        Cargo = json['Cargo'];
        Customer = json['Customer'];
        CustomerPhone = json['CustomerPhone'];
        HoldContact = json['HoldContact'];
        HoldPhone = json['HoldPhone'];
        FromLoc = json['FromLoc'];
        ToLoc = json['ToLoc'];
        Miles = json['Miles'];
        WindowText = json['WindowText'];
        Stage = json['Stage'];
        Rate = JsonConverters.toDouble(json['Rate']);
        RequiredRig = json['RequiredRig'];
        DriverLabel = json['DriverLabel'];
        EtaText = json['EtaText'];
        OfferRigIds = json['OfferRigIds'];
        OfferExpiresMin = json['OfferExpiresMin'];
        OfferExpired = json['OfferExpired'];
        Declined = json['Declined'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'JobId': JobId,
        'Code': Code,
        'Cargo': Cargo,
        'Customer': Customer,
        'CustomerPhone': CustomerPhone,
        'HoldContact': HoldContact,
        'HoldPhone': HoldPhone,
        'FromLoc': FromLoc,
        'ToLoc': ToLoc,
        'Miles': Miles,
        'WindowText': WindowText,
        'Stage': Stage,
        'Rate': Rate,
        'RequiredRig': RequiredRig,
        'DriverLabel': DriverLabel,
        'EtaText': EtaText,
        'OfferRigIds': OfferRigIds,
        'OfferExpiresMin': OfferExpiresMin,
        'OfferExpired': OfferExpired,
        'Declined': Declined
    };

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

class DispatchOdDriverView implements IConvertible
{
    int? DriverId;
    String? Code;
    String? Name;
    String? Zone;
    String? Phone;
    String? Status;
    String? Tier;
    double? DistanceMi;
    String? Capabilities;

    DispatchOdDriverView({this.DriverId,this.Code,this.Name,this.Zone,this.Phone,this.Status,this.Tier,this.DistanceMi,this.Capabilities});
    DispatchOdDriverView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        DriverId = json['DriverId'];
        Code = json['Code'];
        Name = json['Name'];
        Zone = json['Zone'];
        Phone = json['Phone'];
        Status = json['Status'];
        Tier = json['Tier'];
        DistanceMi = JsonConverters.toDouble(json['DistanceMi']);
        Capabilities = json['Capabilities'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'DriverId': DriverId,
        'Code': Code,
        'Name': Name,
        'Zone': Zone,
        'Phone': Phone,
        'Status': Status,
        'Tier': Tier,
        'DistanceMi': DistanceMi,
        'Capabilities': Capabilities
    };

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

class DispatchOdRequestView implements IConvertible
{
    int? RequestId;
    String? Code;
    String? Address;
    String? Zone;
    int? Bags;
    String? Stage;
    String? DriverCode;
    String? Needs;
    String? Note;
    int? PingExpiresMin;
    String? TriedCodes;
    String? CandidateCodes;
    String? EtaText;
    String? NoDriver;

    DispatchOdRequestView({this.RequestId,this.Code,this.Address,this.Zone,this.Bags,this.Stage,this.DriverCode,this.Needs,this.Note,this.PingExpiresMin,this.TriedCodes,this.CandidateCodes,this.EtaText,this.NoDriver});
    DispatchOdRequestView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        RequestId = json['RequestId'];
        Code = json['Code'];
        Address = json['Address'];
        Zone = json['Zone'];
        Bags = json['Bags'];
        Stage = json['Stage'];
        DriverCode = json['DriverCode'];
        Needs = json['Needs'];
        Note = json['Note'];
        PingExpiresMin = json['PingExpiresMin'];
        TriedCodes = json['TriedCodes'];
        CandidateCodes = json['CandidateCodes'];
        EtaText = json['EtaText'];
        NoDriver = json['NoDriver'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'RequestId': RequestId,
        'Code': Code,
        'Address': Address,
        'Zone': Zone,
        'Bags': Bags,
        'Stage': Stage,
        'DriverCode': DriverCode,
        'Needs': Needs,
        'Note': Note,
        'PingExpiresMin': PingExpiresMin,
        'TriedCodes': TriedCodes,
        'CandidateCodes': CandidateCodes,
        'EtaText': EtaText,
        'NoDriver': NoDriver
    };

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

class DispatchPackView implements IConvertible
{
    String? PackId;
    bool? HasQuotas;
    bool? IsInverted;
    int? LoadLimitMins;
    String? DayBoundary;
    String? TicketSource;
    String? PayBasis;
    int? SortOrder;

    DispatchPackView({this.PackId,this.HasQuotas,this.IsInverted,this.LoadLimitMins,this.DayBoundary,this.TicketSource,this.PayBasis,this.SortOrder});
    DispatchPackView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PackId = json['PackId'];
        HasQuotas = json['HasQuotas'];
        IsInverted = json['IsInverted'];
        LoadLimitMins = json['LoadLimitMins'];
        DayBoundary = json['DayBoundary'];
        TicketSource = json['TicketSource'];
        PayBasis = json['PayBasis'];
        SortOrder = json['SortOrder'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PackId': PackId,
        'HasQuotas': HasQuotas,
        'IsInverted': IsInverted,
        'LoadLimitMins': LoadLimitMins,
        'DayBoundary': DayBoundary,
        'TicketSource': TicketSource,
        'PayBasis': PayBasis,
        'SortOrder': SortOrder
    };

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

class DispatchPackTermView implements IConvertible
{
    String? PackId;
    String? Lang;
    String? ModeName;
    String? Facility;
    String? FacilityShort;
    String? SourceSite;
    String? Supplier;
    String? SupplierPlural;
    String? UnloadVerb;
    String? TicketNoun;
    String? DayNoun;
    String? FleetLabel;
    String? PageSubtitle;
    String? SeasonChip;
    String? CampaignNoun;
    String? BayNoun;
    String? AssignTarget;

    DispatchPackTermView({this.PackId,this.Lang,this.ModeName,this.Facility,this.FacilityShort,this.SourceSite,this.Supplier,this.SupplierPlural,this.UnloadVerb,this.TicketNoun,this.DayNoun,this.FleetLabel,this.PageSubtitle,this.SeasonChip,this.CampaignNoun,this.BayNoun,this.AssignTarget});
    DispatchPackTermView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PackId = json['PackId'];
        Lang = json['Lang'];
        ModeName = json['ModeName'];
        Facility = json['Facility'];
        FacilityShort = json['FacilityShort'];
        SourceSite = json['SourceSite'];
        Supplier = json['Supplier'];
        SupplierPlural = json['SupplierPlural'];
        UnloadVerb = json['UnloadVerb'];
        TicketNoun = json['TicketNoun'];
        DayNoun = json['DayNoun'];
        FleetLabel = json['FleetLabel'];
        PageSubtitle = json['PageSubtitle'];
        SeasonChip = json['SeasonChip'];
        CampaignNoun = json['CampaignNoun'];
        BayNoun = json['BayNoun'];
        AssignTarget = json['AssignTarget'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PackId': PackId,
        'Lang': Lang,
        'ModeName': ModeName,
        'Facility': Facility,
        'FacilityShort': FacilityShort,
        'SourceSite': SourceSite,
        'Supplier': Supplier,
        'SupplierPlural': SupplierPlural,
        'UnloadVerb': UnloadVerb,
        'TicketNoun': TicketNoun,
        'DayNoun': DayNoun,
        'FleetLabel': FleetLabel,
        'PageSubtitle': PageSubtitle,
        'SeasonChip': SeasonChip,
        'CampaignNoun': CampaignNoun,
        'BayNoun': BayNoun,
        'AssignTarget': AssignTarget
    };

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

class DispatchPackUnitView implements IConvertible
{
    String? PackId;
    String? Unit;
    double? LoadQty;
    int? VolumeLow;
    int? VolumeHigh;
    double? SeasonMultiple;
    double? WeeklyFraction;

    DispatchPackUnitView({this.PackId,this.Unit,this.LoadQty,this.VolumeLow,this.VolumeHigh,this.SeasonMultiple,this.WeeklyFraction});
    DispatchPackUnitView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PackId = json['PackId'];
        Unit = json['Unit'];
        LoadQty = JsonConverters.toDouble(json['LoadQty']);
        VolumeLow = json['VolumeLow'];
        VolumeHigh = json['VolumeHigh'];
        SeasonMultiple = JsonConverters.toDouble(json['SeasonMultiple']);
        WeeklyFraction = JsonConverters.toDouble(json['WeeklyFraction']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PackId': PackId,
        'Unit': Unit,
        'LoadQty': LoadQty,
        'VolumeLow': VolumeLow,
        'VolumeHigh': VolumeHigh,
        'SeasonMultiple': SeasonMultiple,
        'WeeklyFraction': WeeklyFraction
    };

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

class DispatchBoardView implements IConvertible
{
    DispatchPackConfigView? Pack;
    DispatchHaulConfigView? Config;
    List<DispatchOfflineWindowView>? OfflineWindows = [];
    List<DispatchSupplierView>? Suppliers = [];
    List<DispatchTruckView>? Trucks = [];
    List<DispatchSlotView>? Slots = [];
    List<DispatchTicketView>? Tickets = [];
    List<DispatchLogView>? Log = [];
    DispatchAutopilotView? Autopilot;
    List<DispatchExceptionView>? Exceptions = [];
    List<DispatchFeedView>? Feed = [];
    List<DispatchRigView>? Rigs = [];
    List<DispatchJobView>? Jobs = [];
    List<DispatchOdDriverView>? OdDrivers = [];
    List<DispatchOdRequestView>? OdRequests = [];
    List<DispatchPackView>? Packs = [];
    List<DispatchPackTermView>? PackTerms = [];
    List<DispatchPackUnitView>? PackUnits = [];

    DispatchBoardView({this.Pack,this.Config,this.OfflineWindows,this.Suppliers,this.Trucks,this.Slots,this.Tickets,this.Log,this.Autopilot,this.Exceptions,this.Feed,this.Rigs,this.Jobs,this.OdDrivers,this.OdRequests,this.Packs,this.PackTerms,this.PackUnits});
    DispatchBoardView.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Pack = JsonConverters.fromJson(json['Pack'],'DispatchPackConfigView',context!);
        Config = JsonConverters.fromJson(json['Config'],'DispatchHaulConfigView',context!);
        OfflineWindows = JsonConverters.fromJson(json['OfflineWindows'],'List<DispatchOfflineWindowView>',context!);
        Suppliers = JsonConverters.fromJson(json['Suppliers'],'List<DispatchSupplierView>',context!);
        Trucks = JsonConverters.fromJson(json['Trucks'],'List<DispatchTruckView>',context!);
        Slots = JsonConverters.fromJson(json['Slots'],'List<DispatchSlotView>',context!);
        Tickets = JsonConverters.fromJson(json['Tickets'],'List<DispatchTicketView>',context!);
        Log = JsonConverters.fromJson(json['Log'],'List<DispatchLogView>',context!);
        Autopilot = JsonConverters.fromJson(json['Autopilot'],'DispatchAutopilotView',context!);
        Exceptions = JsonConverters.fromJson(json['Exceptions'],'List<DispatchExceptionView>',context!);
        Feed = JsonConverters.fromJson(json['Feed'],'List<DispatchFeedView>',context!);
        Rigs = JsonConverters.fromJson(json['Rigs'],'List<DispatchRigView>',context!);
        Jobs = JsonConverters.fromJson(json['Jobs'],'List<DispatchJobView>',context!);
        OdDrivers = JsonConverters.fromJson(json['OdDrivers'],'List<DispatchOdDriverView>',context!);
        OdRequests = JsonConverters.fromJson(json['OdRequests'],'List<DispatchOdRequestView>',context!);
        Packs = JsonConverters.fromJson(json['Packs'],'List<DispatchPackView>',context!);
        PackTerms = JsonConverters.fromJson(json['PackTerms'],'List<DispatchPackTermView>',context!);
        PackUnits = JsonConverters.fromJson(json['PackUnits'],'List<DispatchPackUnitView>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Pack': JsonConverters.toJson(Pack,'DispatchPackConfigView',context!),
        'Config': JsonConverters.toJson(Config,'DispatchHaulConfigView',context!),
        'OfflineWindows': JsonConverters.toJson(OfflineWindows,'List<DispatchOfflineWindowView>',context!),
        'Suppliers': JsonConverters.toJson(Suppliers,'List<DispatchSupplierView>',context!),
        'Trucks': JsonConverters.toJson(Trucks,'List<DispatchTruckView>',context!),
        'Slots': JsonConverters.toJson(Slots,'List<DispatchSlotView>',context!),
        'Tickets': JsonConverters.toJson(Tickets,'List<DispatchTicketView>',context!),
        'Log': JsonConverters.toJson(Log,'List<DispatchLogView>',context!),
        'Autopilot': JsonConverters.toJson(Autopilot,'DispatchAutopilotView',context!),
        'Exceptions': JsonConverters.toJson(Exceptions,'List<DispatchExceptionView>',context!),
        'Feed': JsonConverters.toJson(Feed,'List<DispatchFeedView>',context!),
        'Rigs': JsonConverters.toJson(Rigs,'List<DispatchRigView>',context!),
        'Jobs': JsonConverters.toJson(Jobs,'List<DispatchJobView>',context!),
        'OdDrivers': JsonConverters.toJson(OdDrivers,'List<DispatchOdDriverView>',context!),
        'OdRequests': JsonConverters.toJson(OdRequests,'List<DispatchOdRequestView>',context!),
        'Packs': JsonConverters.toJson(Packs,'List<DispatchPackView>',context!),
        'PackTerms': JsonConverters.toJson(PackTerms,'List<DispatchPackTermView>',context!),
        'PackUnits': JsonConverters.toJson(PackUnits,'List<DispatchPackUnitView>',context!)
    };

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

class DispatchActionResponse implements IConvertible
{
    DispatchBoardView? Board;
    String? Message;
    int? Sent;
    int? Failed;
    String? TicketCode;
    double? TicketNet;
    ResponseStatus? ResponseStatus;

    DispatchActionResponse({this.Board,this.Message,this.Sent,this.Failed,this.TicketCode,this.TicketNet,this.ResponseStatus});
    DispatchActionResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Board = JsonConverters.fromJson(json['Board'],'DispatchBoardView',context!);
        Message = json['Message'];
        Sent = json['Sent'];
        Failed = json['Failed'];
        TicketCode = json['TicketCode'];
        TicketNet = JsonConverters.toDouble(json['TicketNet']);
        ResponseStatus = JsonConverters.fromJson(json['ResponseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Board': JsonConverters.toJson(Board,'DispatchBoardView',context!),
        'Message': Message,
        'Sent': Sent,
        'Failed': Failed,
        'TicketCode': TicketCode,
        'TicketNet': TicketNet,
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!)
    };

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

// @Route("/v1/dispatch/autopilot", "PUT,OPTIONS")
class DispatchAutopilotRequest implements IReturn<DispatchActionResponse>, IConvertible, IPut
{
    bool? IsOn;
    bool? RuleSlot;
    bool? RuleRoute;
    bool? RuleRelease;
    bool? RuleTract;
    bool? RuleThrottle;
    bool? RuleOffline;
    int? ThStaged;
    int? ThWait;
    int? ThBand;
    int? ThStall;
    int? ThFeed;
    String? Note;
    int? AtMin;

    DispatchAutopilotRequest({this.IsOn,this.RuleSlot,this.RuleRoute,this.RuleRelease,this.RuleTract,this.RuleThrottle,this.RuleOffline,this.ThStaged,this.ThWait,this.ThBand,this.ThStall,this.ThFeed,this.Note,this.AtMin});
    DispatchAutopilotRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        IsOn = json['IsOn'];
        RuleSlot = json['RuleSlot'];
        RuleRoute = json['RuleRoute'];
        RuleRelease = json['RuleRelease'];
        RuleTract = json['RuleTract'];
        RuleThrottle = json['RuleThrottle'];
        RuleOffline = json['RuleOffline'];
        ThStaged = json['ThStaged'];
        ThWait = json['ThWait'];
        ThBand = json['ThBand'];
        ThStall = json['ThStall'];
        ThFeed = json['ThFeed'];
        Note = json['Note'];
        AtMin = json['AtMin'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'IsOn': IsOn,
        'RuleSlot': RuleSlot,
        'RuleRoute': RuleRoute,
        'RuleRelease': RuleRelease,
        'RuleTract': RuleTract,
        'RuleThrottle': RuleThrottle,
        'RuleOffline': RuleOffline,
        'ThStaged': ThStaged,
        'ThWait': ThWait,
        'ThBand': ThBand,
        'ThStall': ThStall,
        'ThFeed': ThFeed,
        'Note': Note,
        'AtMin': AtMin
    };

    createResponse() => DispatchActionResponse();
    getResponseTypeName() => "DispatchActionResponse";
    getTypeName() => "DispatchAutopilotRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'DispatchPackConfigView': TypeInfo(TypeOf.Class, create:() => DispatchPackConfigView()),
    'DispatchHaulConfigView': TypeInfo(TypeOf.Class, create:() => DispatchHaulConfigView()),
    'DispatchOfflineWindowView': TypeInfo(TypeOf.Class, create:() => DispatchOfflineWindowView()),
    'DispatchSiteView': TypeInfo(TypeOf.Class, create:() => DispatchSiteView()),
    'DispatchSupplierView': TypeInfo(TypeOf.Class, create:() => DispatchSupplierView()),
    'List<DispatchSiteView>': TypeInfo(TypeOf.Class, create:() => <DispatchSiteView>[]),
    'DispatchTruckView': TypeInfo(TypeOf.Class, create:() => DispatchTruckView()),
    'DispatchSlotView': TypeInfo(TypeOf.Class, create:() => DispatchSlotView()),
    'DispatchTicketView': TypeInfo(TypeOf.Class, create:() => DispatchTicketView()),
    'DispatchLogView': TypeInfo(TypeOf.Class, create:() => DispatchLogView()),
    'DispatchAutopilotView': TypeInfo(TypeOf.Class, create:() => DispatchAutopilotView()),
    'DispatchExceptionView': TypeInfo(TypeOf.Class, create:() => DispatchExceptionView()),
    'DispatchFeedView': TypeInfo(TypeOf.Class, create:() => DispatchFeedView()),
    'DispatchRigView': TypeInfo(TypeOf.Class, create:() => DispatchRigView()),
    'DispatchJobView': TypeInfo(TypeOf.Class, create:() => DispatchJobView()),
    'DispatchOdDriverView': TypeInfo(TypeOf.Class, create:() => DispatchOdDriverView()),
    'DispatchOdRequestView': TypeInfo(TypeOf.Class, create:() => DispatchOdRequestView()),
    'DispatchPackView': TypeInfo(TypeOf.Class, create:() => DispatchPackView()),
    'DispatchPackTermView': TypeInfo(TypeOf.Class, create:() => DispatchPackTermView()),
    'DispatchPackUnitView': TypeInfo(TypeOf.Class, create:() => DispatchPackUnitView()),
    'DispatchBoardView': TypeInfo(TypeOf.Class, create:() => DispatchBoardView()),
    'List<DispatchOfflineWindowView>': TypeInfo(TypeOf.Class, create:() => <DispatchOfflineWindowView>[]),
    'List<DispatchSupplierView>': TypeInfo(TypeOf.Class, create:() => <DispatchSupplierView>[]),
    'List<DispatchTruckView>': TypeInfo(TypeOf.Class, create:() => <DispatchTruckView>[]),
    'List<DispatchSlotView>': TypeInfo(TypeOf.Class, create:() => <DispatchSlotView>[]),
    'List<DispatchTicketView>': TypeInfo(TypeOf.Class, create:() => <DispatchTicketView>[]),
    'List<DispatchLogView>': TypeInfo(TypeOf.Class, create:() => <DispatchLogView>[]),
    'List<DispatchExceptionView>': TypeInfo(TypeOf.Class, create:() => <DispatchExceptionView>[]),
    'List<DispatchFeedView>': TypeInfo(TypeOf.Class, create:() => <DispatchFeedView>[]),
    'List<DispatchRigView>': TypeInfo(TypeOf.Class, create:() => <DispatchRigView>[]),
    'List<DispatchJobView>': TypeInfo(TypeOf.Class, create:() => <DispatchJobView>[]),
    'List<DispatchOdDriverView>': TypeInfo(TypeOf.Class, create:() => <DispatchOdDriverView>[]),
    'List<DispatchOdRequestView>': TypeInfo(TypeOf.Class, create:() => <DispatchOdRequestView>[]),
    'List<DispatchPackView>': TypeInfo(TypeOf.Class, create:() => <DispatchPackView>[]),
    'List<DispatchPackTermView>': TypeInfo(TypeOf.Class, create:() => <DispatchPackTermView>[]),
    'List<DispatchPackUnitView>': TypeInfo(TypeOf.Class, create:() => <DispatchPackUnitView>[]),
    'DispatchActionResponse': TypeInfo(TypeOf.Class, create:() => DispatchActionResponse()),
    'DispatchAutopilotRequest': TypeInfo(TypeOf.Class, create:() => DispatchAutopilotRequest()),
});