/* Options:
Date: 2026-10-16 00:21:04
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: KpiV2BranchRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart
*/

import 'package:servicestack/servicestack.dart';

class SvcNamedTime implements IConvertible
{
    String? Id;
    String? Name;
    int? SignedSec;
    int? Served;

    SvcNamedTime({this.Id,this.Name,this.SignedSec,this.Served});
    SvcNamedTime.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Id = json['Id'];
        Name = json['Name'];
        SignedSec = json['SignedSec'];
        Served = json['Served'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Id': Id,
        'Name': Name,
        'SignedSec': SignedSec,
        'Served': Served
    };

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

class SvcTint implements IConvertible
{
    String? Field;
    String? Tone;
    String? Reason;
    double? Value;
    double? Reference;
    double? BranchValue;

    SvcTint({this.Field,this.Tone,this.Reason,this.Value,this.Reference,this.BranchValue});
    SvcTint.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Field = json['Field'];
        Tone = json['Tone'];
        Reason = json['Reason'];
        Value = JsonConverters.toDouble(json['Value']);
        Reference = JsonConverters.toDouble(json['Reference']);
        BranchValue = JsonConverters.toDouble(json['BranchValue']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Field': Field,
        'Tone': Tone,
        'Reason': Reason,
        'Value': Value,
        'Reference': Reference,
        'BranchValue': BranchValue
    };

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

class SvcMetrics implements IConvertible
{
    int? Checkins;
    int? Walkins;
    int? Appts;
    int? Served;
    int? NoShows;
    int? ApptNoShows;
    int? CancelledAtWindow;
    int? Abandoned;
    int? Called;
    int? CalledUp;
    double? AbandonRate;
    double? NoShowRate;
    double? AvgServiceSec;
    double? MedianServiceSec;
    double? AvgWaitSec;
    int? MaxWaitSec;
    double? AvgWalkUpSec;
    double? ExpectedServiceSec;
    int? SignedSec;
    int? ServingSec;
    int? PausedSec;
    int? IdleSec;
    int? UnstaffedSec;
    double? Utilization;
    double? IdleShare;
    double? PausedShare;
    int? Sessions;
    int? OpenDays;
    double? FeesEarned;
    double? AvgFee;
    double? FeesPerStaffedHour;
    double? ExpectedFeesPerStaffedHour;
    double? LaborCost;
    bool? LaborPartial;
    List<String>? MissingCostEmployeeIds = [];
    List<SvcNamedTime>? MissingCost = [];
    bool? LaborLocked;
    double? Contribution;
    double? LostFees;
    double? LostNoShowFees;
    Map<String,int?>? Mix = {};
    List<int>? HourlyServed = [];
    List<double>? HourlyFees = [];
    List<double>? HourlyCost = [];
    List<SvcTint>? Tints = [];

