/* Options:
Date: 2026-08-01 07:37:17
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: CoverageNoShowFalseAlarmRequest.*
//ExcludeTypes: 
//DefaultImports: package:servicestack/servicestack.dart,dart:typed_data
*/

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

class CoverageExplanationSource implements IConvertible
{
    String? PolicyName;
    String? CascadeLevel;

    CoverageExplanationSource({this.PolicyName,this.CascadeLevel});
    CoverageExplanationSource.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'PolicyName': PolicyName,
        'CascadeLevel': CascadeLevel
    };

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

class CoverageExplanationOverride implements IConvertible
{
    String? Who;
    String? Consequence;

    CoverageExplanationOverride({this.Who,this.Consequence});
    CoverageExplanationOverride.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Who': Who,
        'Consequence': Consequence
    };

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

class CoverageExplanation implements IConvertible
{
    String? PlainSentence;
    String? RuleId;
    String? RuleName;
    String? Demand;
    CoverageExplanationSource? Source;
    String? Kind;
    String? WhyItExists;
    String? WhatWouldChangeIt;
    CoverageExplanationOverride? Override;
    String? Drill;

    CoverageExplanation({this.PlainSentence,this.RuleId,this.RuleName,this.Demand,this.Source,this.Kind,this.WhyItExists,this.WhatWouldChangeIt,this.Override,this.Drill});
    CoverageExplanation.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        PlainSentence = json['PlainSentence'];
        RuleId = json['RuleId'];
        RuleName = json['RuleName'];
        Demand = json['Demand'];
        Source = JsonConverters.fromJson(json['Source'],'CoverageExplanationSource',context!);
        Kind = json['Kind'];
        WhyItExists = json['WhyItExists'];
        WhatWouldChangeIt = json['WhatWouldChangeIt'];
        Override = JsonConverters.fromJson(json['Override'],'CoverageExplanationOverride',context!);
        Drill = json['Drill'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'PlainSentence': PlainSentence,
        'RuleId': RuleId,
        'RuleName': RuleName,
        'Demand': Demand,
        'Source': JsonConverters.toJson(Source,'CoverageExplanationSource',context!),
        'Kind': Kind,
        'WhyItExists': WhyItExists,
        'WhatWouldChangeIt': WhatWouldChangeIt,
        'Override': JsonConverters.toJson(Override,'CoverageExplanationOverride',context!),
        'Drill': Drill
    };

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

class CoverageCandidateCheck implements IConvertible
{
    String? CheckId;
    String? Result;
    CoverageExplanation? Expl;

    CoverageCandidateCheck({this.CheckId,this.Result,this.Expl});
    CoverageCandidateCheck.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CheckId = json['CheckId'];
        Result = json['Result'];
        Expl = JsonConverters.fromJson(json['Expl'],'CoverageExplanation',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CheckId': CheckId,
        'Result': Result,
        'Expl': JsonConverters.toJson(Expl,'CoverageExplanation',context!)
    };

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

class CoverageEffect implements IConvertible
{
    String? Icon;
    String? Text;
    String? RuleId;
    CoverageExplanation? Expl;

    CoverageEffect({this.Icon,this.Text,this.RuleId,this.Expl});
    CoverageEffect.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Icon = json['Icon'];
        Text = json['Text'];
        RuleId = json['RuleId'];
        Expl = JsonConverters.fromJson(json['Expl'],'CoverageExplanation',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Icon': Icon,
        'Text': Text,
        'RuleId': RuleId,
        'Expl': JsonConverters.toJson(Expl,'CoverageExplanation',context!)
    };

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

class CoverageCandidate implements IConvertible
{
    int? ContactId;
    String? Name;
    String? FirstName;
    String? Initials;
    int? Rank;
    String? DiffLine;
    String? CostLine;
    String? CostTone;
    CoverageExplanation? RankExpl;
    double? MarginPct;
    String? MarginTone;
    double? Loaded;
    double? Billed;
    double? OtHours;
    double? OtPremium;
    List<CoverageCandidateCheck>? Checks = [];
    List<CoverageEffect>? Preview = [];
    List<CoverageEffect>? Confirm = [];
    bool? HasWarn;

