@seniorsistemas/hcm-clocking-event-rule-nodejs 0.35.0

package/src/data/timeEvaluation/timeEvaluation.ts

@@ -0,0 +1,1540 @@
+import { DateUtils } from "../../utils/dateUtils";
+import { TimeEvaluationSituation } from "./timeEvaluationSituation";
+import { Interval, IntervalTypes, IntervalSubTypes } from "./interval";
+import { Workschedule, IntervalType } from './../foundation/workschedule';
+import { Workshift } from "./../foundation/workshift";
+import { SeparatedHours } from "./separatedHours";
+import { ContextReference } from "./../context/contextReference";
+import { ClockingEvent, ClockingEventOriginType } from "./clockingEvent";
+import { ObjectUtils } from "src/utils/object.utils";
+import { Schedules } from "./../schedules/schedules";
+import { Bridge } from "./../schedules/bridge";
+import { HourBankAccount } from "./../hourBank/hourBankAccount";
+import { TimeEvaluationSituationDefinitionHistory } from "./../definition/timeEvaluationSituationDefinitionHistory";
+import { Histories } from "./../histories/histories";
+import { JobPositionHistory } from "./../histories/jobPositionHistory";
+import { CompanyBranchHistory } from "./../histories/companyBranchHistory";
+import { EstimatedHours } from "./estimatedHours";
+import { TimeEvaluationHistory } from './../histories/timeEvaluationHistory';
+import { Syndicate } from "./../foundation/syndicate";
+import { EmploymentRelationshipHistory } from "./../histories/employmentRelationshipHistory";
+import { WorkscheduleChange } from "./../schedules/workscheduleChange";
+import { WorkshiftChange } from "./../schedules/workshiftChange";
+import { Readiness } from "./../schedules/readiness";
+import { OvertimeAuthorization } from "./../schedules/overtimeAuthorization";
+import { Compensation } from "./../schedules/compensation";
+import { WorkshiftHistory } from "./../histories/workshiftHistory";
+import { Holiday } from "./../foundation/holiday";
+import { LeaveHistory } from "./../histories/leaveHistory";
+import { CostCenter } from './../foundation/costCenter';
+import { Contract } from "./../contract/contract";
+
+
+/**
+ * Interface para os parâmetros do construtor de TimeEvaluation.
+ * @hidden
+ */
+export interface TimeEvaluationParams {
+    date: Date;
+    workscheduleId: string;
+    workscheduleWorkshiftId: string;
+    workshiftId: string;
+    timeEvaluationSituations: TimeEvaluationSituation[];
+    clockingEvents: ClockingEvent[];
+    intervals: Interval[];
+    schedules: Schedules;
+    histories: Histories;
+    hourBankAccounts: HourBankAccount[];
+    situationDefinitionKey: string;
+    estimatedHours: EstimatedHours;
+    syndicateKey: string;
+    holiday?: Holiday;
+    missingClockingEvent: boolean;
+    costCenterKey: string;
+}
+
+
+/**
+ * Representa a apuração de ponto e as apurações acontecem diariamente.
+ * 
+ * Nesta classe podem ser encontradas as informações:
+ * - Data da apuração.
+ * - Horário de trabalho.
+ * - Escala do dia.
+ * - Situações apuradas, bem com alterar essas situações.
+ * - Marcações de ponto do colaborador.
+ * - Intervalos apurados, como por exemplo, faltas, atrasos, extras, etc.
+ * - Programações de horários, como por exemplo, pontes e trocas de horário.
+ * - Histórico de apuração de ponto, como por exemplo, históricos de cargo, sindicato e filial.
+ * - Contas de banco de horas do colaborador.
+ * - Gerenciar as pendências do dia.
+ * 
+ * Exemplo de uso:
+ * ```typescript
+ *  timeEvaluation.setSituationHour(15, 60); // Define 60 minutos na situação 15 (faltas).
+ *  timeEvaluation.sumSituationHour(16, 30); // Soma 30 minutos na situação 16 (extras).
+ *  const hours = timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas).
+ *  timeEvaluation.resetSituationHour(15); // Zera a quantidade de horas da situação 15 (faltas).
+ *  timeEvaluation.resetSituationHourByCodes(15, 16); // Zera a quantidade de horas das situações 15 e 16 (faltas e extras).
+ * 
+ *  const separatedHours = timeEvaluation.getSeparateHours(IntervalTypes.ABSENCE, true); // Retorna as horas apuradas separadas em diurnas, noturnas e o total, do tipo de intervalo falta, considerando tolerância.
+ *  const separatedHoursWithPart = timeEvaluation.getSeparateHoursWithExpedientPart(IntervalTypes.ABSENCE, 1, true); // Retorna as horas apuradas separadas em diurnas, noturnas e o total, do tipo de intervalo falta, e primeira parte do expediente, considerando tolerância.
+ *  const separatedHoursIntervalSubType = timeEvaluation.getSeparateHoursIntervalSubType(IntervalSubTypes.DELAY, true); // Retorna as horas apuradas separadas em diurnas, noturnas e o total, do subtipo de intervalo atraso, considerando tolerância.
+ * ```
+ * 
+ * 
+ */
+export class TimeEvaluation {
+    /**
+     * Data da apuração.
+     */
+    private readonly _date: Date;
+    /**
+     * Indica se deve gerar ajustes pendentes para o dia apurado.
+     */
+    private _generatePendingAdjustment: boolean | undefined;
+
+    /**
+     * Horário de trabalho do dia apurado considerando trocas de horário, busca automática e pontes.
+     */
+    private readonly _workschedulId: string;
+    /**
+     * Horário de trabalho conforme a escala, considerando o histórico e as programações de troca de escala. 
+     * Não considera trocas de horário, busca automática e nem pontes.
+     */
+    private readonly _workscheduleWorkshiftId: string;
+    /**
+     * Escala.
+     */
+    private readonly _workshiftId: string;
+    /**
+     * Situações.
+     */
+    private readonly _timeEvaluationSituations: TimeEvaluationSituation[];
+    /**
+     * Marcações de ponto.
+     */
+    private readonly _clockingEvents: ClockingEvent[];
+    /**
+     * Intevalos de apuração.
+     */
+    private readonly _intervals: Interval[];
+
+    /**
+     * Programações de horários, como por exemplo, pontes e trocas de horário.
+     */
+    private readonly _schedules: Schedules;
+    /**
+     * Histórico de apuração de ponto, como por exemplo, históricos de cargo, sindicato filial.
+     */
+    private readonly _histories: Histories;
+
+    /**
+     * Contas de banco de horas do colaborador.
+     */
+    private readonly _hourBankAccounts: HourBankAccount[];
+    /**
+     * Mensagem de erro para dia inválido.
+     */
+    private _errorMessage = "";
+    /**
+     * Chave de definição de situação.
+     */
+    private readonly _situationDefinitionKey: string;
+    /**
+     * Previsão de horas.
+     */
+    private readonly _estimatedHours: EstimatedHours;
+    private readonly _syndicateKey: string;
+    private readonly _holiday: Holiday | undefined;
+    private readonly _costCenterKey: string;
+    private readonly _missingClockingEvent: boolean;
+
+
+    /** @hidden */
+    constructor(params: TimeEvaluationParams) {
+        this._date = ObjectUtils.toDateOrThrow(params.date, "timeEvaluation.date");
+        this._timeEvaluationSituations = [];
+        this._intervals = [];
+
+        this._workshiftId = params.workshiftId;
+        this._workschedulId = params.workscheduleId;
+        this._workscheduleWorkshiftId = params.workscheduleWorkshiftId;
+        this._clockingEvents = params.clockingEvents;
+        this._schedules = params.schedules;
+        this._histories = params.histories;
+        this._hourBankAccounts = params.hourBankAccounts;
+        this._situationDefinitionKey = params.situationDefinitionKey;
+        this._syndicateKey = params.syndicateKey;
+        this._holiday = params.holiday;
+        this._costCenterKey = params.costCenterKey;
+        this._missingClockingEvent = params.missingClockingEvent;
+
+        if (Array.isArray(params.timeEvaluationSituations)) {
+            for (const timeEvaluationSituationItem of params.timeEvaluationSituations) {
+                this._timeEvaluationSituations.push(
+                    TimeEvaluationSituation.clone(timeEvaluationSituationItem)
+                );
+            }
+        }
+
+        this.mapIntervals(params);
+
+        if (params.estimatedHours) {
+            this._estimatedHours = new EstimatedHours({
+                meal: params.estimatedHours.meal,
+                snack: params.estimatedHours.snack,
+                work: params.estimatedHours.work
+            });
+        }
+
+        this._clockingEvents = [];
+        if (Array.isArray(params.clockingEvents)) {
+            for (const event of params.clockingEvents) {
+                this._clockingEvents.push(new ClockingEvent(event));
+            }
+        }
+    }
+
+    private mapIntervals(params: TimeEvaluationParams) {
+        if (Array.isArray(params.intervals)) {
+            for (const intervalItem of params.intervals) {
+                this._intervals.push(Interval.clone(intervalItem));
+            }
+        }
+    }
+
+    /**
+     * Data de apuração.
+     * 
+     * @example
+     * ```typescript
+     * let date = timeEvaluation.date; // Retorna a data de apuração.
+     * ```
+     * 
+     * @returns Data de apuração.
+     */
+    get date(): Date {
+        return this._date;
+    }
+
+    /**
+     * Horário de trabalho do dia apurado considerando trocas de horário, busca automática e pontes.
+     * @hidden
+     */
+    private get workscheduleId(): string {
+        return this._workschedulId;
+    }
+
+    /**
+     * Horário de trabalho conforme a escala, considerando o histórico e as programações de troca de escala. 
+     * Não considera trocas de horário, busca automática e nem pontes.
+     * @hidden
+     */
+    private get workscheduleWorkshiftId(): string {
+        return this._workscheduleWorkshiftId;
+    }
+    /**
+     * Id da Escala
+     * @hidden
+     */
+    private get workshiftId(): string {
+        return this._workshiftId;
+    }
+
+    /**
+     * Horário de trabalho.
+     * 
+     * @example
+     * ```typescript
+     * let workschedule = timeEvaluation.workschedule; // Retorna o horário de trabalho do dia apurado.
+     * workschedule.code; // Retorna o código do horário de trabalho.
+     * ```
+     * @returns Horário de trabalho do dia apurado.
+     * @throws Se o horário de trabalho não for encontrado no contexto.
+     * @see {@link Workschedule}
+     */
+    get workschedule(): Workschedule {
+        const workschedule = ContextReference.getGlobalInstance().getWorkschedule(this._workschedulId);
+        if (!workschedule) {
+            throw new Error(`Workschedule with id ${this._workschedulId} not found`);
+        }
+        return workschedule;
+    }
+
+    /**
+     * Horário de trabalho conforme a escala, considerando o histórico e as programações de troca de escala. 
+     * Não considera trocas de horário, busca automática e nem pontes.
+     * 
+     * @example
+     * ```typescript
+     * let workscheduleWorkshift = timeEvaluation.workscheduleWorkshift; // Retorna o horário de trabalho conforme a escala do dia apurado.
+     * workscheduleWorkshift.code; // Retorna o código do horário de trabalho conforme a escala.
+     * ```
+     * @returns Horário de trabalho conforme a escala do dia apurado.
+     * @throws Se o horário de trabalho conforme a escala não for encontrado no contexto.
+     * @see {@link Workschedule}
+     */
+    get workscheduleWorkshift(): Workschedule {
+        const workshift = ContextReference.getGlobalInstance().getWorkschedule(this._workscheduleWorkshiftId);
+        if (!workshift) {
+            throw new Error(`Workschedule with id ${this._workscheduleWorkshiftId} not found`);
+        }
+        return workshift;
+    }
+
+    /**
+     * Escala apurada no dia.
+     * 
+     * @example
+     * ```typescript
+     * let workshift = timeEvaluation.workshift; // Retorna a escala apurada no dia.
+     * workshift.code; // Retorna o código da escala apurada no dia.
+     * ```
+     *  @returns Escala apurada no dia.
+     *  @throws Se a escala não for encontrada no contexto.
+     *  @see {@link Workshift}
+     */
+    get workshift(): Workshift {
+        const workshift = ContextReference.getGlobalInstance().getWorkshift(this._workshiftId);
+        if (!workshift) {
+            throw new Error(`Workshift with id ${this._workshiftId} not found`);
+        }
+        return workshift;
+    }
+
+    /**
+     * Lista das situações calculadas na apuração do dia.
+     * 
+     * @example
+     * ```typescript
+     * let situations = timeEvaluation.timeEvaluationSituations; // Retorna as situações calculadas na apuração do dia.
+     * situations.forEach(situation => {
+     *   console.log(situation.situationCode); // Exibe o código de cada situação.
+     *   console.log(situation.numberOfHours); // Exibe a quantidade de horas de cada situação.
+     * });
+     * ```
+     * @returns Lista de situações calculadas na apuração do dia.
+     * @see {@link TimeEvaluationSituation}
+     */
+    get timeEvaluationSituations(): TimeEvaluationSituation[] {
+        return this._timeEvaluationSituations;
+    }
+
+    /**
+     * Lista das marcações de ponto para o dia apurado.
+     * 
+     * @example
+     * ```typescript
+     * let clockingEvents = timeEvaluation.clockingEvents; // Retorna as marcações de ponto do dia apurado.
+     * clockingEvents.forEach(event => {
+     *   console.log(event.clockingTime); // Exibe o horário de cada marcação.
+     *  console.log(event.originType); // Exibe o tipo de origem da marcação.
+     * });
+     * ```
+     * @returns Lista de marcações de ponto do dia apurado.
+     * @see {@link ClockingEvent}
+     */
+    get clockingEvents(): ClockingEvent[] {
+        return this._clockingEvents;
+    }
+
+    /**
+     * Retorna uma lista de intervalos calculados na apuração.
+     * Referência no Controle de ponto: NumInt, MSaInD[], MSaInN[], MInExD[], MInExN[].
+     * 
+     * @example 
+     * ```typescript
+     * let intervals = timeEvaluation.intervals; // Retorna os intervalos calculados na apuração.
+     * intervals.forEach(interval => {
+     *  console.log(interval.clockingEventStart); // Exibe o horário inicial de cada intervalo.
+     *  console.log(interval.clockingEventEnd); // Exibe o horário final de cada intervalo.
+     *  console.log(interval.type); // Exibe o tipo de intervalo.
+     * });
+     * ```
+     *  
+     * @return Lista de intervalos de marcações no dia apurado.
+     * @see {@link Interval}
+     */
+    get intervals(): Interval[] {
+        return this._intervals;
+    }
+
+    /**
+     * Chave de identificação do sindicato.
+     * @hidden
+     */
+    private static syndicateKey(timeEvaluation: TimeEvaluation): string {
+        return timeEvaluation._syndicateKey;
+    }
+
+    /**
+     * Sindicato do histórico vigente no dia apurado.
+     * @example
+     * ```typescript
+     * let syndicate = timeEvaluation.syndicate; // Retorna o sindicato do histórico vigente no dia apurado.
+     * syndicate.code; // Retorna o código do sindicato.
+     * syndicate.nightStartHour; // Retorna a hora inicial do turno noturno do sindicato.
+     * syndicate.nightEndHour; // Retorna a hora final do turno noturno do sindicato.
+     * syndicate.minimumInterval4to6Hours; // Retorna o intervalo mínimo para jornada entre 4 e 6 horas do sindicato.
+     * ```
+     * 
+     * @returns Sindicato do histórico vigente no dia apurado.
+     * @throws Se o sindicato não for encontrado no contexto.
+     * @see {@link Syndicate}
+     */
+    get syndicate(): Syndicate {
+        const syndicate = ContextReference.getGlobalInstance().getSyndicate(this._syndicateKey);
+        if (!syndicate) {
+            throw new Error(`Syndicate with key ${this._syndicateKey} not found`);
+        }
+        return syndicate;
+    }
+
+    /**
+     * Chave de identificação do centro de custo.
+     */
+    private get costCenterKey(): string {
+        return this._costCenterKey;
+    }
+
+    /**
+     * Centro de custo do histórico vigente no dia apurado.
+     * @example
+     * ```typescript
+     * let costCenter = timeEvaluation.costCenter; // Retorna o centro de custo.
+     * costCenter.code; // Retorna o código do centro de custo.
+     * ```
+     * 
+     * @returns Centro de custo no dia apurado.
+     * @throws Se o centro de custo não for encontrado no contexto.
+     * @see {@link CostCenter}
+     */
+    get costCenter(): CostCenter {
+        const costCenter = ContextReference.getGlobalInstance().getCostCenter(this._costCenterKey);
+        if (!costCenter) {
+            throw new Error(`Cost center with key ${this._costCenterKey} not found`);
+        }
+        return costCenter;
+    }
+
+    /**
+     * Retorna a quantidade de Horas previstas para o dia em minutos.
+     * 
+     * @example
+     * ```typescript
+     * let estimatedHours = timeEvaluation.estimatedHours; // Retorna as horas previstas para o dia em minutos.
+     * estimatedHours.work; // Retorna as horas de trabalho previstas em minutos.
+     * estimatedHours.meal; // Retorna as horas de refeição previstas em minutos.
+     * estimatedHours.snack; // Retorna as horas de lanche previstas em minutos.
+     * ```
+     * @returns Horas previstas para o dia apurado.
+     * @see {@link EstimatedHours}
+     * 
+     */
+    get estimatedHours(): EstimatedHours {
+        return this._estimatedHours;
+    }
+
+    /**
+     * Atualiza a quantidade de horas de uma situação se existir ou cria uma nova situação com a quantidade de horas em minutos.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas), 100 minutos.
+     * timeEvaluation.setSituationHour(15, 120); // Define 120 minutos na situação 15 (faltas).
+     * timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas), agora 120 minutos.
+     * ```
+     * 
+     * @param situationCode Código da Situação.
+     * @param numberOfHours Quantidade de horas em minutos.
+     */
+    public setSituationHour(situationCode: number, numberOfHours: number): void {
+        const situation = this.findSituationByCode(situationCode);
+
+        if (situation) {
+            situation.numberOfHours = numberOfHours;
+        }
+
+        if (!situation && numberOfHours > 0) {
+            this.createTimeEvaluationSituation(situationCode, numberOfHours);
+        }
+    }
+
+    /**
+     * Soma uma quantidade de horas em uma situação em minutos.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas), 100 minutos.
+     * timeEvaluation.sumSituationHour(15, 30); // Soma 30 minutos na situação 15 (faltas).
+     * timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas) somando as horas, 130 minutos.
+     * ```
+     * 
+     * @param situationCode Código da situação.
+     * @param numberOfHours Quantidade de horas em minutos.
+     */
+    public sumSituationHour(situationCode: number, numberOfHours: number): void {
+        const situation = this.findSituationByCode(situationCode);
+
+        if (situation) {
+            situation.addNumberOfHours(numberOfHours);
+        } else {
+            this.createTimeEvaluationSituation(situationCode, numberOfHours);
+        }
+    }
+
+    /**
+     * Retorna a quantidade de horas de uma situação em minutos. Retorna 0 se não encontrar.
+     * 
+     * @example
+     * ```typescript
+     * let hours = timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas).
+     * ```
+     * 
+     * @param situationCode Código da situação.
+     * @returns Quantidade de horas em minutos conforme o código de situação.
+     */
+    public getSituationHour(situationCode: number): number {
+        const situation = this.findSituationByCode(situationCode);
+        return situation ? situation.numberOfHours : 0;
+    }
+
+    /**
+     * Rertorna a quantidade de horas de uma lista de situações em minutos. Retorna 0 se não encontrar.
+     * 
+     * @example
+     * ```typescript
+     * let hours = timeEvaluation.getSituationHourByCodes(15, 16); // Retorna a quantidade de horas em minutos das situações 15 (faltas) e 16 (extras).
+     * ```
+     * 
+     * @param situationCodes Lista de códigos da situação.
+     * @returns Quantidade de horas em minutos conforme o código de situação.
+     */
+    public getSituationHourByCodes(...situationCodes: number[]): number {
+        return situationCodes.reduce((totalHours, situationCode) => {
+            const situation = this.findSituationByCode(situationCode);
+            return totalHours + (situation ? situation.numberOfHours : 0);
+        }, 0);
+    }
+
+
+    /**
+     * Zera a quantidade de horas de uma situação.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas), 100 minutos.
+     * timeEvaluation.resetSituationHour(15); // Zera a quantidade de horas da situação 15 (faltas).
+     * timeEvaluation.getSituationHour(15); // Retorna 0, pois a situação foi zerada.
+     * ```
+     * 
+     * @param situationCode Código da situação.
+     */
+    public resetSituationHour(situationCode: number): void {
+        this.setSituationHour(situationCode, 0);
+    }
+
+    /**
+     * Zera a quantidade de horas de uma lista de situações.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas), 100 minutos.
+     * timeEvaluation.getSituationHour(16); // Retorna a quantidade de horas em minutos da situação 16 (extras), 50 minutos.
+     * timeEvaluation.resetSituationHourByCodes(15, 16); // Zera a quantidade de horas das situações 15 e 16 (faltas e extras).
+     * timeEvaluation.getSituationHour(15); // Retorna 0, pois a situação 15 foi zerada.
+     * timeEvaluation.getSituationHour(16); // Retorna 0, pois a situação 16 foi zerada.
+     * ```
+     * @param situationCodes Lista de códigos da situação.
+     */
+    public resetSituationHourByCodes(...situationCodes: number[]): void {
+        situationCodes.forEach((situationCode) => {
+            this.setSituationHour(situationCode, 0);
+        });
+    }
+
+    /**
+     * Zera a quantidade de horas de uma situação conforme faixa de códigos.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.getSituationHour(14); // Retorna a quantidade de horas em minutos da situação 14 (trabalhando), 120 minutos.
+     * timeEvaluation.getSituationHour(15); // Retorna a quantidade de horas em minutos da situação 15 (faltas), 100 minutos.
+     * timeEvaluation.getSituationHour(16); // Retorna a quantidade de horas em minutos da situação 16 (extras), 50 minutos.
+     * timeEvaluation.resetSituationHourByRange(15, 16); // Zera a quantidade de horas das situações entre os códigos 15 a 16 (faltas e extras).
+     * timeEvaluation.getSituationHour(14); // Retorna 120, pois a situação 14 não foi zerada.
+     * timeEvaluation.getSituationHour(15); // Retorna 0, pois a situação 15 foi zerada.
+     * timeEvaluation.getSituationHour(16); // Retorna 0, pois a situação 16 foi zerada.
+     * ```
+     * @param startCode Código de situação inicial da faixa.
+     * @param endCode Código de situração final da faixa.
+     */
+    public resetSituationHourByRange(startCode: number, endCode: number): void {
+        for (let situationCode = startCode; situationCode <= endCode; situationCode++) {
+            this.setSituationHour(situationCode, 0);
+        }
+    }
+
+    /**
+     * Retorna a soma das horas em minutos de uma faixa de situações. Retorna 0 se não encontrar situações com os códigos informados.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.setSituationHour(15, 60); // Define 60 minutos na situação 15 (faltas).
+     * timeEvaluation.setSituationHour(16, 30); // Define 30 minutos na situação 16 (extras).
+     * timeEvaluation.getSituationHourByRange(15, 16); // Retorna 90, pois soma 60 minutos da situação 15 e 30 minutos da situação 16.
+     * ```
+     * 
+     * @param startCode Código de situação inicial da faixa.
+     * @param endCode Código de situação final da faixa.
+     * @returns Soma das horas em minutos para as situações no intervalo da faixa.
+     */
+    public getSituationHourByRange(startCode: number, endCode: number): number {
+        const totalHours = 0;
+
+        if (startCode > endCode) {
+            throw new Error("startCode must be less than or equal to endCode");
+        }
+
+        const total = this.timeEvaluationSituations.filter(
+            (situation) => situation.situationCode >= startCode && situation.situationCode <= endCode
+        ).reduce((accumulator, situation) => {
+            return accumulator + situation.numberOfHours;
+        }, totalHours);
+
+        if (total > 0) {
+            return total;
+        }
+
+        return 0;
+    }
+
+    private findSituationByCode(situationCode: number): TimeEvaluationSituation | undefined {
+        return this._timeEvaluationSituations.find(
+            (timeEvaluationSituation) => timeEvaluationSituation.situationCode === situationCode
+        );
+    }
+
+    private createTimeEvaluationSituation(situationCode: number, numberOfHours: number): void {
+        const timeEvaluationSituation = new TimeEvaluationSituation({
+            numberOfHours,
+            situationCode,
+            situationId: ""
+        });
+        // Sujar o buffer
+        timeEvaluationSituation.numberOfHours = numberOfHours;
+        this._timeEvaluationSituations.push(timeEvaluationSituation);
+    }
+
+    /**
+     * Retorna a quantidade de horas em minutos de um tipo de intervalo com opção de considerar/desconsiderar a tolerância.
+     * 
+     * @example
+     * ```typescript
+     *  let separatedHours = timeEvaluation.getSeparateHours(IntervalTypes.ABSENCE, true); // Retorna as horas apuradas separadas em diurnas, noturnas e o total, do tipo de intervalo Falta, considerando tolerância.
+     *  separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     *  separatedHours.nightlyHours; // Retorna as horas noturnas em minutos.
+     *  separatedHours.total; // Retorna o total de horas (diurnas + noturnas) em minutos.
+     * ```
+     * 
+     * @param intervalType tipo do intervalo
+     * @param tolerance se deve aplicar as tolerâncias nos intervalos de faltas e extras
+     * @returns um objeto do tipo SeparatedHours que contém as horas diurnas e noturnas.
+     * 
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalTypes}
+     */
+    public getSeparateHours(intervalType: IntervalTypes, tolerance: boolean): SeparatedHours {
+        return this.handleEmptyIntervals(() => this.getHours(DateUtils.MIN_DATE, DateUtils.MAX_DATE, intervalType, tolerance));
+    }
+
+    /**
+     * Retorna a quantidade de horas diurnas e noturnas em minutos de uma parte do expediente. 
+     * A divisão do expediente em partes acontece na hora final dos intervalos do tipo meal (refeição).
+     * ```
+     * Representação das partes do expediente 
+     * 
+     *   |----------------------------------------expedient-----------------------------------------| 
+     *   |----------------------part(1)----------------------|---------------part(2)----------------|
+     * 08:00        10:00        10:15        12:00        13:30        16:30        16:45        18:00
+     *   |------------|------------|------------|------------|------------|------------|------------|
+     *   |   work(1)  |  snack(1)  |   work(2)  |   meal(1)  |   work(3)  |  snack(2)  |   work(4)  |
+     * ```
+     * @example 
+     * ```typescript
+     * let separatedHours = timeEvaluation.getSeparateHoursWithExpedientPart(IntervalTypes.ABSENCE, 1, true);
+     * // Retorna as horas apuradas separadas em diurnas, noturnas e o total, do tipo de intervalo falta, e primeira parte do expediente, considerando tolerância
+     * separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     * ```
+     * 
+     * 
+     * @param intervalType tipo do intervalo.
+     * @param part Parte. Ex.: 1, 2... Refere-se a cada parte do expediente que é gerado pelos intervalos de refeição.
+     * @param tolerance Se deve aplicar as tolerâncias nos intervalos de faltas e extras.
+     * @return Objeto do tipo SeparatedHours que contém as horas diurnas e noturnas.
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalTypes}
+     */
+    public getSeparateHoursWithExpedientPart(intervalType: IntervalTypes, part: number, tolerance: boolean): SeparatedHours {
+        return this.handleEmptyIntervals(() => this.getHoursWithExpedientPart(DateUtils.MIN_DATE, DateUtils.MAX_DATE, intervalType, part, tolerance));
+    }
+
+    /**
+     * Retorna a quantidade de horas diurnas e noturnas em minutos de um subtipo de intervalo.
+     * Referência no Controle de ponto: ApuDiu[], ApuNot[].
+     * 
+     * @example
+     * ```typescript
+     * let separatedHours = timeEvaluation.getSeparateHoursIntervalSubType(IntervalSubTypes.DELAY, true); // Retorna as horas em minutos apuradas separadas em diurnas, noturnas e o total, do subtipo de intervalo atraso, considerando tolerância.
+     * separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     * ```
+     * 
+     * @param intervalSubType Subtipo do intervalo.
+     * @param tolerance Se deve aplicar as tolerâncias nos intervalos de faltas e extras.
+     * @return Objeto do tipo SeparatedHours que contém as horas diurnas e noturnas.
+     * 
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalSubTypes}
+     * 
+     */
+    public getSeparateHoursIntervalSubType(intervalSubType: IntervalSubTypes, tolerance: boolean): SeparatedHours {
+        return this.handleEmptyIntervals(() => this.getHoursIntervalSubType(DateUtils.MIN_DATE, DateUtils.MAX_DATE, intervalSubType, tolerance));
+    }
+
+    /**
+     * Retorna a quantidade de horas diurnas e noturnas em minutos de um subtipo de intervalo numa parte do expediente. 
+     * A divisão do expediente em partes acontece na hora final dos intervalos do tipo meal (refeição).
+     * ```
+     * Representação das partes do expediente 
+     * 
+     *   |----------------------------------------expedient-----------------------------------------| 
+     *   |----------------------part(1)----------------------|---------------part(2)----------------|
+     * 08:00        10:00        10:15        12:00        13:30        16:30        16:45        18:00
+     *   |------------|------------|------------|------------|------------|------------|------------|
+     *   |   work(1)  |  snack(1)  |   work(2)  |   meal(1)  |   work(3)  |  snack(2)  |   work(4)  |
+     * ``` 
+     * @example
+     * ```typescript
+     * let separatedHours = timeEvaluation.getSeparateHoursIntervalSubTypeWithExpedientPart(IntervalSubTypes.DELAY, 1, true); // Retorna as horas apuradas separadas em diurnas, noturnas e o total, do subtipo de intervalo atraso, e primeira parte do expediente, considerando tolerância.
+     * separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     * ```
+     * 
+     * @param intervalSubType Subtipo do intervalo.
+     * @param part Parte. Ex.: 1, 2... Refere-se a cada parte do expediente que é gerado pelos intervalos de refeição.
+     * @param tolerance Se deve aplicar as tolerâncias nos intervalos de faltas e extras.
+     * @return Objeto do tipo SeparatedHours que contém as horas diurnas e noturnas.
+     * 
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalSubTypes}
+     */
+    public getSeparateHoursIntervalSubTypeWithExpedientPart(intervalSubType: IntervalSubTypes, part: number, tolerance: boolean): SeparatedHours {
+        return this.handleEmptyIntervals(() => this.getHoursIntervalSubTypeWithExpedientPart(DateUtils.MIN_DATE, DateUtils.MAX_DATE, intervalSubType, part, tolerance));
+    }
+
+    /**
+     * Retorna um determinado intervalo calculado na apuração pela sua posição.
+     * Referência no Controle de ponto: NumInt, MSaInD[], MSaInN[], MInExD[], MInExN[]. 
+     * 
+     * - ATENÇÃO: Index é baseado em 1, ou seja, o primeiro intervalo calculado tem índice 1. Se o índice for inválido (0 ou valor maior que a quantidade de intervalos), o método retornará undefined.
+     * @example
+     * ```typescript
+     * Interval interval = getCalculatedIntervalByIndex(1); // Retorna o primeiro intervalo calculado.
+     * ```
+     * 
+     * @param index Índice do intervalo calculado, o index inicia em 1.
+     * @return Um intervalo calculado, ou null se o índice for inválido.
+     * 
+     * @see {@link Interval}     
+     */
+    public getCalculatedIntervalByIndex(index: number): Interval | undefined {
+        const adjustedIndex = index - 1;
+        if (adjustedIndex >= 0 && adjustedIndex < this._intervals.length) {
+            return this._intervals[adjustedIndex];
+        }
+        return undefined;
+    }
+
+    /**
+     * Retorna um determinado intervalo calculado na apuração pelo seu tipo.
+     * 
+     * @example
+     * ```typescript
+     * Interval[] intervals = getCalculatedIntervalByType(IntervalTypes.WORKING); // Retorna os intervalos do tipo WORKING.
+     * intervals.forEach(interval => {
+     *   console.log(interval.clockingEventStart); // Exibe o horário inicial de cada intervalo.
+     *   console.log(interval.clockingEventEnd); // Exibe o horário final de cada intervalo.
+     * });
+     * ```
+     * 
+     * @param intervalType Tipo de intervalo.
+     * @return Um intervalo calculado na apuração pelo seu tipo.
+     * @see {@link IntervalTypes}
+     * @see {@link Interval}
+     * 
+     */
+    public getCalculatedIntervalByType(intervalType: IntervalTypes): Interval[] {
+        return this._intervals.filter(interval => interval.type === intervalType);
+    }
+
+    /**
+     * Retorna uma lista de intervalos calculados na apuração de um subtipo de intervalo.
+     * 
+     * @example
+     * ```typescript
+     * Interval[] intervals = getCalculatedIntervalBySubType(IntervalSubTypes.DELAY); // Retorna os intervalos do subtipo DELAY.
+     * intervals.forEach(interval => {
+     *  console.log(interval.clockingEventStart); // Exibe o horário inicial de cada intervalo.
+     *  console.log(interval.clockingEventEnd); // Exibe o horário final de cada intervalo.
+     * });
+     * ```
+     * 
+     * @param intervalSubType Subtipo de intervalo.
+     * @return Um subtipo de intervalo.
+     * 
+     * @see {@link IntervalSubTypes}
+     * @see {@link Interval}
+     */
+    public getCalculatedIntervalBySubType(intervalSubType: IntervalSubTypes): Interval[] {
+        return this._intervals.filter(interval => interval.subType === intervalSubType);
+    }
+
+    /**
+     * Retorna a quantidade de horas extras diurnas e noturnas em minutos dentro de um intervalo de tempo para o dia que está sendo calculado.
+     * Referência no Controle de ponto: ExtrasIntervalo.
+     * 
+     * @example
+     * ```typescript
+     * SeparatedHours overtime = timeEvaluation.getOvertimeByRangeTime(360, 480); // Retorna as horas extras diurnas e noturnas em minutos entre 06:00 e 08:00 no dia atual.
+     * overtime.dailyHours; // Retorna as horas extras diurnas em minutos.
+     * overtime.nightlyHours; // Retorna as horas extras noturnas em minutos.
+     * overtime.total; // Retorna o total de horas extras (diurnas + noturnas) em minutos.
+     * ```
+     * 
+     * @param startClocking Hora em minutos do início do intervalo.
+     * @param endClocking Hora em minutos do fim do intervalo.
+     * @return Objeto do tipo SeparatedHours que contém a quantidade de horas extras diurnas e noturnas em minutos dentro de um intervalo de tempo. 
+     * 
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalTypes}
+     * 
+     */
+    public getOvertimeByRangeTime(startClocking: number, endClocking: number): SeparatedHours {
+        const startClockingDate = DateUtils.addMinutes(this._date, startClocking);
+        const endClockingDate = DateUtils.addMinutes(this._date, endClocking);
+        return this.handleEmptyIntervals(() => this.getHours(startClockingDate, endClockingDate, IntervalTypes.OVERTIME, true));
+    }
+
+    /**
+     * Retorna uma lista com as marcações realizadas pelo colaborador que está sendo processado na data. 
+     * Caso não tenham marcações no dia o método irá retornar uma lista vazia.
+     * Referência no Controle de ponto: QtdMar, FLeMar, FPxMar, DatMar, HorMar, FncMar, RlgMar, OriMar, ConGer.
+     * 
+     * @example
+     * ```typescript
+     * ClockingEvent[] clockingEvents = timeEvaluation.getClockingEvents(true); // Retorna uma lista com as marcações realizadas pelo colaborador no dia apurado considerando as marcações geradas.
+     *  clockingEvents.forEach(event => {
+     *  console.log(event.clockingTime); // Exibe o horário de cada marcação.
+     *  console.log(event.originType); // Exibe o tipo de origem da marcação.
+     * });
+     * ```
+     * 
+     * @param isConsiderGenerated Indica se deve trazer as marcações geradas pelo sistema.
+     * @return Objetos do tipo ClockingEvent (marcações) realizadas pelo colaborador que está sendo processado na data.
+     * 
+     * @see {@link ClockingEvent}
+     * @see {@link ClockingEventOriginType}
+     * 
+     */
+    public getClockingEvents(isConsiderGenerated: boolean): ClockingEvent[] {
+        if (!this._clockingEvents?.length) {
+            return [];
+        }
+        if (isConsiderGenerated) {
+            return this._clockingEvents;
+        }
+        return this._clockingEvents.filter(
+            (clockingEvent) => clockingEvent.originType !== ClockingEventOriginType.GENERATED
+        );
+    }
+
+
+    /**
+     * Retorna a quantidade em minutos de horas separadas de um intervalo de tempo.
+     * 
+     * @example
+     * ```typescript
+     * SeparatedHours separatedHours = timeEvaluation.getHours(new Date('2023-01-01T08:00:00'), new Date('2023-01-01T18:00:00'), IntervalTypes.ABSENCE, true); // Retorna as horas apuradas separadas em diurnas, noturnas e o total, do tipo de intervalo falta, considerando tolerância.
+     * separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     * separatedHours.nightlyHours; // Retorna as horas noturnas em minutos.
+     * separatedHours.total; // Retorna o total de horas (diurnas + noturnas) em minutos.
+     * ```
+     * 
+     * @param startClocking Data de início.
+     * @param endClocking Data de fim.
+     * @param intervalType Tipo de intervalo.
+     * @param tolerance Considerar tolerância.
+     * @returns Horas separadas de um intervalo.
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalTypes}
+     * @see {@link Interval}
+     * 
+     */
+    private getHours(startClocking: Date, endClocking: Date, intervalType: IntervalTypes, tolerance: boolean): SeparatedHours {
+        const separatedHours = this.initializeSeparatedHours();
+
+        this.processIntervals(interval => {
+            const type = this.getIntervalType(interval, tolerance);
+            if (intervalType === type) {
+                separatedHours.sumSeparatedHours(this.calculateSeparateHours(startClocking, endClocking, interval));
+            }
+        });
+
+        return separatedHours;
+    }
+
+    /**
+     * Retorna a quantidade de horas separadas de um intervalo considerando o expediente e a parte do expediente.
+     * A divisão do expediente em partes acontece na hora final dos intervalos do tipo meal (refeição).
+     * ```
+     * Representação das partes do expediente 
+     * 
+     *   |----------------------------------------expedient-----------------------------------------| 
+     *   |----------------------part(1)----------------------|---------------part(2)----------------|
+     * 08:00        10:00        10:15        12:00        13:30        16:30        16:45        18:00
+     *   |------------|------------|------------|------------|------------|------------|------------|
+     *   |   work(1)  |  snack(1)  |   work(2)  |   meal(1)  |   work(3)  |  snack(2)  |   work(4)  |
+     * ```
+     * 
+     * @example
+     * ```typescript
+     * SeparatedHours separatedHours = timeEvaluation.getHoursWithExpedientPart(new Date('2023-01-01T08:00:00'), new Date('2023-01-01T18:00:00'), IntervalTypes.ABSENCE, 1, true); // Retorna em minutos as horas apuradas separadas em diurnas, noturnas e o total, do tipo de intervalo falta, considerando tolerância e a parte do expediente.
+     * separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     * separatedHours.nightlyHours; // Retorna as horas noturnas em minutos.
+     * separatedHours.total; // Retorna o total de horas (diurnas + noturnas) em minutos.
+     * ```
+     * 
+     * 
+     * @param startClocking Data de início.
+     * @param endClocking Data de fim.
+     * @param intervalType Tipo de intervalo.
+     * @param part Parte do expediente. Ex.: 1, 2...
+     * @param tolerance Considerar tolerância.
+     * @return Objeto do tipo SeparatedHours que contém as horas diurnas e noturnas.
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalTypes}
+     * @see {@link Interval}
+     * 
+     */
+    private getHoursWithExpedientPart(startClocking: Date, endClocking: Date, intervalType: IntervalTypes, part: number, tolerance: boolean): SeparatedHours {
+        const separatedHours = this.initializeSeparatedHours();
+
+        this.processIntervals(interval => {
+            const type = this.getIntervalType(interval, tolerance);
+            if (intervalType === type && interval.positionWorkingPart?.workingHours === 1 && interval.positionWorkingPart?.part === part) {
+                separatedHours.sumSeparatedHours(this.calculateSeparateHours(startClocking, endClocking, interval));
+            }
+        });
+
+        return separatedHours;
+    }
+
+    /**
+     * Retorna a quantidade de horas separadas de um subtipo de intervalo.
+     * 
+     * @example
+     * ```typescript
+     * SeparatedHours separatedHours = timeEvaluation.getHoursIntervalSubType(new Date('2023-01-01T08:00:00'), new Date('2023-01-01T18:00:00'), IntervalSubTypes.DELAY, true); // Retorna em minutos as horas apuradas separadas em diurnas, noturnas e o total, do subtipo de intervalo atraso, considerando tolerância.
+     * separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     * separatedHours.nightlyHours; // Retorna as horas noturnas em minutos.
+     * separatedHours.total; // Retorna o total de horas (diurnas + noturnas) em minutos.
+     * ```
+     * 
+     * @param startClocking Data de início.
+     * @param endClocking Data de fim.
+     * @param intervalSubType Subtipo de intervalo.
+     * @param tolerance Considerar tolerância.
+     * @return Objeto do tipo SeparatedHours que contém as horas diurnas e noturnas.
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalSubTypes}
+     * @see {@link Interval}
+     * 
+     */
+    private getHoursIntervalSubType(startClocking: Date, endClocking: Date, intervalSubType: IntervalSubTypes, tolerance: boolean): SeparatedHours {
+        const separatedHours = this.initializeSeparatedHours();
+
+        this.processIntervals(interval => {
+            const type = this.getIntervalSubType(interval, tolerance);
+            if (intervalSubType === type) {
+                separatedHours.sumSeparatedHours(this.calculateSeparateHours(startClocking, endClocking, interval));
+            }
+        });
+
+        return separatedHours;
+    }
+
+    /**
+     * Retorna em minutos a quantidade de horas separadas de um subtipo de intervalo considerando o a parte do expediente.
+     * 
+     * @example
+     * ```typescript
+     * SeparatedHours separatedHours = timeEvaluation.getHoursIntervalSubTypeWithExpedientPart(new Date('2023-01-01T08:00:00'), new Date('2023-01-01T18:00:00'), IntervalSubTypes.DELAY, 1, true); // Retorna em minutos as horas apuradas separadas em diurnas, noturnas e o total, do subtipo de intervalo atraso, considerando tolerância e a parte do expediente.
+     * separatedHours.dailyHours; // Retorna as horas diurnas em minutos.
+     * separatedHours.nightlyHours; // Retorna as horas noturnas em minutos.
+     * separatedHours.total; // Retorna o total de horas (diurnas + noturnas) em minutos.
+     * ```
+     * 
+     * @param startClocking Data de início.
+     * @param endClocking Data de fim.
+     * @param intervalSubType Subtipo de intervalo.
+     * @param part Parte do expediente. Ex.: 1, 2...
+     * @param tolerance Considerar tolerância.
+     * @return Objeto do tipo SeparatedHours que contém as horas diurnas e noturnas.
+     * @see {@link SeparatedHours}
+     * @see {@link IntervalSubTypes}
+     * @see {@link Interval}
+     * 
+     */
+    private getHoursIntervalSubTypeWithExpedientPart(startClocking: Date, endClocking: Date, intervalSubType: IntervalSubTypes, part: number, tolerance: boolean): SeparatedHours {
+        const separatedHours = this.initializeSeparatedHours();
+
+        this.processIntervals(interval => {
+            const type = this.getIntervalSubType(interval, tolerance);
+            if (intervalSubType === type && interval.positionWorkingPart?.workingHours === 1 && interval.positionWorkingPart?.part === part) {
+                separatedHours.sumSeparatedHours(this.calculateSeparateHours(startClocking, endClocking, interval));
+            }
+        });
+
+        return separatedHours;
+    }
+
+    private getIntervalType(interval: Interval, tolerance: boolean): IntervalTypes {
+        if (interval.isTolerancePeriod && !tolerance) {
+            return interval.typeIntervalTolerance;
+        }
+        return interval.type;
+    }
+
+    private getIntervalSubType(interval: Interval, tolerance: boolean): IntervalSubTypes {
+        if (interval.isTolerancePeriod && !tolerance) {
+            return interval.subTypeIntervalTolerance;
+        }
+        return interval.subType;
+    }
+
+    private initializeSeparatedHours(): SeparatedHours {
+        return new SeparatedHours({ dailyHours: 0, nightlyHours: 0 });
+    }
+
+    private handleEmptyIntervals<T>(callback: () => T): T {
+        if (!this.intervals?.length) {
+            return this.initializeSeparatedHours() as T;
+        }
+        return callback();
+    }
+
+    private processIntervals(callback: (interval: Interval) => void): void {
+        if (Array.isArray(this.intervals)) {
+            for (const interval of this.intervals) {
+                callback(interval);
+            }
+        }
+    }
+
+    private calculateSeparateHours(startClocking: Date, endClocking: Date, interval: Interval): SeparatedHours {
+        const separedHours = new SeparatedHours({ dailyHours: 0, nightlyHours: 0 });
+
+        if (DateUtils.isBeforeOrEquals(startClocking, interval.clockingEventStart) && DateUtils.isAfterOrEquals(endClocking, interval.clockingEventEnd)) {
+            this.sumCompleteInterval(interval, separedHours);
+        } else if (DateUtils.between(startClocking, interval.clockingEventStart, interval.clockingEventEnd) ||
+            DateUtils.between(endClocking, interval.clockingEventStart, interval.clockingEventEnd)) {
+            this.sumBetweenClocking(interval, endClocking, startClocking, separedHours);
+        }
+
+        return separedHours;
+    }
+
+    private sumCompleteInterval(interval: Interval, separedHours: SeparatedHours) {
+        if (!interval.isNightly) {
+            separedHours.sumDailyHours(interval.getIntervalInMinutes());
+        } else {
+            separedHours.sumNightlyHours(interval.getIntervalInMinutes());
+        }
+    }
+
+    private sumBetweenClocking(interval: Interval, endClocking: Date, startClocking: Date, separedHours: SeparatedHours) {
+        const menorFim = DateUtils.isBefore(interval.clockingEventEnd, endClocking) ? interval.clockingEventEnd : endClocking;
+        const maiorInicio = DateUtils.isAfter(interval.clockingEventStart, startClocking) ? interval.clockingEventStart : startClocking;
+        if (!interval.isNightly) {
+            separedHours.sumDailyHours(DateUtils.getDateInMinutes(menorFim, maiorInicio));
+        } else {
+            separedHours.sumNightlyHours(DateUtils.getDateInMinutes(menorFim, maiorInicio));
+        }
+    }
+
+    /**
+     * Invalida uma apuração. A apuração invalidada não será considerada no cálculo.
+     * A apuração não será alterada.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.invalidate("Erro na apuração, dados inconsistentes");
+     * ```
+     * 
+     * @param message Motivo.
+     */
+    public invalidate(message: string) {
+        this._errorMessage = message
+    }
+
+    /**
+     * Recupera a mensagem de erro de um dia invalidado.
+     * 
+     * @example
+     * ```typescript
+     * if (timeEvaluation.errorMessage) {
+     *   console.error(timeEvaluation.errorMessage);
+     * }
+     * ```
+     */
+    get errorMessage(): string {
+        return this._errorMessage;
+    }
+
+    /**
+     * Busca a ponte que corresponde a data de apuração, caso tenha ponte para a data de apuração, seja a data de origem ou a de destino.
+     * 
+     * @example
+     * ```typescript
+     * const bridge = timeEvaluation.bridge;
+     * if (bridge) {
+     *   console.log(`Ponte encontrada na data ${timeEvaluation.date}: origem: ${bridge.originDate}`);
+     * } else {
+     *  console.log(`Não foi encontrado ponte na data ${timeEvaluation.date}`);
+     * }
+     * ```
+     * 
+     * @return A ponte que corresponde ao critério ou undefined se não encontrar.
+     * 
+     * @see {@link Bridge}
+     */
+    get bridge(): Bridge | undefined {
+        return this._schedules.findBridgeByDate(this._date);
+    }
+
+    /**
+     * Busca a programação de autorização de horas extras para o dia apurado.
+     * Caso não exista uma programação de autorização de horas extras para o dia, retorna uma lista vazia.
+     * 
+     * @example
+     * ```typescript
+     * const overtimeAuthorizations = timeEvaluation.overtimeAuthorizations;
+     * if (overtimeAuthorizations.length > 0) {
+     *  console.log(`Autorização de hora extra encontrada na data${timeEvaluation.date}: ${overtimeAuthorizations.length}`);
+     * } else {
+     *  console.log(`Não foi encontrado autorização de hora extra na data ${timeEvaluation.date}`);
+     * }
+     * ```
+     * 
+     * @return A programação de autorização de horas extras ou uma lista vazia se não encontrar.
+     * 
+     * @see {@link OvertimeAuthorization}
+     */
+    get overtimeAuthorizations(): OvertimeAuthorization[] {
+        return this._schedules.findOvertimeAuthorizationByDate(this._date);
+    }
+
+    /**
+     * Retorna a troca de escala do colaborador no dia apurado.
+     * Caso não exista uma troca de escala para o dia, retorna undefined.
+     * 
+     * @example
+     * ```typescript
+     * const workshiftChange = timeEvaluation.workshiftChange;
+     * if (workshiftChange) {
+     *  console.log(`Troca de escala encontrada na data ${timeEvaluation.date}: ${workshiftChange.companyBranch.code}`);
+     * } else {
+     * console.log(`Não foi encontrada troca de escala na data ${timeEvaluation.date}`);
+     * }
+     * ```
+     * 
+     * @returns A troca de escala ou undefined se não encontrar.
+     * 
+     * @see {@link WorkshiftChange}
+     */
+    get workshiftChange(): WorkshiftChange | undefined {
+        return this._schedules.findWorkshiftChangeByDate(this._date);
+    }
+
+    /**
+     * Retorna uma ou mais programações de sobreaviso do colaborador no dia apurado.
+     * 
+     * @example
+     * ```typescript
+     * const readinesses = timeEvaluation.readinesses;
+     * if (readinesses.length > 0) {
+     *  console.log(`Programação de sobreaviso encontrado na data ${timeEvaluation.date}: ${readinesses.length}`);
+     * } else {
+     *  console.log(`Não foi encontrado programação de sobreaviso na data ${timeEvaluation.date}`);
+     * }
+     * ```
+     * @returns A programação de sobreaviso ou undefined se não encontrar.
+     * 
+     * @see {@link Readiness}
+     */
+    get readinesses(): Readiness[] {
+        return this._schedules.findReadinessByDate(this._date);
+    }
+
+    /**
+     * Retorna uma ou mais compensações de horas do colaborador no dia apurado.
+     * Caso não exista uma compensação de horas para o dia, retorna uma lista vazia.
+     * @example
+     * ```typescript
+     * const compensations = timeEvaluation.compensations;
+     * if (compensations.length > 0) {
+     *  console.log(`Compensação de horas encontrada na data ${timeEvaluation.date}: ${compensations.length}`);
+     * } else {
+     *  console.log(`Não foi encontrado compensação de horas na data ${timeEvaluation.date}`);
+     * }
+     * ```
+     * 
+     * @returns A lista de compensações de horas ou uma lista vazia se não encontrar.
+     * 
+     * @see {@link Compensation}
+     */
+    get compensations(): Compensation[] {
+        return this._schedules.findCompensationByDate(this._date);
+    }
+
+    /**
+     * Retorna o histórico de cargo da apuração.
+     * 
+     * @example
+     * ```typescript
+     *  const jobPositionHistory = timeEvaluation.jobPositionHistory;
+     *  console.log(`Histórico de cargo encontrado na data ${timeEvaluation.date}: ${jobPositionHistory.jobPosition}`);
+     * ```
+     * 
+     * @returns Histórico de cargo.
+     * 
+     * @see {@link JobPositionHistory}
+     */
+    get jobPositionHistory(): JobPositionHistory {
+        const jobPositionHistory = this._histories.findJobPositionByDate(this._date);
+
+        if (!jobPositionHistory) {
+            throw new Error(`Job position history for date ${this._date} not found`);
+        }
+
+        return jobPositionHistory;
+    }
+
+    /**
+     * Retorna o histórico de filial da apuração.
+     * 
+     * @example
+     * ```typescript
+     * const companyBranchHistory = timeEvaluation.companyBranchHistory;
+     * console.log(`Histórico de filial encontrado na data ${timeEvaluation.date}: ${companyBranchHistory.companyBranch}`);
+     * ```
+     * 
+     * @returns Histórico de filial.
+     * @see {@link CompanyBranchHistory}
+     */
+    get companyBranchHistory(): CompanyBranchHistory {
+        const companyBrach = this._histories.findCompanyBranchByDate(this._date);
+        if (!companyBrach) {
+            throw new Error(`Company branch history for date ${this._date} not found`);
+        }
+
+        return companyBrach;
+    }
+
+    /**
+     * Retorna o histórico de apuração no dia apurado. Neste histórico é retornado a definição de situação, que também é em 
+     * formato de histórico, ou seja, um histórico de apuração pode ter uma lista de históricos de definição de situação.
+     * Caso desejar retornar a definição de situação vigente na data utilizar diretamente o timeEvaluation.situationDefinition.
+     * 
+     * @example
+     * ```typescript
+     * const timeEvaluationHistory = timeEvaluation.timeEvaluationHistory;
+     * console.log(`Histórico de apuração encontrado na data ${timeEvaluation.date}: ${timeEvaluationHistory.startDate}`);
+     * ```
+     * @returns Histórico de apuração
+     */
+    get timeEvaluationHistory(): TimeEvaluationHistory {
+        const timeEvaluationHistory = this._histories.findTimeEvaluationHistoryByDate(this._date);
+
+        if (!timeEvaluationHistory) {
+            throw new Error(`Time evaluation history for date ${this._date} not found`);
+        }
+
+        return timeEvaluationHistory;
+    }
+
+    /**
+     * Retorna o histórico de escala de trabalho do colaborador no dia apurado.
+     * 
+     * @example
+     * ```typescript
+     * const workshiftHistory = timeEvaluation.workshiftHistory;
+     * console.log(`Histórico de escala encontrado na data ${timeEvaluation.date}: ${workshiftHistory.workshift}`);
+     * ```
+     * @returns Histórico de escala de trabalho.
+     * @see {@link WorkshiftHistory}
+     */
+    get workshiftHistory(): WorkshiftHistory {
+        const workshiftHistory = this._histories.findWorkshiftHistoryByDate(this._date);
+        if (!workshiftHistory) {
+            throw new Error(`Workshift history for date ${this._date} not found`);
+        }
+        return workshiftHistory;
+    }
+
+    /**
+     * Retorna as contas de banco de horas válidas para a data de apuração.
+     * Verifica se a data de apuração está entre creationDate e extinctionDate da conta.
+     * Retorna vazio caso o colaborador não tenha contas de banco de horas ou se as contas não estiverem ativas na data de apuração.
+     * 
+     * @example
+     * ```typescript
+     * const hourBankAccounts = timeEvaluation.hourBankAccounts;
+     * if (hourBankAccounts.length > 0) {
+     *   console.log(`Contas de banco de horas encontradas na data ${timeEvaluation.date}: ${hourBankAccounts.length}`);
+     * } else {
+     *  console.log(`Não foi encontrado contas de banco de horas na data ${timeEvaluation.date}`);
+     * }
+     * ```
+     * 
+     * @returns A conta de banco de horas válida ou undefined se não encontrar.
+     * @see {@link HourBankAccount}
+     */
+    get hourBankAccounts(): HourBankAccount[] {
+        if (this._hourBankAccounts == null || this._hourBankAccounts.length === 0) {
+            return [];
+        }
+
+        return this._hourBankAccounts.filter((account) => {
+            return DateUtils.isAfterOrEquals(this._date, account.creationDate) &&
+                (account.extinctionDate === null || DateUtils.isBeforeOrEquals(this._date, account.extinctionDate));
+        });
+    }
+
+    /**
+     * Retorna a definição de situação de apuração de ponto vigente na data de apuração.
+     * 
+     * @example
+     * ```typescript
+     * const situationDefinition = timeEvaluation.situationDefinition;
+     * console.log(`Definição de situação encontrado na data ${timeEvaluation.date}: ${situationDefinition.workSituation.code}`);
+     * ```
+     * 
+     * @returns A definição de situação de apuração de ponto.
+     * @see {@link TimeEvaluationSituationDefinitionHistory}
+     */
+    get situationDefinition(): TimeEvaluationSituationDefinitionHistory {
+        const situationDefinition = ContextReference.getGlobalInstance().getTimeEvaluationSituationDefinitionHistory(this._situationDefinitionKey);
+        if (!situationDefinition) {
+            throw new Error(`Time evaluation situation definition with key ${this._situationDefinitionKey} not found`);
+        }
+        return situationDefinition;
+    }
+
+    /**
+     * @hidden
+     * Retorna a chave da definição de situação de apuração de ponto vigente na data de apuração.
+     * 
+     * @example
+     * ```typescript
+     * const situationDefinitionKey = timeEvaluation.situationDefinitionKey;
+     * console.log(`Situation definition key for date ${timeEvaluation.date}: ${situationDefinitionKey}`);
+     * ```
+     * 
+     * @returns A chave da definição de situação de apuração de ponto.
+     */
+    private get situationDefinitionKey(): string {
+        return this._situationDefinitionKey;
+    }
+
+    /**
+     * Retorna o histórico de vínculo da apuração.
+     * 
+     * @example
+     * ```typescript
+     * const employmentRelationshipHistory = timeEvaluation.employmentRelationshipHistory;
+     * console.log(`Histórico de vínculo encontrado na data ${timeEvaluation.date}: ${employmentRelationshipHistory}`);
+     * ```
+     * 
+     * @returns Histórico de vínculo.
+     */
+    get employmentRelationshipHistory(): EmploymentRelationshipHistory {
+        const employmentRelationshipHistory = this._histories.findEmploymentRelationshipByDate(this._date);
+        if (!employmentRelationshipHistory) {
+            throw new Error(`Employment relationship not found for date: ${this._date}`);
+        }
+        return employmentRelationshipHistory;
+    }
+
+    /**
+      * Retorna o feriado do dia apurado.
+      * Se não encontrar o feriado, retorna undefined.
+      * 
+      * @example
+      * ```typescript
+      * const holiday = timeEvaluation.holiday;
+      * if (holiday) {
+      *  console.log(`Feriado encontrado na data ${timeEvaluation.date}: ${holiday.date}`);
+      * }
+      * ```
+      * 
+      * @returns Feriado.
+      */
+    get holiday(): Holiday | undefined {
+        return this._holiday;
+    }
+
+    /**
+     * Permite modificar o indicador para gerar pendência no dia apurado.
+     * 
+     * generatePendingAdjustment = true: gera pendência de acerto no dia caso não exista.
+     * Caso já exista uma pendência, mantém o seu status como está;
+     * 
+     * generatePendingAdjustment = false: não gera pendência de acerto no dia. 
+     * Caso já exista uma pendência de acerto no dia e seu o status é:
+     * - com gestor -> mantém com o gestor;
+     * - com colaborador -> muda para o gestor;
+     * - tratada -> mantém tratada;
+     * - expirada -> mantém expirada.
+     * 
+     * Caso este parâmetro não seja definido, vai seguir o padrão do sistema.
+     * 
+     * @example
+     * ```typescript
+     * timeEvaluation.generatePendingAdjustment = true; // Gera pendência de acerto no dia apurado.
+     * timeEvaluation.generatePendingAdjustment = false; // Não gera pendência de acerto no dia apurado.
+     * ```
+     * 
+     * @param value Valor booleano para definir se deve gerar pendência de acerto no dia apurado.
+     */
+    set generatePendingAdjustment(value: boolean) {
+        this._generatePendingAdjustment = value;
+    }
+
+    /**
+     * Indica se deve gerar pendência no dia.
+     * A Rotina de geração de pendência de acerto deve ser executada após a apuração do dia.
+     * O valor retornado será undefined se não tiver sido definido, caso for definido o valor será true ou false conforme configurado na regra.
+     * @example
+     * ```typescript
+     * const shouldGeneratePending = timeEvaluation.generatePendingAdjustment;
+     * 
+     * if(shouldGeneratePending === undefined) {
+     *  console.log("A geração de pendência não foi definida, seguindo o padrão do sistema.");
+     * } else if (shouldGeneratePending) {
+     *   console.log("Geração de pendência foi alterada na customização e será gerada uma pendência de acerto no dia.");
+     * } else {
+     *  console.log("Não será gerada uma pendência de acerto no dia.");
+     * }
+     * ```
+     */
+    get generatePendingAdjustment(): boolean | undefined {
+        return this._generatePendingAdjustment;
+    }
+
+    /**
+     * Indica se o dia de apuração não possui alguma das marcações de ponto obrigatórias.
+     * Isso pode ocorrer quando o colaborador não registrou ponto no dia ou quando o sistema não conseguiu registrar as marcações.
+     * Observações:
+     * 
+     * 1) Horarios do tipo flexíveis vão sempre retornar false.
+     * 
+     * 2) Colaborador em afastamento de férias vai sempre retornar false.
+     * 
+     * 3) Somente as marcações obrigatórias são consideradas para essa verificação.
+     * 
+     * Nos horários com marcações não obrigatórias, as marcação não obrigatórias são ignoradas. O sistema aloca as marcações para se encaixar o mais próximo possível do esperado. 
+     * Cenários: 
+     * 
+     * Horário: 08:00 12:00 13:00 15:30 16:00 18:00, onde as marcações da 15:30 e 16:00 são opcionais. 
+     * Se o colaborador registrar marcações as 08:00, 12:00, 13:00 e 16:00, o sistema vai retornar que esta faltando marcação, porque considera que a das 16 horas é uma marcação não obrigatória.
+     * 
+     * @example
+     * ```typescript
+     * if (timeEvaluation.missingClockingEvent) {
+     *   console.log("O dia de apuração não possui todas as marcações de ponto.");
+     * } else {
+     *   console.log("O dia de apuração possui marcações de ponto.");
+     * }
+     * ```
+     */
+    get missingClockingEvent(): boolean {
+        return this._missingClockingEvent;
+    }
+
+    /**
+     * Retorna o histórico de afastamento do colaborador utilizado no dia apurado.
+     * Caso não encontre o histórico de afastamento, retorna uma lista vazia.
+     * Existem casos que o afastamento é criado mas não aplicado no dia apurado, como por exemplo:
+     *  - Afastamentos em DSR (não são aplicados).
+     * 
+     * @example
+     * ```typescript
+     * const leaveHistories = timeEvaluation.leaveHistories;
+     * if (leaveHistories.length > 0) { 
+     *   console.log(`Históricos de afastamento encontrados na apuração do dia ${timeEvaluation.date}, quantidade: ${leaveHistories.length}`);
+     * } else {
+     *  console.log(`Não foram encontrados históricos de afastamento para a apuração do dia ${timeEvaluation.date}`);
+     * }
+     * ```
+     * 
+     * @returns Lista de afastamentos do colaborador no dia apurado.
+     * @see {@link LeaveHistory}
+     */
+    get leaveHistories(): LeaveHistory[] {
+        return this._histories.findLeaveHistoryByTimeEvaluationDate(this._date);
+    }
+
+    /**
+     * Retorna a programação de troca de horário vigente na data de apuração.
+     * @example
+     * ```typescript
+     * const workscheduleChange = timeEvaluation.workscheduleChange;
+     * if (workscheduleChange) {
+     *  console.log(`Troca de horário encontrada na data ${timeEvaluation.date}: ${workscheduleChange.workschedule.code}`);
+     * }
+     * ```
+     * 
+     * @returns A programação de troca de horário ou undefined se não encontrar.
+     * @see {@link WorkscheduleChange}
+     */
+    get workscheduleChange(): WorkscheduleChange | undefined {
+        return this._schedules.findWorkscheduleChangeByDate(this._date);
+    }
+
+
+    public static clone(timeEvaluation: TimeEvaluation, contract: Contract
+    ): TimeEvaluation {
+        const timeEvaluationParams: TimeEvaluationParams = {
+            date: timeEvaluation.date,
+            missingClockingEvent: timeEvaluation.missingClockingEvent,
+            workscheduleId: timeEvaluation.workscheduleId,
+            workscheduleWorkshiftId: timeEvaluation.workscheduleWorkshiftId,
+            workshiftId: timeEvaluation.workshiftId,
+            timeEvaluationSituations: timeEvaluation.timeEvaluationSituations,
+            clockingEvents: timeEvaluation.clockingEvents,
+            intervals: timeEvaluation.intervals,
+            schedules: contract.schedules,
+            histories: contract.histories,
+            hourBankAccounts: contract.hourBankAccounts,
+            situationDefinitionKey: timeEvaluation.situationDefinitionKey,
+            estimatedHours: timeEvaluation.estimatedHours,
+            syndicateKey: timeEvaluation._syndicateKey,
+            holiday: contract.getHolidayByDate(ObjectUtils.toDateOrThrow(timeEvaluation.date, "timeEvaluation.date")),
+            costCenterKey: timeEvaluation.costCenterKey,
+        };
+
+        return new TimeEvaluation(timeEvaluationParams);
+    }
+
+}