    SvcMetrics({this.Checkins,this.Walkins,this.Appts,this.Served,this.NoShows,this.ApptNoShows,this.CancelledAtWindow,this.Abandoned,this.Called,this.CalledUp,this.AbandonRate,this.NoShowRate,this.AvgServiceSec,this.MedianServiceSec,this.AvgWaitSec,this.MaxWaitSec,this.AvgWalkUpSec,this.ExpectedServiceSec,this.SignedSec,this.ServingSec,this.PausedSec,this.IdleSec,this.UnstaffedSec,this.Utilization,this.IdleShare,this.PausedShare,this.Sessions,this.OpenDays,this.FeesEarned,this.AvgFee,this.FeesPerStaffedHour,this.ExpectedFeesPerStaffedHour,this.LaborCost,this.LaborPartial,this.MissingCostEmployeeIds,this.MissingCost,this.LaborLocked,this.Contribution,this.LostFees,this.LostNoShowFees,this.Mix,this.HourlyServed,this.HourlyFees,this.HourlyCost,this.Tints});
    SvcMetrics.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Checkins = json['Checkins'];
        Walkins = json['Walkins'];
        Appts = json['Appts'];
        Served = json['Served'];
        NoShows = json['NoShows'];
        ApptNoShows = json['ApptNoShows'];
        CancelledAtWindow = json['CancelledAtWindow'];
        Abandoned = json['Abandoned'];
        Called = json['Called'];
        CalledUp = json['CalledUp'];
        AbandonRate = JsonConverters.toDouble(json['AbandonRate']);
        NoShowRate = JsonConverters.toDouble(json['NoShowRate']);
        AvgServiceSec = JsonConverters.toDouble(json['AvgServiceSec']);
        MedianServiceSec = JsonConverters.toDouble(json['MedianServiceSec']);
        AvgWaitSec = JsonConverters.toDouble(json['AvgWaitSec']);
        MaxWaitSec = json['MaxWaitSec'];
        AvgWalkUpSec = JsonConverters.toDouble(json['AvgWalkUpSec']);
        ExpectedServiceSec = JsonConverters.toDouble(json['ExpectedServiceSec']);
        SignedSec = json['SignedSec'];
        ServingSec = json['ServingSec'];
        PausedSec = json['PausedSec'];
        IdleSec = json['IdleSec'];
        UnstaffedSec = json['UnstaffedSec'];
        Utilization = JsonConverters.toDouble(json['Utilization']);
        IdleShare = JsonConverters.toDouble(json['IdleShare']);
        PausedShare = JsonConverters.toDouble(json['PausedShare']);
        Sessions = json['Sessions'];
        OpenDays = json['OpenDays'];
        FeesEarned = JsonConverters.toDouble(json['FeesEarned']);
        AvgFee = JsonConverters.toDouble(json['AvgFee']);
        FeesPerStaffedHour = JsonConverters.toDouble(json['FeesPerStaffedHour']);
        ExpectedFeesPerStaffedHour = JsonConverters.toDouble(json['ExpectedFeesPerStaffedHour']);
        LaborCost = JsonConverters.toDouble(json['LaborCost']);
        LaborPartial = json['LaborPartial'];
        MissingCostEmployeeIds = JsonConverters.fromJson(json['MissingCostEmployeeIds'],'List<String>',context!);
        MissingCost = JsonConverters.fromJson(json['MissingCost'],'List<SvcNamedTime>',context!);
        LaborLocked = json['LaborLocked'];
        Contribution = JsonConverters.toDouble(json['Contribution']);
        LostFees = JsonConverters.toDouble(json['LostFees']);
        LostNoShowFees = JsonConverters.toDouble(json['LostNoShowFees']);
        Mix = JsonConverters.fromJson(json['Mix'],'Map<String,int?>',context!);
        HourlyServed = JsonConverters.fromJson(json['HourlyServed'],'List<int>',context!);
        HourlyFees = JsonConverters.fromJson(json['HourlyFees'],'List<double>',context!);
        HourlyCost = JsonConverters.fromJson(json['HourlyCost'],'List<double>',context!);
        Tints = JsonConverters.fromJson(json['Tints'],'List<SvcTint>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Checkins': Checkins,
        'Walkins': Walkins,
        'Appts': Appts,
        'Served': Served,
        'NoShows': NoShows,
        'ApptNoShows': ApptNoShows,
        'CancelledAtWindow': CancelledAtWindow,
        'Abandoned': Abandoned,
        'Called': Called,
        'CalledUp': CalledUp,
        'AbandonRate': AbandonRate,
        'NoShowRate': NoShowRate,
        'AvgServiceSec': AvgServiceSec,
        'MedianServiceSec': MedianServiceSec,
        'AvgWaitSec': AvgWaitSec,
        'MaxWaitSec': MaxWaitSec,
        'AvgWalkUpSec': AvgWalkUpSec,
        'ExpectedServiceSec': ExpectedServiceSec,
        'SignedSec': SignedSec,
        'ServingSec': ServingSec,
        'PausedSec': PausedSec,
        'IdleSec': IdleSec,
        'UnstaffedSec': UnstaffedSec,
        'Utilization': Utilization,
        'IdleShare': IdleShare,
        'PausedShare': PausedShare,
        'Sessions': Sessions,
        'OpenDays': OpenDays,
        'FeesEarned': FeesEarned,
        'AvgFee': AvgFee,
        'FeesPerStaffedHour': FeesPerStaffedHour,
        'ExpectedFeesPerStaffedHour': ExpectedFeesPerStaffedHour,
        'LaborCost': LaborCost,
        'LaborPartial': LaborPartial,
        'MissingCostEmployeeIds': JsonConverters.toJson(MissingCostEmployeeIds,'List<String>',context!),
        'MissingCost': JsonConverters.toJson(MissingCost,'List<SvcNamedTime>',context!),
        'LaborLocked': LaborLocked,
        'Contribution': Contribution,
        'LostFees': LostFees,
        'LostNoShowFees': LostNoShowFees,
        'Mix': JsonConverters.toJson(Mix,'Map<String,int?>',context!),
        'HourlyServed': JsonConverters.toJson(HourlyServed,'List<int>',context!),
        'HourlyFees': JsonConverters.toJson(HourlyFees,'List<double>',context!),
        'HourlyCost': JsonConverters.toJson(HourlyCost,'List<double>',context!),
        'Tints': JsonConverters.toJson(Tints,'List<SvcTint>',context!)
    };

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

class SvcBranchRow implements IConvertible
{
    String? BranchId;
    String? Name;
    String? StateCode;
    String? ZoneCode;
    String? TimeZone;
    int? Windows;
    DateTime? RecordingSinceUtc;
    DateTime? SessionsSinceUtc;
    SvcMetrics? Metrics;