    CoverageCandidate({this.ContactId,this.Name,this.FirstName,this.Initials,this.Rank,this.DiffLine,this.CostLine,this.CostTone,this.RankExpl,this.MarginPct,this.MarginTone,this.Loaded,this.Billed,this.OtHours,this.OtPremium,this.Checks,this.Preview,this.Confirm,this.HasWarn});
    CoverageCandidate.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ContactId = json['ContactId'];
        Name = json['Name'];
        FirstName = json['FirstName'];
        Initials = json['Initials'];
        Rank = json['Rank'];
        DiffLine = json['DiffLine'];
        CostLine = json['CostLine'];
        CostTone = json['CostTone'];
        RankExpl = JsonConverters.fromJson(json['RankExpl'],'CoverageExplanation',context!);
        MarginPct = JsonConverters.toDouble(json['MarginPct']);
        MarginTone = json['MarginTone'];
        Loaded = JsonConverters.toDouble(json['Loaded']);
        Billed = JsonConverters.toDouble(json['Billed']);
        OtHours = JsonConverters.toDouble(json['OtHours']);
        OtPremium = JsonConverters.toDouble(json['OtPremium']);
        Checks = JsonConverters.fromJson(json['Checks'],'List<CoverageCandidateCheck>',context!);
        Preview = JsonConverters.fromJson(json['Preview'],'List<CoverageEffect>',context!);
        Confirm = JsonConverters.fromJson(json['Confirm'],'List<CoverageEffect>',context!);
        HasWarn = json['HasWarn'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ContactId': ContactId,
        'Name': Name,
        'FirstName': FirstName,
        'Initials': Initials,
        'Rank': Rank,
        'DiffLine': DiffLine,
        'CostLine': CostLine,
        'CostTone': CostTone,
        'RankExpl': JsonConverters.toJson(RankExpl,'CoverageExplanation',context!),
        'MarginPct': MarginPct,
        'MarginTone': MarginTone,
        'Loaded': Loaded,
        'Billed': Billed,
        'OtHours': OtHours,
        'OtPremium': OtPremium,
        'Checks': JsonConverters.toJson(Checks,'List<CoverageCandidateCheck>',context!),
        'Preview': JsonConverters.toJson(Preview,'List<CoverageEffect>',context!),
        'Confirm': JsonConverters.toJson(Confirm,'List<CoverageEffect>',context!),
        'HasWarn': HasWarn
    };

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

class CoverageBlockedCandidate implements IConvertible
{
    int? ContactId;
    String? Name;
    String? Initials;
    String? Reason;
    String? ChangeChip;
    CoverageExplanation? Expl;

    CoverageBlockedCandidate({this.ContactId,this.Name,this.Initials,this.Reason,this.ChangeChip,this.Expl});
    CoverageBlockedCandidate.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        ContactId = json['ContactId'];
        Name = json['Name'];
        Initials = json['Initials'];
        Reason = json['Reason'];
        ChangeChip = json['ChangeChip'];
        Expl = JsonConverters.fromJson(json['Expl'],'CoverageExplanation',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'ContactId': ContactId,
        'Name': Name,
        'Initials': Initials,
        'Reason': Reason,
        'ChangeChip': ChangeChip,
        'Expl': JsonConverters.toJson(Expl,'CoverageExplanation',context!)
    };

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

class CoverageOfferInfo implements IConvertible
{
    int? CoverageOfferId;
    int? ContactId;
    String? Name;
    int? Ring;
    String? Channel;
    String? Status;
    DateTime? SentAtUtc;
    DateTime? RespondedAtUtc;

