@atlantjs/arch 13.3.0 → 14.0.0

package/objects/schedule/schedule.edge.js

@@ -11,12 +11,76 @@ class ScheduleEdge {
     constructor(_moment) {
         this._moment = _moment;
     }
+    // ==================== Verificações ====================
+    /**
+     * Verifica se o agendamento é recorrente (baseado em expressão cron).
+     * @returns true se o agendamento é recorrente, false se é um datetime fixo
+     * @example
+     * new ScheduleEdge(new CronExpressionEdge("0 8 * * *")).isRecurrent() // true
+     * new ScheduleEdge(new DatetimeEdge(new Date())).isRecurrent() // false
+     */
     isRecurrent() {
-        if (this._moment instanceof cron_expression_edge_1.CronExpressionEdge) {
+        return this._moment instanceof cron_expression_edge_1.CronExpressionEdge;
+    }
+    /**
+     * Verifica se o agendamento é um evento único (baseado em DatetimeEdge).
+     * @returns true se o agendamento é um evento único, false se é recorrente
+     * @example
+     * new ScheduleEdge(new DatetimeEdge(new Date())).isOneTime() // true
+     * new ScheduleEdge(new CronExpressionEdge("0 8 * * *")).isOneTime() // false
+     */
+    isOneTime() {
+        return this._moment instanceof datetime_edge_1.DatetimeEdge;
+    }
+    /**
+     * Verifica se o agendamento já passou em relação à data/hora atual.
+     * Para agendamentos recorrentes, sempre retorna false.
+     * @returns true se a data do agendamento é anterior ao momento atual
+     * @example
+     * new ScheduleEdge(new DatetimeEdge(new Date("2020-01-01"))).isPast() // true
+     * new ScheduleEdge(new DatetimeEdge(new Date("2099-01-01"))).isPast() // false
+     */
+    isPast() {
+        if (this._moment instanceof cron_expression_edge_1.CronExpressionEdge)
+            return false;
+        return this._moment.isBefore(new datetime_edge_1.DatetimeEdge(new Date()));
+    }
+    /**
+     * Verifica se o agendamento ainda está no futuro em relação à data/hora atual.
+     * Para agendamentos recorrentes, sempre retorna true.
+     * @returns true se a data do agendamento é posterior ao momento atual
+     * @example
+     * new ScheduleEdge(new DatetimeEdge(new Date("2099-01-01"))).isFuture() // true
+     * new ScheduleEdge(new DatetimeEdge(new Date("2020-01-01"))).isFuture() // false
+     */
+    isFuture() {
+        if (this._moment instanceof cron_expression_edge_1.CronExpressionEdge)
             return true;
+        return this._moment.isAfter(new datetime_edge_1.DatetimeEdge(new Date()));
+    }
+    /**
+     * Verifica se o agendamento ocorre hoje.
+     * Para agendamentos recorrentes, verifica se há uma ocorrência hoje.
+     * @returns true se há uma ocorrência hoje, false caso contrário
+     * @example
+     * new ScheduleEdge(new DatetimeEdge(new Date())).isToday() // true
+     */
+    isToday() {
+        if (this._moment instanceof datetime_edge_1.DatetimeEdge) {
+            return this._moment.isToday();
         }
-        return false;
+        const next = cron_parser_1.CronExpressionParser.parse(this._moment.toString()).next();
+        const nextDatetime = new datetime_edge_1.DatetimeEdge(next.toDate());
+        return nextDatetime.isToday();
     }
+    // ==================== Ocorrências ====================
+    /**
+     * Retorna a próxima ocorrência de um agendamento recorrente.
+     * @returns Success com a próxima ocorrência ou Failure se o agendamento não for recorrente
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * *"));
+     * schedule.nextOccurrence() // Success(DatetimeEdge com a próxima ocorrência às 8h)
+     */
     nextOccurrence() {
         if (this._moment instanceof datetime_edge_1.DatetimeEdge) {
             return (0, return_type_1.Failure)(new schedule_edge_failure_1.RecurringScheduleEdgeFailure(this._moment.toISOString()));
@@ -24,6 +88,14 @@ class ScheduleEdge {
         const cronDate = cron_parser_1.CronExpressionParser.parse(this._moment.toString()).next();
         return (0, return_type_1.Success)(new datetime_edge_1.DatetimeEdge(cronDate.toDate()));
     }
+    /**
+     * Retorna as próximas N ocorrências de um agendamento recorrente.
+     * @param quantity - Número de ocorrências a retornar
+     * @returns Success com array das próximas ocorrências ou Failure se não for recorrente
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * *"));
+     * schedule.nextOccurrences(3) // Success([DatetimeEdge, DatetimeEdge, DatetimeEdge])
+     */
     nextOccurrences(quantity) {
         if (this._moment instanceof datetime_edge_1.DatetimeEdge) {
             return (0, return_type_1.Failure)(new schedule_edge_failure_1.RecurringScheduleEdgeFailure(this._moment.toISOString()));
@@ -31,6 +103,13 @@ class ScheduleEdge {
         const cronDates = cron_parser_1.CronExpressionParser.parse(this._moment.toString()).take(quantity);
         return (0, return_type_1.Success)(cronDates.map((cronDate) => new datetime_edge_1.DatetimeEdge(cronDate.toDate())));
     }
+    /**
+     * Retorna a ocorrência anterior de um agendamento recorrente.
+     * @returns Success com a ocorrência anterior ou Failure se o agendamento não for recorrente
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * *"));
+     * schedule.previousOccurrence() // Success(DatetimeEdge com a última ocorrência às 8h)
+     */
     previousOccurrence() {
         if (this._moment instanceof datetime_edge_1.DatetimeEdge) {
             return (0, return_type_1.Failure)(new schedule_edge_failure_1.RecurringScheduleEdgeFailure(this._moment.toISOString()));
@@ -38,6 +117,14 @@ class ScheduleEdge {
         const cronDate = cron_parser_1.CronExpressionParser.parse(this._moment.toString()).prev();
         return (0, return_type_1.Success)(new datetime_edge_1.DatetimeEdge(cronDate.toDate()));
     }
+    /**
+     * Retorna as N ocorrências anteriores de um agendamento recorrente.
+     * @param quantity - Número de ocorrências a retornar
+     * @returns Success com array das ocorrências anteriores ou Failure se não for recorrente
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * *"));
+     * schedule.previousOccurrences(3) // Success([DatetimeEdge, DatetimeEdge, DatetimeEdge])
+     */
     previousOccurrences(quantity) {
         if (this._moment instanceof datetime_edge_1.DatetimeEdge) {
             return (0, return_type_1.Failure)(new schedule_edge_failure_1.RecurringScheduleEdgeFailure(this._moment.toISOString()));
@@ -45,14 +132,194 @@ class ScheduleEdge {
         const cronDates = cron_parser_1.CronExpressionParser.parse(this._moment.toString()).take(-quantity);
         return (0, return_type_1.Success)(cronDates.map((cronDate) => new datetime_edge_1.DatetimeEdge(cronDate.toDate())));
     }
+    /**
+     * Retorna todas as ocorrências dentro de um intervalo de datas.
+     * @param start - Data de início do intervalo
+     * @param end - Data de fim do intervalo
+     * @returns Success com array das ocorrências no intervalo ou Failure se não for recorrente
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * *"));
+     * schedule.occurrencesBetween(startDate, endDate)
+     * // Success([DatetimeEdge, DatetimeEdge, ...])
+     */
+    occurrencesBetween(start, end) {
+        if (this._moment instanceof datetime_edge_1.DatetimeEdge) {
+            return (0, return_type_1.Failure)(new schedule_edge_failure_1.RecurringScheduleEdgeFailure(this._moment.toISOString()));
+        }
+        const interval = cron_parser_1.CronExpressionParser.parse(this._moment.toString(), {
+            currentDate: start.toDate(),
+            endDate: end.toDate(),
+        });
+        const occurrences = [];
+        while (true) {
+            try {
+                const next = interval.next();
+                occurrences.push(new datetime_edge_1.DatetimeEdge(next.toDate()));
+            }
+            catch {
+                break;
+            }
+        }
+        return (0, return_type_1.Success)(occurrences);
+    }
+    /**
+     * Conta quantas ocorrências existem dentro de um intervalo de datas.
+     * @param start - Data de início do intervalo
+     * @param end - Data de fim do intervalo
+     * @returns Success com o número de ocorrências ou Failure se não for recorrente
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * 1-5"));
+     * schedule.countOccurrencesBetween(startDate, endDate) // Success(5) em uma semana
+     */
+    countOccurrencesBetween(start, end) {
+        const resultWrapped = this.occurrencesBetween(start, end);
+        if (!resultWrapped.hasSuccess)
+            return resultWrapped;
+        return (0, return_type_1.Success)(resultWrapped.unwrap().values.length);
+    }
+    // ==================== Getters ====================
+    /**
+     * Retorna o horário do agendamento como um TimeEdge.
+     * @returns TimeEdge com hora e minuto do agendamento
+     * @example
+     * new ScheduleEdge(new CronExpressionEdge("0 8 * * *")).getTime()
+     * // TimeEdge("08:00")
+     */
     getTime() {
         const interval = cron_parser_1.CronExpressionParser.parse(this._moment.toString()).fields;
         const hour = String(interval.hour.values.toString()).padStart(2, "0");
         const minute = String(interval.minute.values.toString()).padStart(2, "0");
         return new time_edge_1.TimeEdge(`${hour}:${minute}`);
     }
+    /**
+     * Retorna o momento interno do agendamento (CronExpressionEdge ou DatetimeEdge).
+     * @returns Instância de CronExpressionEdge ou DatetimeEdge
+     * @example
+     * new ScheduleEdge(new CronExpressionEdge("0 8 * * *")).getMoment()
+     * // CronExpressionEdge("0 8 * * *")
+     */
+    getMoment() {
+        return this._moment;
+    }
+    /**
+     * Retorna o DatetimeEdge do agendamento se for um evento único.
+     * @returns Success com o DatetimeEdge ou Failure se o agendamento for recorrente
+     * @example
+     * const date = new DatetimeEdge(new Date());
+     * new ScheduleEdge(date).getDatetime() // Success(DatetimeEdge)
+     */
+    getDatetime() {
+        if (this._moment instanceof cron_expression_edge_1.CronExpressionEdge) {
+            return (0, return_type_1.Failure)(new schedule_edge_failure_1.RecurringScheduleEdgeFailure(this._moment.toString()));
+        }
+        return (0, return_type_1.Success)(this._moment);
+    }
+    /**
+     * Retorna a CronExpressionEdge do agendamento se for recorrente.
+     * @returns Success com a CronExpressionEdge ou Failure se for evento único
+     * @example
+     * const cron = new CronExpressionEdge("0 8 * * *");
+     * new ScheduleEdge(cron).getCronExpression() // Success(CronExpressionEdge)
+     */
+    getCronExpression() {
+        if (this._moment instanceof datetime_edge_1.DatetimeEdge) {
+            return (0, return_type_1.Failure)(new schedule_edge_failure_1.RecurringScheduleEdgeFailure(this._moment.toISOString()));
+        }
+        return (0, return_type_1.Success)(this._moment);
+    }
+    // ==================== Clonagem e Imutabilidade ====================
+    /**
+     * Cria uma cópia independente desta instância de ScheduleEdge.
+     * @returns Nova instância com o mesmo momento interno
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * *"));
+     * const clone = schedule.clone(); // instância independente
+     */
+    clone() {
+        return new ScheduleEdge(this._moment);
+    }
+    /**
+     * Retorna uma nova instância com o momento alterado.
+     * @param moment - Novo momento (CronExpressionEdge ou DatetimeEdge)
+     * @returns Nova instância com o momento alterado
+     * @example
+     * const schedule = new ScheduleEdge(new CronExpressionEdge("0 8 * * *"));
+     * const updated = schedule.withMoment(new CronExpressionEdge("0 10 * * *"));
+     */
+    withMoment(moment) {
+        return new ScheduleEdge(moment);
+    }
+    // ==================== Formatação ====================
+    /**
+     * Retorna a representação em string do momento do agendamento.
+     * Para cron, retorna a expressão cron. Para datetime, retorna a ISO string.
+     * @returns String representando o agendamento
+     * @example
+     * new ScheduleEdge(new CronExpressionEdge("0 8 * * *")).toString() // "0 8 * * *"
+     * new ScheduleEdge(new DatetimeEdge(new Date())).toString() // "2026-03-12T14:00:00.000Z"
+     */
     toString() {
         return this._moment.toString();
     }
+    // ==================== Métodos Estáticos ====================
+    /**
+     * Cria um ScheduleEdge recorrente a partir de uma expressão cron.
+     * @param expression - Expressão cron válida
+     * @returns Nova instância de ScheduleEdge recorrente
+     * @example
+     * ScheduleEdge.fromCron("0 8 * * *") // agendamento diário às 8h
+     * ScheduleEdge.fromCron("0 8 * * 1-5") // agendamento de segunda a sexta às 8h
+     */
+    static fromCron(expression) {
+        return new ScheduleEdge(new cron_expression_edge_1.CronExpressionEdge(expression));
+    }
+    /**
+     * Cria um ScheduleEdge de evento único a partir de um objeto Date.
+     * @param date - Data e hora do evento único
+     * @returns Nova instância de ScheduleEdge para evento único
+     * @example
+     * ScheduleEdge.fromDate(new Date("2026-12-25T08:00:00"))
+     * // agendamento para o Natal de 2026 às 8h
+     */
+    static fromDate(date) {
+        return new ScheduleEdge(new datetime_edge_1.DatetimeEdge(date));
+    }
+    /**
+     * Cria um ScheduleEdge para agendamentos diários em um horário específico.
+     * @param time - Horário do agendamento no formato TimeEdge
+     * @returns Nova instância de ScheduleEdge com recorrência diária
+     * @example
+     * ScheduleEdge.daily(new TimeEdge("08:00")) // todos os dias às 8h -> "0 8 * * *"
+     */
+    static daily(time) {
+        const expression = `${time.getMinutes()} ${time.getHours()} * * *`;
+        return ScheduleEdge.fromCron(expression);
+    }
+    /**
+     * Cria um ScheduleEdge para agendamentos semanais em um dia e horário específico.
+     * @param dayOfWeek - Dia da semana (0=domingo, 1=segunda, ..., 6=sábado)
+     * @param time - Horário do agendamento no formato TimeEdge
+     * @returns Nova instância de ScheduleEdge com recorrência semanal
+     * @example
+     * ScheduleEdge.weekly(1, new TimeEdge("08:00"))
+     * // toda segunda-feira às 8h -> "0 8 * * 1"
+     */
+    static weekly(dayOfWeek, time) {
+        const expression = `${time.getMinutes()} ${time.getHours()} * * ${dayOfWeek}`;
+        return ScheduleEdge.fromCron(expression);
+    }
+    /**
+     * Cria um ScheduleEdge para agendamentos mensais em um dia e horário específico.
+     * @param dayOfMonth - Dia do mês (1-31)
+     * @param time - Horário do agendamento no formato TimeEdge
+     * @returns Nova instância de ScheduleEdge com recorrência mensal
+     * @example
+     * ScheduleEdge.monthly(15, new TimeEdge("08:00"))
+     * // todo dia 15 de cada mês às 8h -> "0 8 15 * *"
+     */
+    static monthly(dayOfMonth, time) {
+        const expression = `${time.getMinutes()} ${time.getHours()} ${dayOfMonth} * *`;
+        return ScheduleEdge.fromCron(expression);
+    }
 }
 exports.ScheduleEdge = ScheduleEdge;

package/objects/time/time.edge.d.ts

@@ -1,11 +1,294 @@
 export declare class TimeEdge {
     private readonly value;
     constructor(value: string);
+    /**
+     * Retorna as horas do tempo como número inteiro.
+     * @returns Número inteiro representando as horas (0-23)
+     * @example
+     * new TimeEdge("14:30").getHours() // 14
+     * new TimeEdge("08:00").getHours() // 8
+     */
+    getHours(): number;
+    /**
+     * Retorna os minutos do tempo como número inteiro.
+     * @returns Número inteiro representando os minutos (0-59)
+     * @example
+     * new TimeEdge("14:30").getMinutes() // 30
+     * new TimeEdge("08:05").getMinutes() // 5
+     */
+    getMinutes(): number;
+    /**
+     * Retorna o tempo total convertido em minutos.
+     * @returns Total de minutos representados pelo tempo
+     * @example
+     * new TimeEdge("01:30").toTotalMinutes() // 90
+     * new TimeEdge("02:00").toTotalMinutes() // 120
+     */
+    toTotalMinutes(): number;
+    /**
+     * Retorna o tempo total convertido em segundos.
+     * @returns Total de segundos representados pelo tempo
+     * @example
+     * new TimeEdge("00:01").toTotalSeconds() // 60
+     * new TimeEdge("01:00").toTotalSeconds() // 3600
+     */
+    toTotalSeconds(): number;
+    /**
+     * Subtrai um tempo de outro e retorna uma nova instância.
+     * @param time - Tempo a ser subtraído do valor atual
+     * @returns Nova instância de TimeEdge com o resultado da subtração
+     * @example
+     * new TimeEdge("10:30").subtract(new TimeEdge("01:00")) // TimeEdge("09:30")
+     * new TimeEdge("08:15").subtract(new TimeEdge("00:30")) // TimeEdge("07:45")
+     */
     subtract(time: TimeEdge): TimeEdge;
+    /**
+     * Soma um tempo ao valor atual e retorna uma nova instância.
+     * @param time - Tempo a ser somado ao valor atual
+     * @returns Nova instância de TimeEdge com o resultado da soma
+     * @example
+     * new TimeEdge("08:30").add(new TimeEdge("01:00")) // TimeEdge("09:30")
+     * new TimeEdge("23:30").add(new TimeEdge("01:00")) // TimeEdge("00:30")
+     */
     add(time: TimeEdge): TimeEdge;
+    /**
+     * Calcula a diferença absoluta entre dois tempos.
+     * @param time - Tempo para calcular a diferença
+     * @returns Nova instância de TimeEdge com a diferença absoluta
+     * @example
+     * new TimeEdge("10:00").difference(new TimeEdge("08:30")) // TimeEdge("01:30")
+     * new TimeEdge("08:30").difference(new TimeEdge("10:00")) // TimeEdge("01:30")
+     */
+    difference(time: TimeEdge): TimeEdge;
+    /**
+     * Multiplica o tempo por um fator numérico e retorna uma nova instância.
+     * @param factor - Fator de multiplicação
+     * @returns Nova instância de TimeEdge com o tempo multiplicado
+     * @example
+     * new TimeEdge("01:30").multiply(2) // TimeEdge("03:00")
+     * new TimeEdge("00:20").multiply(3) // TimeEdge("01:00")
+     */
+    multiply(factor: number): TimeEdge;
+    /**
+     * Verifica se este tempo é igual a outro.
+     * @param time - Tempo para comparação
+     * @returns true se os tempos são iguais, false caso contrário
+     * @example
+     * new TimeEdge("10:30").isEqual(new TimeEdge("10:30")) // true
+     * new TimeEdge("10:30").isEqual(new TimeEdge("10:00")) // false
+     */
+    isEqual(time: TimeEdge): boolean;
+    /**
+     * Verifica se este tempo é diferente de outro.
+     * @param time - Tempo para comparação
+     * @returns true se os tempos são diferentes, false caso contrário
+     * @example
+     * new TimeEdge("10:30").isDifferent(new TimeEdge("09:00")) // true
+     * new TimeEdge("10:30").isDifferent(new TimeEdge("10:30")) // false
+     */
+    isDifferent(time: TimeEdge): boolean;
+    /**
+     * Verifica se este tempo é maior que outro.
+     * @param time - Tempo para comparação
+     * @returns true se this > time, false caso contrário
+     * @example
+     * new TimeEdge("10:30").isGreaterThan(new TimeEdge("09:00")) // true
+     * new TimeEdge("08:00").isGreaterThan(new TimeEdge("10:00")) // false
+     */
+    isGreaterThan(time: TimeEdge): boolean;
+    /**
+     * Verifica se este tempo é menor que outro.
+     * @param time - Tempo para comparação
+     * @returns true se this < time, false caso contrário
+     * @example
+     * new TimeEdge("08:00").isLessThan(new TimeEdge("10:00")) // true
+     * new TimeEdge("10:30").isLessThan(new TimeEdge("09:00")) // false
+     */
+    isLessThan(time: TimeEdge): boolean;
+    /**
+     * Verifica se este tempo é maior ou igual a outro.
+     * @param time - Tempo para comparação
+     * @returns true se this >= time, false caso contrário
+     * @example
+     * new TimeEdge("10:30").isGreaterThanOrEqual(new TimeEdge("10:30")) // true
+     * new TimeEdge("10:30").isGreaterThanOrEqual(new TimeEdge("09:00")) // true
+     */
+    isGreaterThanOrEqual(time: TimeEdge): boolean;
+    /**
+     * Verifica se este tempo é menor ou igual a outro.
+     * @param time - Tempo para comparação
+     * @returns true se this <= time, false caso contrário
+     * @example
+     * new TimeEdge("08:00").isLessThanOrEqual(new TimeEdge("08:00")) // true
+     * new TimeEdge("08:00").isLessThanOrEqual(new TimeEdge("10:00")) // true
+     */
+    isLessThanOrEqual(time: TimeEdge): boolean;
+    /**
+     * Verifica se este tempo está entre dois limites (inclusive).
+     * @param start - Tempo mínimo do intervalo
+     * @param end - Tempo máximo do intervalo
+     * @returns true se o tempo está entre start e end, false caso contrário
+     * @example
+     * new TimeEdge("10:00").isBetween(new TimeEdge("08:00"), new TimeEdge("12:00")) // true
+     * new TimeEdge("14:00").isBetween(new TimeEdge("08:00"), new TimeEdge("12:00")) // false
+     */
+    isBetween(start: TimeEdge, end: TimeEdge): boolean;
+    /**
+     * Verifica se o tempo representa meia-noite (00:00).
+     * @returns true se o tempo é 00:00, false caso contrário
+     * @example
+     * new TimeEdge("00:00").isMidnight() // true
+     * new TimeEdge("12:00").isMidnight() // false
+     */
+    isMidnight(): boolean;
+    /**
+     * Verifica se o tempo representa o meio-dia (12:00).
+     * @returns true se o tempo é 12:00, false caso contrário
+     * @example
+     * new TimeEdge("12:00").isNoon() // true
+     * new TimeEdge("00:00").isNoon() // false
+     */
+    isNoon(): boolean;
+    /**
+     * Verifica se o tempo está no período da manhã (00:00 até 11:59).
+     * @returns true se o tempo é anterior às 12:00, false caso contrário
+     * @example
+     * new TimeEdge("09:00").isMorning() // true
+     * new TimeEdge("13:00").isMorning() // false
+     */
+    isMorning(): boolean;
+    /**
+     * Verifica se o tempo está no período da tarde (12:00 até 17:59).
+     * @returns true se o tempo está entre 12:00 e 17:59, false caso contrário
+     * @example
+     * new TimeEdge("14:00").isAfternoon() // true
+     * new TimeEdge("20:00").isAfternoon() // false
+     */
+    isAfternoon(): boolean;
+    /**
+     * Verifica se o tempo está no período da noite (18:00 até 23:59).
+     * @returns true se o tempo é a partir das 18:00, false caso contrário
+     * @example
+     * new TimeEdge("20:00").isEvening() // true
+     * new TimeEdge("14:00").isEvening() // false
+     */
+    isEvening(): boolean;
+    /**
+     * Cria uma cópia independente desta instância de TimeEdge.
+     * @returns Nova instância com o mesmo valor de tempo
+     * @example
+     * const time1 = new TimeEdge("10:30");
+     * const time2 = time1.clone(); // instância independente com "10:30"
+     */
+    clone(): TimeEdge;
+    /**
+     * Retorna uma nova instância com as horas alteradas.
+     * @param hours - Novo valor de horas (0-23)
+     * @returns Nova instância com as horas alteradas
+     * @example
+     * new TimeEdge("10:30").withHours(15) // TimeEdge("15:30")
+     */
+    withHours(hours: number): TimeEdge;
+    /**
+     * Retorna uma nova instância com os minutos alterados.
+     * @param minutes - Novo valor de minutos (0-59)
+     * @returns Nova instância com os minutos alterados
+     * @example
+     * new TimeEdge("10:30").withMinutes(45) // TimeEdge("10:45")
+     */
+    withMinutes(minutes: number): TimeEdge;
+    /**
+     * Retorna o tempo como string no formato HH:mm.
+     * @returns String no formato "HH:mm"
+     * @example
+     * new TimeEdge("14:30").toString() // "14:30"
+     */
     toString(): string;
+    /**
+     * Retorna o tempo no formato de 12 horas com AM/PM.
+     * @returns String no formato "hh:mm AM/PM"
+     * @example
+     * new TimeEdge("14:30").toFormat12h() // "02:30 PM"
+     * new TimeEdge("08:00").toFormat12h() // "08:00 AM"
+     */
+    toFormat12h(): string;
+    /**
+     * Retorna uma representação legível do tempo em horas e minutos por extenso.
+     * @returns String descritiva no formato "Xh Ym"
+     * @example
+     * new TimeEdge("14:30").toReadableString() // "14h 30m"
+     * new TimeEdge("08:05").toReadableString() // "8h 5m"
+     */
+    toReadableString(): string;
+    /**
+     * Cria um TimeEdge representando a hora atual do sistema.
+     * @returns Nova instância com o horário atual no formato HH:mm
+     * @example
+     * TimeEdge.now() // pode retornar TimeEdge("14:35") dependendo da hora atual
+     */
+    static now(): TimeEdge;
+    /**
+     * Cria um TimeEdge representando a meia-noite (00:00).
+     * @returns Nova instância com o valor "00:00"
+     * @example
+     * TimeEdge.midnight() // TimeEdge("00:00")
+     */
+    static midnight(): TimeEdge;
+    /**
+     * Cria um TimeEdge representando o meio-dia (12:00).
+     * @returns Nova instância com o valor "12:00"
+     * @example
+     * TimeEdge.noon() // TimeEdge("12:00")
+     */
+    static noon(): TimeEdge;
+    /**
+     * Cria um TimeEdge a partir de um total de minutos.
+     * @param totalMinutes - Total de minutos a converter para HH:mm
+     * @returns Nova instância com o tempo correspondente ao total de minutos
+     * @example
+     * TimeEdge.fromMinutes(90) // TimeEdge("01:30")
+     * TimeEdge.fromMinutes(125) // TimeEdge("02:05")
+     */
+    static fromMinutes(totalMinutes: number): TimeEdge;
+    /**
+     * Retorna o maior tempo de uma lista.
+     * @param times - Array de instâncias de TimeEdge para comparação
+     * @returns A instância com o maior valor de tempo
+     * @throws {Error} Se o array estiver vazio
+     * @example
+     * TimeEdge.max([new TimeEdge("08:00"), new TimeEdge("14:30"), new TimeEdge("10:00")])
+     * // TimeEdge("14:30")
+     */
+    static max(times: TimeEdge[]): TimeEdge;
+    /**
+     * Retorna o menor tempo de uma lista.
+     * @param times - Array de instâncias de TimeEdge para comparação
+     * @returns A instância com o menor valor de tempo
+     * @throws {Error} Se o array estiver vazio
+     * @example
+     * TimeEdge.min([new TimeEdge("08:00"), new TimeEdge("14:30"), new TimeEdge("10:00")])
+     * // TimeEdge("08:00")
+     */
+    static min(times: TimeEdge[]): TimeEdge;
+    /**
+     * Soma uma lista de tempos e retorna o total.
+     * @param times - Array de instâncias de TimeEdge para somar
+     * @returns Nova instância com a soma total dos tempos
+     * @throws {Error} Se o array estiver vazio
+     * @example
+     * TimeEdge.sumAll([new TimeEdge("01:00"), new TimeEdge("02:30"), new TimeEdge("00:15")])
+     * // TimeEdge("03:45")
+     */
+    static sumAll(times: TimeEdge[]): TimeEdge;
+    /**
+     * Valida o formato do tempo informado no construtor.
+     * @throws {Error} Se o formato não for HH:mm válido
+     */
     private validate;
+    /**
+     * Verifica se uma string está no formato de tempo HH:mm válido.
+     * @param value - String a ser validada
+     * @returns true se o formato é válido, false caso contrário
+     */
     private isValidTimeFormat;
-    getHours(): number;
-    private getMinutes;
 }