    SvcBranchRow({this.BranchId,this.Name,this.StateCode,this.ZoneCode,this.TimeZone,this.Windows,this.RecordingSinceUtc,this.SessionsSinceUtc,this.Metrics});
    SvcBranchRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        BranchId = json['BranchId'];
        Name = json['Name'];
        StateCode = json['StateCode'];
        ZoneCode = json['ZoneCode'];
        TimeZone = json['TimeZone'];
        Windows = json['Windows'];
        RecordingSinceUtc = JsonConverters.fromJson(json['RecordingSinceUtc'],'DateTime',context!);
        SessionsSinceUtc = JsonConverters.fromJson(json['SessionsSinceUtc'],'DateTime',context!);
        Metrics = JsonConverters.fromJson(json['Metrics'],'SvcMetrics',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'BranchId': BranchId,
        'Name': Name,
        'StateCode': StateCode,
        'ZoneCode': ZoneCode,
        'TimeZone': TimeZone,
        'Windows': Windows,
        'RecordingSinceUtc': JsonConverters.toJson(RecordingSinceUtc,'DateTime',context!),
        'SessionsSinceUtc': JsonConverters.toJson(SessionsSinceUtc,'DateTime',context!),
        'Metrics': JsonConverters.toJson(Metrics,'SvcMetrics',context!)
    };

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

class SvcWindowRow implements IConvertible
{
    String? StationId;
    String? Name;
    List<SvcNamedTime>? Clerks = [];
    bool? NeverStaffed;
    DateTime? LastStaffedUtc;
    String? LastStaffedBy;
    SvcMetrics? Metrics;

    SvcWindowRow({this.StationId,this.Name,this.Clerks,this.NeverStaffed,this.LastStaffedUtc,this.LastStaffedBy,this.Metrics});
    SvcWindowRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        StationId = json['StationId'];
        Name = json['Name'];
        Clerks = JsonConverters.fromJson(json['Clerks'],'List<SvcNamedTime>',context!);
        NeverStaffed = json['NeverStaffed'];
        LastStaffedUtc = JsonConverters.fromJson(json['LastStaffedUtc'],'DateTime',context!);
        LastStaffedBy = json['LastStaffedBy'];
        Metrics = JsonConverters.fromJson(json['Metrics'],'SvcMetrics',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'StationId': StationId,
        'Name': Name,
        'Clerks': JsonConverters.toJson(Clerks,'List<SvcNamedTime>',context!),
        'NeverStaffed': NeverStaffed,
        'LastStaffedUtc': JsonConverters.toJson(LastStaffedUtc,'DateTime',context!),
        'LastStaffedBy': LastStaffedBy,
        'Metrics': JsonConverters.toJson(Metrics,'SvcMetrics',context!)
    };

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

class SvcClerkRow implements IConvertible
{
    String? EmployeeId;
    String? Name;
    List<SvcNamedTime>? Windows = [];
    double? LoadedRate;
    bool? RateSet;
    bool? RateLocked;
    SvcMetrics? Metrics;