    CoverageOfferInfo({this.CoverageOfferId,this.ContactId,this.Name,this.Ring,this.Channel,this.Status,this.SentAtUtc,this.RespondedAtUtc});
    CoverageOfferInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CoverageOfferId = json['CoverageOfferId'];
        ContactId = json['ContactId'];
        Name = json['Name'];
        Ring = json['Ring'];
        Channel = json['Channel'];
        Status = json['Status'];
        SentAtUtc = JsonConverters.fromJson(json['SentAtUtc'],'DateTime',context!);
        RespondedAtUtc = JsonConverters.fromJson(json['RespondedAtUtc'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CoverageOfferId': CoverageOfferId,
        'ContactId': ContactId,
        'Name': Name,
        'Ring': Ring,
        'Channel': Channel,
        'Status': Status,
        'SentAtUtc': JsonConverters.toJson(SentAtUtc,'DateTime',context!),
        'RespondedAtUtc': JsonConverters.toJson(RespondedAtUtc,'DateTime',context!)
    };

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

class CoverageApprovalInfo implements IConvertible
{
    int? CoverageApprovalId;
    int? CoverageGapId;
    String? Type;
    String? Status;
    DateTime? RequestedAtUtc;
    List<CoverageEffect>? Effects = [];
    int? ContactId;
    String? ContactName;
    DateTime? DecidedAtUtc;
    String? DecisionNote;

    CoverageApprovalInfo({this.CoverageApprovalId,this.CoverageGapId,this.Type,this.Status,this.RequestedAtUtc,this.Effects,this.ContactId,this.ContactName,this.DecidedAtUtc,this.DecisionNote});
    CoverageApprovalInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CoverageApprovalId = json['CoverageApprovalId'];
        CoverageGapId = json['CoverageGapId'];
        Type = json['Type'];
        Status = json['Status'];
        RequestedAtUtc = JsonConverters.fromJson(json['RequestedAtUtc'],'DateTime',context!);
        Effects = JsonConverters.fromJson(json['Effects'],'List<CoverageEffect>',context!);
        ContactId = json['ContactId'];
        ContactName = json['ContactName'];
        DecidedAtUtc = JsonConverters.fromJson(json['DecidedAtUtc'],'DateTime',context!);
        DecisionNote = json['DecisionNote'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CoverageApprovalId': CoverageApprovalId,
        'CoverageGapId': CoverageGapId,
        'Type': Type,
        'Status': Status,
        'RequestedAtUtc': JsonConverters.toJson(RequestedAtUtc,'DateTime',context!),
        'Effects': JsonConverters.toJson(Effects,'List<CoverageEffect>',context!),
        'ContactId': ContactId,
        'ContactName': ContactName,
        'DecidedAtUtc': JsonConverters.toJson(DecidedAtUtc,'DateTime',context!),
        'DecisionNote': DecisionNote
    };

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

class CoverageGapEventInfo implements IConvertible
{
    String? EventType;
    String? Channel;
    String? Detail;
    String? ContactName;
    DateTime? AtUtc;

    CoverageGapEventInfo({this.EventType,this.Channel,this.Detail,this.ContactName,this.AtUtc});
    CoverageGapEventInfo.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        EventType = json['EventType'];
        Channel = json['Channel'];
        Detail = json['Detail'];
        ContactName = json['ContactName'];
        AtUtc = JsonConverters.fromJson(json['AtUtc'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'EventType': EventType,
        'Channel': Channel,
        'Detail': Detail,
        'ContactName': ContactName,
        'AtUtc': JsonConverters.toJson(AtUtc,'DateTime',context!)
    };

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

class CoverageMoveOption implements IConvertible
{
    String? Key;
    String? Label;
    String? Detail;
    CoverageExplanation? Expl;

    CoverageMoveOption({this.Key,this.Label,this.Detail,this.Expl});
    CoverageMoveOption.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Key = json['Key'];
        Label = json['Label'];
        Detail = json['Detail'];
        Expl = JsonConverters.fromJson(json['Expl'],'CoverageExplanation',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Key': Key,
        'Label': Label,
        'Detail': Detail,
        'Expl': JsonConverters.toJson(Expl,'CoverageExplanation',context!)
    };

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

class CoverageNoShowAttempt implements IConvertible
{
    DateTime? AtUtc;
    String? Channel;
    String? Note;

    CoverageNoShowAttempt({this.AtUtc,this.Channel,this.Note});
    CoverageNoShowAttempt.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AtUtc = JsonConverters.fromJson(json['AtUtc'],'DateTime',context!);
        Channel = json['Channel'];
        Note = json['Note'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AtUtc': JsonConverters.toJson(AtUtc,'DateTime',context!),
        'Channel': Channel,
        'Note': Note
    };

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

class CoverageNoShowState implements IConvertible
{
    DateTime? GraceUntilUtc;
    List<CoverageNoShowAttempt>? Attempts = [];
    DateTime? DeclaredAtUtc;
    bool? AttendanceNote;
    bool? FalseAlarm;

    CoverageNoShowState({this.GraceUntilUtc,this.Attempts,this.DeclaredAtUtc,this.AttendanceNote,this.FalseAlarm});
    CoverageNoShowState.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        GraceUntilUtc = JsonConverters.fromJson(json['GraceUntilUtc'],'DateTime',context!);
        Attempts = JsonConverters.fromJson(json['Attempts'],'List<CoverageNoShowAttempt>',context!);
        DeclaredAtUtc = JsonConverters.fromJson(json['DeclaredAtUtc'],'DateTime',context!);
        AttendanceNote = json['AttendanceNote'];
        FalseAlarm = json['FalseAlarm'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'GraceUntilUtc': JsonConverters.toJson(GraceUntilUtc,'DateTime',context!),
        'Attempts': JsonConverters.toJson(Attempts,'List<CoverageNoShowAttempt>',context!),
        'DeclaredAtUtc': JsonConverters.toJson(DeclaredAtUtc,'DateTime',context!),
        'AttendanceNote': AttendanceNote,
        'FalseAlarm': FalseAlarm
    };

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

class CoverageLeaveCheckpoint implements IConvertible
{
    DateTime? AtUtc;
    String? Note;
    String? ByName;

    CoverageLeaveCheckpoint({this.AtUtc,this.Note,this.ByName});
    CoverageLeaveCheckpoint.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        AtUtc = JsonConverters.fromJson(json['AtUtc'],'DateTime',context!);
        Note = json['Note'];
        ByName = json['ByName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'AtUtc': JsonConverters.toJson(AtUtc,'DateTime',context!),
        'Note': Note,
        'ByName': ByName
    };

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

class CoverageLeaveState implements IConvertible
{
    bool? Fmla;
    DateTime? Began;
    DateTime? EstReturn;
    int? CheckpointDays;
    DateTime? NextCheckpointUtc;
    List<CoverageLeaveCheckpoint>? Checkpoints = [];
    int? InterimContactId;
    String? InterimName;
    DateTime? InterimStart;
    DateTime? InterimEnd;
    bool? RequisitionOpened;
    int? StaffPostingId;
    List<int>? ChainedGapIds = [];
    int? ParentLeaveGapId;
    DateTime? RestoredAtUtc;

    CoverageLeaveState({this.Fmla,this.Began,this.EstReturn,this.CheckpointDays,this.NextCheckpointUtc,this.Checkpoints,this.InterimContactId,this.InterimName,this.InterimStart,this.InterimEnd,this.RequisitionOpened,this.StaffPostingId,this.ChainedGapIds,this.ParentLeaveGapId,this.RestoredAtUtc});
    CoverageLeaveState.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Fmla = json['Fmla'];
        Began = JsonConverters.fromJson(json['Began'],'DateTime',context!);
        EstReturn = JsonConverters.fromJson(json['EstReturn'],'DateTime',context!);
        CheckpointDays = json['CheckpointDays'];
        NextCheckpointUtc = JsonConverters.fromJson(json['NextCheckpointUtc'],'DateTime',context!);
        Checkpoints = JsonConverters.fromJson(json['Checkpoints'],'List<CoverageLeaveCheckpoint>',context!);
        InterimContactId = json['InterimContactId'];
        InterimName = json['InterimName'];
        InterimStart = JsonConverters.fromJson(json['InterimStart'],'DateTime',context!);
        InterimEnd = JsonConverters.fromJson(json['InterimEnd'],'DateTime',context!);
        RequisitionOpened = json['RequisitionOpened'];
        StaffPostingId = json['StaffPostingId'];
        ChainedGapIds = JsonConverters.fromJson(json['ChainedGapIds'],'List<int>',context!);
        ParentLeaveGapId = json['ParentLeaveGapId'];
        RestoredAtUtc = JsonConverters.fromJson(json['RestoredAtUtc'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'Fmla': Fmla,
        'Began': JsonConverters.toJson(Began,'DateTime',context!),
        'EstReturn': JsonConverters.toJson(EstReturn,'DateTime',context!),
        'CheckpointDays': CheckpointDays,
        'NextCheckpointUtc': JsonConverters.toJson(NextCheckpointUtc,'DateTime',context!),
        'Checkpoints': JsonConverters.toJson(Checkpoints,'List<CoverageLeaveCheckpoint>',context!),
        'InterimContactId': InterimContactId,
        'InterimName': InterimName,
        'InterimStart': JsonConverters.toJson(InterimStart,'DateTime',context!),
        'InterimEnd': JsonConverters.toJson(InterimEnd,'DateTime',context!),
        'RequisitionOpened': RequisitionOpened,
        'StaffPostingId': StaffPostingId,
        'ChainedGapIds': JsonConverters.toJson(ChainedGapIds,'List<int>',context!),
        'ParentLeaveGapId': ParentLeaveGapId,
        'RestoredAtUtc': JsonConverters.toJson(RestoredAtUtc,'DateTime',context!)
    };

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

class CoverageGap implements IConvertible
{
    int? CoverageGapId;
    String? CoverageGapUID;
    String? BranchId;
    String? Status;
    String? Track;
    int? OutContactID;
    String? OutName;
    String? OutInitials;
    int? JobID;
    String? JobName;
    int? ProjectID;
    int? WorkerScheduleItemID;
    DateTime? WindowStart;
    DateTime? WindowEnd;
    String? Reason;
    bool? MustFill;
    CoverageExplanation? MustFillExpl;
    int? FilledByContactID;
    String? FilledByName;
    String? RecordNo;
    int? DecidedPolicyVersionId;
    DateTime? CreatedAt;
    DateTime? UpdatedAt;
    String? QualifiedLine;
    List<CoverageCandidate>? Candidates = [];
    List<CoverageBlockedCandidate>? Blocked = [];
    List<CoverageOfferInfo>? Offers = [];
    List<CoverageApprovalInfo>? Approvals = [];
    List<CoverageGapEventInfo>? Timeline = [];
    List<CoverageMoveOption>? MoveOptions = [];
    CoverageExplanation? OrderExpl;
    String? AssignmentMode;
    CoverageNoShowState? NoShow;
    CoverageLeaveState? Leave;
    String? CustomerName;

    CoverageGap({this.CoverageGapId,this.CoverageGapUID,this.BranchId,this.Status,this.Track,this.OutContactID,this.OutName,this.OutInitials,this.JobID,this.JobName,this.ProjectID,this.WorkerScheduleItemID,this.WindowStart,this.WindowEnd,this.Reason,this.MustFill,this.MustFillExpl,this.FilledByContactID,this.FilledByName,this.RecordNo,this.DecidedPolicyVersionId,this.CreatedAt,this.UpdatedAt,this.QualifiedLine,this.Candidates,this.Blocked,this.Offers,this.Approvals,this.Timeline,this.MoveOptions,this.OrderExpl,this.AssignmentMode,this.NoShow,this.Leave,this.CustomerName});
    CoverageGap.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        CoverageGapId = json['CoverageGapId'];
        CoverageGapUID = json['CoverageGapUID'];
        BranchId = json['BranchId'];
        Status = json['Status'];
        Track = json['Track'];
        OutContactID = json['OutContactID'];
        OutName = json['OutName'];
        OutInitials = json['OutInitials'];
        JobID = json['JobID'];
        JobName = json['JobName'];
        ProjectID = json['ProjectID'];
        WorkerScheduleItemID = json['WorkerScheduleItemID'];
        WindowStart = JsonConverters.fromJson(json['WindowStart'],'DateTime',context!);
        WindowEnd = JsonConverters.fromJson(json['WindowEnd'],'DateTime',context!);
        Reason = json['Reason'];
        MustFill = json['MustFill'];
        MustFillExpl = JsonConverters.fromJson(json['MustFillExpl'],'CoverageExplanation',context!);
        FilledByContactID = json['FilledByContactID'];
        FilledByName = json['FilledByName'];
        RecordNo = json['RecordNo'];
        DecidedPolicyVersionId = json['DecidedPolicyVersionId'];
        CreatedAt = JsonConverters.fromJson(json['CreatedAt'],'DateTime',context!);
        UpdatedAt = JsonConverters.fromJson(json['UpdatedAt'],'DateTime',context!);
        QualifiedLine = json['QualifiedLine'];
        Candidates = JsonConverters.fromJson(json['Candidates'],'List<CoverageCandidate>',context!);
        Blocked = JsonConverters.fromJson(json['Blocked'],'List<CoverageBlockedCandidate>',context!);
        Offers = JsonConverters.fromJson(json['Offers'],'List<CoverageOfferInfo>',context!);
        Approvals = JsonConverters.fromJson(json['Approvals'],'List<CoverageApprovalInfo>',context!);
        Timeline = JsonConverters.fromJson(json['Timeline'],'List<CoverageGapEventInfo>',context!);
        MoveOptions = JsonConverters.fromJson(json['MoveOptions'],'List<CoverageMoveOption>',context!);
        OrderExpl = JsonConverters.fromJson(json['OrderExpl'],'CoverageExplanation',context!);
        AssignmentMode = json['AssignmentMode'];
        NoShow = JsonConverters.fromJson(json['NoShow'],'CoverageNoShowState',context!);
        Leave = JsonConverters.fromJson(json['Leave'],'CoverageLeaveState',context!);
        CustomerName = json['CustomerName'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'CoverageGapId': CoverageGapId,
        'CoverageGapUID': CoverageGapUID,
        'BranchId': BranchId,
        'Status': Status,
        'Track': Track,
        'OutContactID': OutContactID,
        'OutName': OutName,
        'OutInitials': OutInitials,
        'JobID': JobID,
        'JobName': JobName,
        'ProjectID': ProjectID,
        'WorkerScheduleItemID': WorkerScheduleItemID,
        'WindowStart': JsonConverters.toJson(WindowStart,'DateTime',context!),
        'WindowEnd': JsonConverters.toJson(WindowEnd,'DateTime',context!),
        'Reason': Reason,
        'MustFill': MustFill,
        'MustFillExpl': JsonConverters.toJson(MustFillExpl,'CoverageExplanation',context!),
        'FilledByContactID': FilledByContactID,
        'FilledByName': FilledByName,
        'RecordNo': RecordNo,
        'DecidedPolicyVersionId': DecidedPolicyVersionId,
        'CreatedAt': JsonConverters.toJson(CreatedAt,'DateTime',context!),
        'UpdatedAt': JsonConverters.toJson(UpdatedAt,'DateTime',context!),
        'QualifiedLine': QualifiedLine,
        'Candidates': JsonConverters.toJson(Candidates,'List<CoverageCandidate>',context!),
        'Blocked': JsonConverters.toJson(Blocked,'List<CoverageBlockedCandidate>',context!),
        'Offers': JsonConverters.toJson(Offers,'List<CoverageOfferInfo>',context!),
        'Approvals': JsonConverters.toJson(Approvals,'List<CoverageApprovalInfo>',context!),
        'Timeline': JsonConverters.toJson(Timeline,'List<CoverageGapEventInfo>',context!),
        'MoveOptions': JsonConverters.toJson(MoveOptions,'List<CoverageMoveOption>',context!),
        'OrderExpl': JsonConverters.toJson(OrderExpl,'CoverageExplanation',context!),
        'AssignmentMode': AssignmentMode,
        'NoShow': JsonConverters.toJson(NoShow,'CoverageNoShowState',context!),
        'Leave': JsonConverters.toJson(Leave,'CoverageLeaveState',context!),
        'CustomerName': CustomerName
    };

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

class CoverageGapResponse implements IConvertible
{
    CoverageGap? Gap;
    int? ChainedPreview;
    bool? CanSeePay;
    ResponseStatus? ResponseStatus;

    CoverageGapResponse({this.Gap,this.ChainedPreview,this.CanSeePay,this.ResponseStatus});
    CoverageGapResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'Gap': JsonConverters.toJson(Gap,'CoverageGap',context!),
        'ChainedPreview': ChainedPreview,
        'CanSeePay': CanSeePay,
        'ResponseStatus': JsonConverters.toJson(ResponseStatus,'ResponseStatus',context!)
    };

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

// @Route("/v1/coverage/gaps/{CoverageGapId}/noshow/falsealarm", "POST")
class CoverageNoShowFalseAlarmRequest implements IReturn<CoverageGapResponse>, IConvertible, IPost
{
    int? CoverageGapId;

    CoverageNoShowFalseAlarmRequest({this.CoverageGapId});
    CoverageNoShowFalseAlarmRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

    createResponse() => CoverageGapResponse();
    getResponseTypeName() => "CoverageGapResponse";
    getTypeName() => "CoverageNoShowFalseAlarmRequest";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'api.dev.dynamics.trendsic.com', types: <String, TypeInfo> {
    'CoverageExplanationSource': TypeInfo(TypeOf.Class, create:() => CoverageExplanationSource()),
    'CoverageExplanationOverride': TypeInfo(TypeOf.Class, create:() => CoverageExplanationOverride()),
    'CoverageExplanation': TypeInfo(TypeOf.Class, create:() => CoverageExplanation()),
    'CoverageCandidateCheck': TypeInfo(TypeOf.Class, create:() => CoverageCandidateCheck()),
    'CoverageEffect': TypeInfo(TypeOf.Class, create:() => CoverageEffect()),
    'CoverageCandidate': TypeInfo(TypeOf.Class, create:() => CoverageCandidate()),
    'List<CoverageCandidateCheck>': TypeInfo(TypeOf.Class, create:() => <CoverageCandidateCheck>[]),
    'List<CoverageEffect>': TypeInfo(TypeOf.Class, create:() => <CoverageEffect>[]),
    'CoverageBlockedCandidate': TypeInfo(TypeOf.Class, create:() => CoverageBlockedCandidate()),
    'CoverageOfferInfo': TypeInfo(TypeOf.Class, create:() => CoverageOfferInfo()),
    'CoverageApprovalInfo': TypeInfo(TypeOf.Class, create:() => CoverageApprovalInfo()),
    'CoverageGapEventInfo': TypeInfo(TypeOf.Class, create:() => CoverageGapEventInfo()),
    'CoverageMoveOption': TypeInfo(TypeOf.Class, create:() => CoverageMoveOption()),
    'CoverageNoShowAttempt': TypeInfo(TypeOf.Class, create:() => CoverageNoShowAttempt()),
    'CoverageNoShowState': TypeInfo(TypeOf.Class, create:() => CoverageNoShowState()),
    'List<CoverageNoShowAttempt>': TypeInfo(TypeOf.Class, create:() => <CoverageNoShowAttempt>[]),
    'CoverageLeaveCheckpoint': TypeInfo(TypeOf.Class, create:() => CoverageLeaveCheckpoint()),
    'CoverageLeaveState': TypeInfo(TypeOf.Class, create:() => CoverageLeaveState()),
    'List<CoverageLeaveCheckpoint>': TypeInfo(TypeOf.Class, create:() => <CoverageLeaveCheckpoint>[]),
    'CoverageGap': TypeInfo(TypeOf.Class, create:() => CoverageGap()),
    'List<CoverageCandidate>': TypeInfo(TypeOf.Class, create:() => <CoverageCandidate>[]),
    'List<CoverageBlockedCandidate>': TypeInfo(TypeOf.Class, create:() => <CoverageBlockedCandidate>[]),
    'List<CoverageOfferInfo>': TypeInfo(TypeOf.Class, create:() => <CoverageOfferInfo>[]),
    'List<CoverageApprovalInfo>': TypeInfo(TypeOf.Class, create:() => <CoverageApprovalInfo>[]),
    'List<CoverageGapEventInfo>': TypeInfo(TypeOf.Class, create:() => <CoverageGapEventInfo>[]),
    'List<CoverageMoveOption>': TypeInfo(TypeOf.Class, create:() => <CoverageMoveOption>[]),
    'CoverageGapResponse': TypeInfo(TypeOf.Class, create:() => CoverageGapResponse()),
    'CoverageNoShowFalseAlarmRequest': TypeInfo(TypeOf.Class, create:() => CoverageNoShowFalseAlarmRequest()),
});