    SvcClerkRow({this.EmployeeId,this.Name,this.Windows,this.LoadedRate,this.RateSet,this.RateLocked,this.Metrics});
    SvcClerkRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        EmployeeId = json['EmployeeId'];
        Name = json['Name'];
        Windows = JsonConverters.fromJson(json['Windows'],'List<SvcNamedTime>',context!);
        LoadedRate = JsonConverters.toDouble(json['LoadedRate']);
        RateSet = json['RateSet'];
        RateLocked = json['RateLocked'];
        Metrics = JsonConverters.fromJson(json['Metrics'],'SvcMetrics',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'EmployeeId': EmployeeId,
        'Name': Name,
        'Windows': JsonConverters.toJson(Windows,'List<SvcNamedTime>',context!),
        'LoadedRate': LoadedRate,
        'RateSet': RateSet,
        'RateLocked': RateLocked,
        'Metrics': JsonConverters.toJson(Metrics,'SvcMetrics',context!)
    };

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

class SvcAverage implements IConvertible
{
    int? Count;
    double? Served;
    double? AvgServiceSec;
    double? MedianServiceSec;
    double? AvgWaitSec;
    double? Utilization;
    double? IdleSec;
    double? PausedSec;
    double? NoShows;
    double? SignedSec;
    double? FeesEarned;
    double? FeesPerStaffedHour;
    double? LaborCost;
    double? Contribution;
    double? LostNoShowFees;

    SvcAverage({this.Count,this.Served,this.AvgServiceSec,this.MedianServiceSec,this.AvgWaitSec,this.Utilization,this.IdleSec,this.PausedSec,this.NoShows,this.SignedSec,this.FeesEarned,this.FeesPerStaffedHour,this.LaborCost,this.Contribution,this.LostNoShowFees});
    SvcAverage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Count = json['Count'];
        Served = JsonConverters.toDouble(json['Served']);
        AvgServiceSec = JsonConverters.toDouble(json['AvgServiceSec']);
        MedianServiceSec = JsonConverters.toDouble(json['MedianServiceSec']);
        AvgWaitSec = JsonConverters.toDouble(json['AvgWaitSec']);
        Utilization = JsonConverters.toDouble(json['Utilization']);
        IdleSec = JsonConverters.toDouble(json['IdleSec']);
        PausedSec = JsonConverters.toDouble(json['PausedSec']);
        NoShows = JsonConverters.toDouble(json['NoShows']);
        SignedSec = JsonConverters.toDouble(json['SignedSec']);
        FeesEarned = JsonConverters.toDouble(json['FeesEarned']);
        FeesPerStaffedHour = JsonConverters.toDouble(json['FeesPerStaffedHour']);
        LaborCost = JsonConverters.toDouble(json['LaborCost']);
        Contribution = JsonConverters.toDouble(json['Contribution']);
        LostNoShowFees = JsonConverters.toDouble(json['LostNoShowFees']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Count': Count,
        'Served': Served,
        'AvgServiceSec': AvgServiceSec,
        'MedianServiceSec': MedianServiceSec,
        'AvgWaitSec': AvgWaitSec,
        'Utilization': Utilization,
        'IdleSec': IdleSec,
        'PausedSec': PausedSec,
        'NoShows': NoShows,
        'SignedSec': SignedSec,
        'FeesEarned': FeesEarned,
        'FeesPerStaffedHour': FeesPerStaffedHour,
        'LaborCost': LaborCost,
        'Contribution': Contribution,
        'LostNoShowFees': LostNoShowFees
    };

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

class SvcComparison implements IConvertible
{
    String? Mode;
    DateTime? FromDate;
    DateTime? ToDate;
    int? CutoffMinute;
    bool? HasData;
    SvcMetrics? Metrics;

    SvcComparison({this.Mode,this.FromDate,this.ToDate,this.CutoffMinute,this.HasData,this.Metrics});
    SvcComparison.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Mode = json['Mode'];
        FromDate = JsonConverters.fromJson(json['FromDate'],'DateTime',context!);
        ToDate = JsonConverters.fromJson(json['ToDate'],'DateTime',context!);
        CutoffMinute = json['CutoffMinute'];
        HasData = json['HasData'];
        Metrics = JsonConverters.fromJson(json['Metrics'],'SvcMetrics',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Mode': Mode,
        'FromDate': JsonConverters.toJson(FromDate,'DateTime',context!),
        'ToDate': JsonConverters.toJson(ToDate,'DateTime',context!),
        'CutoffMinute': CutoffMinute,
        'HasData': HasData,
        'Metrics': JsonConverters.toJson(Metrics,'SvcMetrics',context!)
    };

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

class SvcCoverageBucket implements IConvertible
{
    double? ServingPct;
    double? IdlePct;
    double? PausedPct;
    double? UnstaffedPct;

    SvcCoverageBucket({this.ServingPct,this.IdlePct,this.PausedPct,this.UnstaffedPct});
    SvcCoverageBucket.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ServingPct = JsonConverters.toDouble(json['ServingPct']);
        IdlePct = JsonConverters.toDouble(json['IdlePct']);
        PausedPct = JsonConverters.toDouble(json['PausedPct']);
        UnstaffedPct = JsonConverters.toDouble(json['UnstaffedPct']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ServingPct': ServingPct,
        'IdlePct': IdlePct,
        'PausedPct': PausedPct,
        'UnstaffedPct': UnstaffedPct
    };

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

class SvcCoverageRow implements IConvertible
{
    String? StationId;
    String? Name;
    List<SvcCoverageBucket>? Buckets = [];

    SvcCoverageRow({this.StationId,this.Name,this.Buckets});
    SvcCoverageRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        StationId = json['StationId'];
        Name = json['Name'];
        Buckets = JsonConverters.fromJson(json['Buckets'],'List<SvcCoverageBucket>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'StationId': StationId,
        'Name': Name,
        'Buckets': JsonConverters.toJson(Buckets,'List<SvcCoverageBucket>',context!)
    };

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

class SvcCoverage implements IConvertible
{
    int? StartLocalMinute;
    int? BucketMinutes;
    List<SvcCoverageRow>? Rows = [];
    List<double>? InLine = [];
    List<List<int>>? GapBands = [];
    int? Days;
    bool? NotRecorded;
    int? FutureFromIndex;

    SvcCoverage({this.StartLocalMinute,this.BucketMinutes,this.Rows,this.InLine,this.GapBands,this.Days,this.NotRecorded,this.FutureFromIndex});
    SvcCoverage.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        StartLocalMinute = json['StartLocalMinute'];
        BucketMinutes = json['BucketMinutes'];
        Rows = JsonConverters.fromJson(json['Rows'],'List<SvcCoverageRow>',context!);
        InLine = JsonConverters.fromJson(json['InLine'],'List<double>',context!);
        GapBands = JsonConverters.fromJson(json['GapBands'],'List<List<int>>',context!);
        Days = json['Days'];
        NotRecorded = json['NotRecorded'];
        FutureFromIndex = json['FutureFromIndex'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'StartLocalMinute': StartLocalMinute,
        'BucketMinutes': BucketMinutes,
        'Rows': JsonConverters.toJson(Rows,'List<SvcCoverageRow>',context!),
        'InLine': JsonConverters.toJson(InLine,'List<double>',context!),
        'GapBands': JsonConverters.toJson(GapBands,'List<List<int>>',context!),
        'Days': Days,
        'NotRecorded': NotRecorded,
        'FutureFromIndex': FutureFromIndex
    };

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

class SvcFeeChange implements IConvertible
{
    String? LocationId;
    DateTime? OnDate;
    double? FromFee;
    double? ToFee;

    SvcFeeChange({this.LocationId,this.OnDate,this.FromFee,this.ToFee});
    SvcFeeChange.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        LocationId = json['LocationId'];
        OnDate = JsonConverters.fromJson(json['OnDate'],'DateTime',context!);
        FromFee = JsonConverters.toDouble(json['FromFee']);
        ToFee = JsonConverters.toDouble(json['ToFee']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'LocationId': LocationId,
        'OnDate': JsonConverters.toJson(OnDate,'DateTime',context!),
        'FromFee': FromFee,
        'ToFee': ToFee
    };

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

class SvcServiceRow implements IConvertible
{
    String? LineId;
    String? Name;
    int? Completed;
    double? AvgServiceSec;
    double? BranchAvgServiceSec;
    double? FeesEarned;
    double? FeeCurrent;
    double? FeeMin;
    double? FeeMax;
    double? FeePerMinute;
    double? BranchFeePerMinute;
    List<SvcFeeChange>? FeeChanges = [];

    SvcServiceRow({this.LineId,this.Name,this.Completed,this.AvgServiceSec,this.BranchAvgServiceSec,this.FeesEarned,this.FeeCurrent,this.FeeMin,this.FeeMax,this.FeePerMinute,this.BranchFeePerMinute,this.FeeChanges});
    SvcServiceRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        LineId = json['LineId'];
        Name = json['Name'];
        Completed = json['Completed'];
        AvgServiceSec = JsonConverters.toDouble(json['AvgServiceSec']);
        BranchAvgServiceSec = JsonConverters.toDouble(json['BranchAvgServiceSec']);
        FeesEarned = JsonConverters.toDouble(json['FeesEarned']);
        FeeCurrent = JsonConverters.toDouble(json['FeeCurrent']);
        FeeMin = JsonConverters.toDouble(json['FeeMin']);
        FeeMax = JsonConverters.toDouble(json['FeeMax']);
        FeePerMinute = JsonConverters.toDouble(json['FeePerMinute']);
        BranchFeePerMinute = JsonConverters.toDouble(json['BranchFeePerMinute']);
        FeeChanges = JsonConverters.fromJson(json['FeeChanges'],'List<SvcFeeChange>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'LineId': LineId,
        'Name': Name,
        'Completed': Completed,
        'AvgServiceSec': AvgServiceSec,
        'BranchAvgServiceSec': BranchAvgServiceSec,
        'FeesEarned': FeesEarned,
        'FeeCurrent': FeeCurrent,
        'FeeMin': FeeMin,
        'FeeMax': FeeMax,
        'FeePerMinute': FeePerMinute,
        'BranchFeePerMinute': BranchFeePerMinute,
        'FeeChanges': JsonConverters.toJson(FeeChanges,'List<SvcFeeChange>',context!)
    };

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

class SvcHourRow implements IConvertible
{
    int? LocalHour;
    int? Served;
    double? FeesEarned;
    double? CostToStaff;

    SvcHourRow({this.LocalHour,this.Served,this.FeesEarned,this.CostToStaff});
    SvcHourRow.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        LocalHour = json['LocalHour'];
        Served = json['Served'];
        FeesEarned = JsonConverters.toDouble(json['FeesEarned']);
        CostToStaff = JsonConverters.toDouble(json['CostToStaff']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'LocalHour': LocalHour,
        'Served': Served,
        'FeesEarned': FeesEarned,
        'CostToStaff': CostToStaff
    };

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

class SvcAlert implements IConvertible
{
    String? Level;
    String? View;
    String? Code;
    String? StationId;
    String? EmployeeId;
    String? BranchId;
    String? LineId;
    String? Name;
    String? OtherLineId;
    String? OtherName;
    List<String>? StationIds = [];
    Map<String,double?>? Values = {};

    SvcAlert({this.Level,this.View,this.Code,this.StationId,this.EmployeeId,this.BranchId,this.LineId,this.Name,this.OtherLineId,this.OtherName,this.StationIds,this.Values});
    SvcAlert.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Level = json['Level'];
        View = json['View'];
        Code = json['Code'];
        StationId = json['StationId'];
        EmployeeId = json['EmployeeId'];
        BranchId = json['BranchId'];
        LineId = json['LineId'];
        Name = json['Name'];
        OtherLineId = json['OtherLineId'];
        OtherName = json['OtherName'];
        StationIds = JsonConverters.fromJson(json['StationIds'],'List<String>',context!);
        Values = JsonConverters.fromJson(json['Values'],'Map<String,double?>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Level': Level,
        'View': View,
        'Code': Code,
        'StationId': StationId,
        'EmployeeId': EmployeeId,
        'BranchId': BranchId,
        'LineId': LineId,
        'Name': Name,
        'OtherLineId': OtherLineId,
        'OtherName': OtherName,
        'StationIds': JsonConverters.toJson(StationIds,'List<String>',context!),
        'Values': JsonConverters.toJson(Values,'Map<String,double?>',context!)
    };

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

class SvcBranchDetail implements IConvertible
{
    SvcBranchRow? Branch;
    List<SvcWindowRow>? Windows = [];
    List<SvcClerkRow>? Clerks = [];
    SvcMetrics? Unassigned;
    SvcMetrics? NoClerk;
    SvcAverage? PerWindowAverage;
    SvcAverage? PerClerkAverage;
    int? OpenDays;
    bool? IsLive;
    SvcComparison? Comparison;
    SvcCoverage? Coverage;
    List<SvcServiceRow>? Services = [];
    List<SvcHourRow>? ByHour = [];
    List<SvcAlert>? Alerts = [];
    bool? TotalsAgree;
    bool? CanSeeStaff;
    bool? CanSeeFinancial;
    bool? CanSeePay;

    SvcBranchDetail({this.Branch,this.Windows,this.Clerks,this.Unassigned,this.NoClerk,this.PerWindowAverage,this.PerClerkAverage,this.OpenDays,this.IsLive,this.Comparison,this.Coverage,this.Services,this.ByHour,this.Alerts,this.TotalsAgree,this.CanSeeStaff,this.CanSeeFinancial,this.CanSeePay});
    SvcBranchDetail.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Branch = JsonConverters.fromJson(json['Branch'],'SvcBranchRow',context!);
        Windows = JsonConverters.fromJson(json['Windows'],'List<SvcWindowRow>',context!);
        Clerks = JsonConverters.fromJson(json['Clerks'],'List<SvcClerkRow>',context!);
        Unassigned = JsonConverters.fromJson(json['Unassigned'],'SvcMetrics',context!);
        NoClerk = JsonConverters.fromJson(json['NoClerk'],'SvcMetrics',context!);
        PerWindowAverage = JsonConverters.fromJson(json['PerWindowAverage'],'SvcAverage',context!);
        PerClerkAverage = JsonConverters.fromJson(json['PerClerkAverage'],'SvcAverage',context!);
        OpenDays = json['OpenDays'];
        IsLive = json['IsLive'];
        Comparison = JsonConverters.fromJson(json['Comparison'],'SvcComparison',context!);
        Coverage = JsonConverters.fromJson(json['Coverage'],'SvcCoverage',context!);
        Services = JsonConverters.fromJson(json['Services'],'List<SvcServiceRow>',context!);
        ByHour = JsonConverters.fromJson(json['ByHour'],'List<SvcHourRow>',context!);
        Alerts = JsonConverters.fromJson(json['Alerts'],'List<SvcAlert>',context!);
        TotalsAgree = json['TotalsAgree'];
        CanSeeStaff = json['CanSeeStaff'];
        CanSeeFinancial = json['CanSeeFinancial'];
        CanSeePay = json['CanSeePay'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Branch': JsonConverters.toJson(Branch,'SvcBranchRow',context!),
        'Windows': JsonConverters.toJson(Windows,'List<SvcWindowRow>',context!),
        'Clerks': JsonConverters.toJson(Clerks,'List<SvcClerkRow>',context!),
        'Unassigned': JsonConverters.toJson(Unassigned,'SvcMetrics',context!),
        'NoClerk': JsonConverters.toJson(NoClerk,'SvcMetrics',context!),
        'PerWindowAverage': JsonConverters.toJson(PerWindowAverage,'SvcAverage',context!),
        'PerClerkAverage': JsonConverters.toJson(PerClerkAverage,'SvcAverage',context!),
        'OpenDays': OpenDays,
        'IsLive': IsLive,
        'Comparison': JsonConverters.toJson(Comparison,'SvcComparison',context!),
        'Coverage': JsonConverters.toJson(Coverage,'SvcCoverage',context!),
        'Services': JsonConverters.toJson(Services,'List<SvcServiceRow>',context!),
        'ByHour': JsonConverters.toJson(ByHour,'List<SvcHourRow>',context!),
        'Alerts': JsonConverters.toJson(Alerts,'List<SvcAlert>',context!),
        'TotalsAgree': TotalsAgree,
        'CanSeeStaff': CanSeeStaff,
        'CanSeeFinancial': CanSeeFinancial,
        'CanSeePay': CanSeePay
    };

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

class KpiV2BranchResponse implements IConvertible
{
    ResponseStatus? ResponseStatus;
    SvcBranchDetail? Branch;

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

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

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

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

// @Route("/v1/dashboard/kpiv2/branch", "POST,OPTIONS")
class KpiV2BranchRequest implements IReturn<KpiV2BranchResponse>, IConvertible, IPost
{
    String? BranchId;
    DateTime? FromDate;
    DateTime? ToDate;
    String? Compare;

    KpiV2BranchRequest({this.BranchId,this.FromDate,this.ToDate,this.Compare});
    KpiV2BranchRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'BranchId': BranchId,
        'FromDate': JsonConverters.toJson(FromDate,'DateTime',context!),
        'ToDate': JsonConverters.toJson(ToDate,'DateTime',context!),
        'Compare': Compare
    };

    createResponse() => KpiV2BranchResponse();
    getResponseTypeName() => "KpiV2BranchResponse";
    getTypeName() => "KpiV2BranchRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'SvcNamedTime': TypeInfo(TypeOf.Class, create:() => SvcNamedTime()),
    'SvcTint': TypeInfo(TypeOf.Class, create:() => SvcTint()),
    'SvcMetrics': TypeInfo(TypeOf.Class, create:() => SvcMetrics()),
    'List<SvcNamedTime>': TypeInfo(TypeOf.Class, create:() => <SvcNamedTime>[]),
    'Map<String,int?>': TypeInfo(TypeOf.Class, create:() => Map<String,int?>()),
    'List<SvcTint>': TypeInfo(TypeOf.Class, create:() => <SvcTint>[]),
    'SvcBranchRow': TypeInfo(TypeOf.Class, create:() => SvcBranchRow()),
    'SvcWindowRow': TypeInfo(TypeOf.Class, create:() => SvcWindowRow()),
    'SvcClerkRow': TypeInfo(TypeOf.Class, create:() => SvcClerkRow()),
    'SvcAverage': TypeInfo(TypeOf.Class, create:() => SvcAverage()),
    'SvcComparison': TypeInfo(TypeOf.Class, create:() => SvcComparison()),
    'SvcCoverageBucket': TypeInfo(TypeOf.Class, create:() => SvcCoverageBucket()),
    'SvcCoverageRow': TypeInfo(TypeOf.Class, create:() => SvcCoverageRow()),
    'List<SvcCoverageBucket>': TypeInfo(TypeOf.Class, create:() => <SvcCoverageBucket>[]),
    'SvcCoverage': TypeInfo(TypeOf.Class, create:() => SvcCoverage()),
    'List<SvcCoverageRow>': TypeInfo(TypeOf.Class, create:() => <SvcCoverageRow>[]),
    'List<List<int>>': TypeInfo(TypeOf.Class, create:() => <List<int>>[]),
    'SvcFeeChange': TypeInfo(TypeOf.Class, create:() => SvcFeeChange()),
    'SvcServiceRow': TypeInfo(TypeOf.Class, create:() => SvcServiceRow()),
    'List<SvcFeeChange>': TypeInfo(TypeOf.Class, create:() => <SvcFeeChange>[]),
    'SvcHourRow': TypeInfo(TypeOf.Class, create:() => SvcHourRow()),
    'SvcAlert': TypeInfo(TypeOf.Class, create:() => SvcAlert()),
    'Map<String,double?>': TypeInfo(TypeOf.Class, create:() => Map<String,double?>()),
    'SvcBranchDetail': TypeInfo(TypeOf.Class, create:() => SvcBranchDetail()),
    'List<SvcWindowRow>': TypeInfo(TypeOf.Class, create:() => <SvcWindowRow>[]),
    'List<SvcClerkRow>': TypeInfo(TypeOf.Class, create:() => <SvcClerkRow>[]),
    'List<SvcServiceRow>': TypeInfo(TypeOf.Class, create:() => <SvcServiceRow>[]),
    'List<SvcHourRow>': TypeInfo(TypeOf.Class, create:() => <SvcHourRow>[]),
    'List<SvcAlert>': TypeInfo(TypeOf.Class, create:() => <SvcAlert>[]),
    'KpiV2BranchResponse': TypeInfo(TypeOf.Class, create:() => KpiV2BranchResponse()),
    'KpiV2BranchRequest': TypeInfo(TypeOf.Class, create:() => KpiV2BranchRequest()),
});