@atlantjs/arch 13.2.0 → 14.0.0

package/@tool-box/utils/type-guard/guardian.js

@@ -3,18 +3,209 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports._ = void 0;
 const guardian_exception_1 = require("./guardian-exception");
 class Guardian {
+    // ==================== Operações Lógicas ====================
+    /**
+     * Verifica se todos os valores booleanos passados são verdadeiros.
+     * @param args - Valores booleanos a serem verificados
+     * @returns true se todos os valores são true, false caso contrário
+     * @example
+     * Guardian.and(true, true, true) // true
+     * Guardian.and(true, false, true) // false
+     */
     static and(...args) {
         return args.every((func) => func);
     }
+    /**
+     * Verifica se pelo menos um dos valores booleanos passados é verdadeiro.
+     * @param args - Valores booleanos a serem verificados
+     * @returns true se pelo menos um valor é true, false caso contrário
+     * @example
+     * Guardian.or(false, false, true) // true
+     * Guardian.or(false, false, false) // false
+     */
     static or(...args) {
         return args.some((func) => func);
     }
+    /**
+     * Retorna um valor baseado em uma condição booleana (ternário).
+     * @template TTrue - Tipo do valor a retornar se a condição for verdadeira
+     * @template TFalse - Tipo do valor a retornar se a condição for falsa
+     * @param condition - Condição a ser avaliada
+     * @param returnIfTrue - Valor retornado quando a condição é true
+     * @param returnIfFalse - Valor retornado quando a condição é false
+     * @returns O valor correspondente à condição
+     * @example
+     * Guardian.ternaryCondition(5 > 3, "maior", "menor") // "maior"
+     */
+    static ternaryCondition(condition, returnIfTrue, returnIfFalse) {
+        return condition ? returnIfTrue : returnIfFalse;
+    }
+    // ==================== Comparações Numéricas ====================
+    /**
+     * Verifica se um número é maior que uma referência.
+     * @param value - Valor a ser comparado
+     * @param reference - Valor de referência para comparação
+     * @returns true se value > reference, false caso contrário
+     * @example
+     * Guardian.greaterThan(10, 5) // true
+     */
     static greaterThan(value, reference) {
         return value > reference;
     }
+    /**
+     * Verifica se um número é menor que uma referência.
+     * @param value - Valor a ser comparado
+     * @param reference - Valor de referência para comparação
+     * @returns true se value < reference, false caso contrário
+     * @example
+     * Guardian.lessThan(3, 5) // true
+     */
     static lessThan(value, reference) {
         return value < reference;
     }
+    /**
+     * Verifica se um número é maior ou igual a uma referência.
+     * @param value - Valor a ser comparado
+     * @param reference - Valor de referência para comparação
+     * @returns true se value >= reference, false caso contrário
+     * @example
+     * Guardian.greaterThanOrEqual(5, 5) // true
+     */
+    static greaterThanOrEqual(value, reference) {
+        return value >= reference;
+    }
+    /**
+     * Verifica se um número é menor ou igual a uma referência.
+     * @param value - Valor a ser comparado
+     * @param reference - Valor de referência para comparação
+     * @returns true se value <= reference, false caso contrário
+     * @example
+     * Guardian.lessThanOrEqual(5, 5) // true
+     */
+    static lessThanOrEqual(value, reference) {
+        return value <= reference;
+    }
+    /**
+     * Verifica se um valor numérico está entre um mínimo e máximo (inclusive).
+     * @param value - Valor numérico ou string a ser verificado
+     * @param min - Valor mínimo da faixa
+     * @param max - Valor máximo da faixa
+     * @returns true se value está entre min e max, false caso contrário
+     * @throws {GuardianException} Se min > max ou se value está vazio
+     * @example
+     * Guardian.isBetween(5, 1, 10) // true
+     * Guardian.isBetween("5", 1, 10) // true
+     */
+    static isBetween(value, min, max) {
+        if (min > max)
+            throw new guardian_exception_1.GuardianException(`Max ${max} should be greater than min ${min}.`);
+        if (Guardian.isEmpty(value)) {
+            throw new guardian_exception_1.GuardianException("Cannot check length of a value. Provided value is empty");
+        }
+        const valueLength = Guardian.isNumber(value) ? value : Number(value);
+        return valueLength >= min && valueLength <= max;
+    }
+    /**
+     * Verifica se um número é positivo (maior que zero).
+     * @param value - Número a ser verificado
+     * @returns true se value > 0, false caso contrário
+     * @example
+     * Guardian.isPositive(5) // true
+     * Guardian.isPositive(-5) // false
+     */
+    static isPositive(value) {
+        return value > 0;
+    }
+    /**
+     * Verifica se um número é negativo (menor que zero).
+     * @param value - Número a ser verificado
+     * @returns true se value < 0, false caso contrário
+     * @example
+     * Guardian.isNegative(-5) // true
+     * Guardian.isNegative(5) // false
+     */
+    static isNegative(value) {
+        return value < 0;
+    }
+    /**
+     * Verifica se um número é zero.
+     * @param value - Número a ser verificado
+     * @returns true se value === 0, false caso contrário
+     * @example
+     * Guardian.isZero(0) // true
+     * Guardian.isZero(5) // false
+     */
+    static isZero(value) {
+        return value === 0;
+    }
+    // ==================== Validação de Números ====================
+    /**
+     * Verifica se um valor é um número inteiro.
+     * @param value - Valor a ser verificado
+     * @returns true se value é um número inteiro, false caso contrário
+     * @example
+     * Guardian.isInteger(5) // true
+     * Guardian.isInteger(5.5) // false
+     */
+    static isInteger(value) {
+        return Number.isInteger(value);
+    }
+    /**
+     * Verifica se um valor é um número decimal (ponto flutuante).
+     * @param value - Valor a ser verificado
+     * @returns true se value é um número decimal, false caso contrário
+     * @example
+     * Guardian.isFloat(5.5) // true
+     * Guardian.isFloat(5) // false
+     */
+    static isFloat(value) {
+        return typeof value === "number" && !Number.isInteger(value);
+    }
+    // ==================== Validação de Valores Vazios/Preenchidos ====================
+    /**
+     * Verifica se um valor está vazio (null, undefined, string vazia, array vazio, objeto vazio).
+     * @param value - Valor a ser verificado
+     * @returns true se value está vazio, false caso contrário
+     * @example
+     * Guardian.isEmpty(null) // true
+     * Guardian.isEmpty("") // true
+     * Guardian.isEmpty([]) // true
+     * Guardian.isEmpty({}) // true
+     * Guardian.isEmpty("texto") // false
+     */
+    static isEmpty(value) {
+        if (Guardian.isNullOrUndefined(value)) {
+            return true;
+        }
+        if (Guardian.isString(value) || Guardian.isArray(value)) {
+            return value.length === 0;
+        }
+        if (Guardian.isObject(value)) {
+            return Object.keys(value).length === 0;
+        }
+        return false;
+    }
+    /**
+     * Verifica se um valor não está vazio.
+     * @param value - Valor a ser verificado
+     * @returns true se value não está vazio, false caso contrário
+     * @example
+     * Guardian.isNotEmpty("texto") // true
+     * Guardian.isNotEmpty("") // false
+     */
+    static isNotEmpty(value) {
+        return !Guardian.isEmpty(value);
+    }
+    /**
+     * Verifica se um array está vazio.
+     * @template T - Tipo dos elementos do array
+     * @param value - Array a ser verificado
+     * @returns true se o array está vazio, false caso contrário
+     * @throws {GuardianException} Se value não for um array
+     * @example
+     * Guardian.isEmptyArray([]) // true
+     * Guardian.isEmptyArray([1, 2]) // false
+     */
     static isEmptyArray(value) {
         if (Guardian.isArray(value).falsy()) {
             throw new guardian_exception_1.GuardianException("The value is not an array");
@@ -24,6 +215,16 @@ class Guardian {
         }
         return value.length === 0;
     }
+    /**
+     * Verifica se um array possui elementos (não está vazio).
+     * @template T - Tipo dos elementos do array
+     * @param value - Array a ser verificado
+     * @returns true se o array possui elementos, false caso contrário
+     * @throws {GuardianException} Se value não for um array
+     * @example
+     * Guardian.isFilledArray([1, 2]) // true
+     * Guardian.isFilledArray([]) // false
+     */
     static isFilledArray(value) {
         if (Guardian.isNullOrUndefined(value)) {
             return false;
@@ -33,42 +234,141 @@ class Guardian {
         }
         return value.length !== 0;
     }
+    /**
+     * Verifica se um array possui exatamente um comprimento específico.
+     * @template T - Tipo dos elementos do array
+     * @param value - Array a ser verificado
+     * @param reference - Comprimento esperado do array
+     * @returns true se o array possui exatamente o comprimento especificado, false caso contrário
+     * @throws {GuardianException} Se value não for um array
+     * @example
+     * Guardian.isLengthArray([1, 2, 3], 3) // true
+     * Guardian.isLengthArray([1, 2], 3) // false
+     */
     static isLengthArray(value, reference) {
         if (Guardian.isArray(value).falsy()) {
             throw new guardian_exception_1.GuardianException("The value is not an array");
         }
         return value?.length === reference;
     }
-    static isEmpty(value) {
-        if (Guardian.isNullOrUndefined(value)) {
-            return true;
-        }
-        if (Guardian.isString(value) || Guardian.isArray(value)) {
-            return value.length === 0;
-        }
-        if (Guardian.isObject(value)) {
-            return Object.keys(value).length === 0;
-        }
-        return false;
-    }
+    // ==================== Validação de Nulos e Indefinidos ====================
+    /**
+     * Verifica se um valor é undefined.
+     * @param value - Valor a ser verificado
+     * @returns true se value é undefined, false caso contrário
+     * @example
+     * Guardian.isUndefined(undefined) // true
+     * Guardian.isUndefined(null) // false
+     */
     static isUndefined(value) {
         return value === undefined;
     }
+    /**
+     * Verifica se um valor não é undefined.
+     * @param value - Valor a ser verificado
+     * @returns true se value não é undefined, false caso contrário
+     * @example
+     * Guardian.isNotUndefined(null) // true
+     * Guardian.isNotUndefined(undefined) // false
+     */
     static isNotUndefined(value) {
         return value !== undefined;
     }
+    /**
+     * Verifica se um valor é null.
+     * @param value - Valor a ser verificado
+     * @returns true se value é null, false caso contrário
+     * @example
+     * Guardian.isNull(null) // true
+     * Guardian.isNull(undefined) // false
+     */
     static isNull(value) {
         return value === null;
     }
+    /**
+     * Verifica se um valor não é null.
+     * @param value - Valor a ser verificado
+     * @returns true se value não é null, false caso contrário
+     * @example
+     * Guardian.isNotNull(undefined) // true
+     * Guardian.isNotNull(null) // false
+     */
     static isNotNull(value) {
         return value !== null;
     }
+    /**
+     * Verifica se um valor é null ou undefined.
+     * @param value - Valor a ser verificado
+     * @returns true se value é null ou undefined, false caso contrário
+     * @example
+     * Guardian.isNullOrUndefined(null) // true
+     * Guardian.isNullOrUndefined(undefined) // true
+     * Guardian.isNullOrUndefined("") // false
+     */
+    static isNullOrUndefined(value) {
+        if (value === null || value === undefined)
+            return true;
+        return false;
+    }
+    /**
+     * Verifica se um valor não é null e não é undefined.
+     * @param value - Valor a ser verificado
+     * @returns true se value não é null e não é undefined, false caso contrário
+     * @example
+     * Guardian.isNotNullOrUndefined("texto") // true
+     * Guardian.isNotNullOrUndefined(null) // false
+     */
+    static isNotNullOrUndefined(value) {
+        if (value === undefined || value === null)
+            return false;
+        return true;
+    }
+    // ==================== Comparações de Igualdade ====================
+    /**
+     * Verifica se dois valores são iguais usando comparação estrita (===).
+     * @param valueA - Primeiro valor a ser comparado
+     * @param valueB - Segundo valor a ser comparado
+     * @returns true se valueA === valueB, false caso contrário
+     * @example
+     * Guardian.isEqual(5, 5) // true
+     * Guardian.isEqual(5, "5") // false
+     */
     static isEqual(valueA, valueB) {
         return valueA === valueB;
     }
+    /**
+     * Verifica se dois valores são diferentes usando comparação estrita (!==).
+     * @param valueA - Primeiro valor a ser comparado
+     * @param valueB - Segundo valor a ser comparado
+     * @returns true se valueA !== valueB, false caso contrário
+     * @example
+     * Guardian.isDifferent(5, "5") // true
+     * Guardian.isDifferent(5, 5) // false
+     */
     static isDifferent(valueA, valueB) {
         return valueA !== valueB;
     }
+    /**
+     * Verifica se todos os valores de um array são iguais.
+     * @template T - Tipo dos valores no array
+     * @param values - Array de valores a ser verificado
+     * @returns true se todos os valores são iguais, false caso contrário
+     * @example
+     * Guardian.allEqual([5, 5, 5]) // true
+     * Guardian.allEqual([5, 5, 3]) // false
+     */
+    static allEqual(values) {
+        return values.every((v) => Guardian.isEqual(v, values[0]));
+    }
+    /**
+     * Verifica se um valor específico existe em uma coleção de valores.
+     * @param reference - Valor a ser procurado
+     * @param anyValues - Array de valores onde procurar
+     * @returns true se reference existe em anyValues, false caso contrário
+     * @example
+     * Guardian.isAnyOf(3, [1, 2, 3, 4]) // true
+     * Guardian.isAnyOf(5, [1, 2, 3, 4]) // false
+     */
     static isAnyOf(reference, anyValues) {
         for (const value of anyValues) {
             if (Guardian.isEqual(reference, value)) {
@@ -77,45 +377,249 @@ class Guardian {
         }
         return false;
     }
-    static ternaryCondition(condition, returnIfTrue, returnIfFalse) {
-        return condition ? returnIfTrue : returnIfFalse;
+    // ==================== Validação de Strings ====================
+    /**
+     * Verifica se uma string é um endereço de email válido.
+     * @param value - String a ser validada como email
+     * @returns true se value é um email válido, false caso contrário
+     * @example
+     * Guardian.isEmail("user@example.com") // true
+     * Guardian.isEmail("invalid-email") // false
+     */
+    static isEmail(value) {
+        return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
     }
-    static isBetween(value, min, max) {
-        if (min > max)
-            throw new guardian_exception_1.GuardianException(`Max ${max} should be greater than min ${min}.`);
-        if (Guardian.isEmpty(value)) {
-            throw new guardian_exception_1.GuardianException("Cannot check length of a value. Provided value is empty");
+    /**
+     * Verifica se uma string é uma URL válida.
+     * @param value - String a ser validada como URL
+     * @returns true se value é uma URL válida, false caso contrário
+     * @example
+     * Guardian.isURL("https://example.com") // true
+     * Guardian.isURL("not a url") // false
+     */
+    static isURL(value) {
+        try {
+            new URL(value);
+            return true;
+        }
+        catch {
+            return false;
         }
-        const valueLength = Guardian.isNumber(value) ? value : Number(value);
-        return valueLength >= min && valueLength <= max;
     }
-    static isNullOrUndefined(value) {
-        if (value === null || value === undefined)
-            return true;
-        return false;
+    /**
+     * Verifica se uma string é um UUID (Universally Unique Identifier) válido.
+     * @param value - String a ser validada como UUID
+     * @returns true se value é um UUID válido, false caso contrário
+     * @example
+     * Guardian.isUUID("550e8400-e29b-41d4-a716-446655440000") // true
+     * Guardian.isUUID("invalid-uuid") // false
+     */
+    static isUUID(value) {
+        return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
     }
-    static isNotNullOrUndefined(value) {
-        if (value === undefined || value === null)
-            return false;
-        return true;
+    // ==================== Validação de Tipos Compostos ====================
+    /**
+     * Verifica se um valor é do tipo booleano.
+     * @param value - Valor a ser verificado
+     * @returns true se value é um booleano, false caso contrário
+     * @example
+     * Guardian.isBoolean(true) // true
+     * Guardian.isBoolean(1) // false
+     */
+    static isBoolean(value) {
+        return typeof value === "boolean";
+    }
+    /**
+     * Verifica se um valor é uma função.
+     * @param value - Valor a ser verificado
+     * @returns true se value é uma função, false caso contrário
+     * @example
+     * Guardian.isFunction(() => {}) // true
+     * Guardian.isFunction("função") // false
+     */
+    static isFunction(value) {
+        return typeof value === "function";
+    }
+    /**
+     * Verifica se um valor é um objeto Date válido.
+     * @param value - Valor a ser verificado
+     * @returns true se value é uma data válida, false caso contrário
+     * @example
+     * Guardian.isDate(new Date()) // true
+     * Guardian.isDate(new Date("invalid")) // false
+     * Guardian.isDate("2024-01-01") // false
+     */
+    static isDate(value) {
+        return value instanceof Date && !Number.isNaN(value.getTime());
+    }
+    // ==================== Validação de Coleções ====================
+    /**
+     * Verifica se todos os elementos de um array satisfazem um predicado.
+     * @template T - Tipo dos elementos do array
+     * @param array - Array a ser verificado
+     * @param predicate - Função que retorna true/false para cada elemento
+     * @returns true se todos os elementos satisfazem o predicado, false caso contrário
+     * @example
+     * Guardian.isEveryOf([2, 4, 6], x => x % 2 === 0) // true
+     * Guardian.isEveryOf([2, 3, 6], x => x % 2 === 0) // false
+     */
+    static isEveryOf(array, predicate) {
+        return array.every(predicate);
+    }
+    /**
+     * Verifica se pelo menos um elemento de um array satisfaz um predicado.
+     * @template T - Tipo dos elementos do array
+     * @param array - Array a ser verificado
+     * @param predicate - Função que retorna true/false para cada elemento
+     * @returns true se pelo menos um elemento satisfaz o predicado, false caso contrário
+     * @example
+     * Guardian.isSomeOf([1, 2, 4], x => x % 2 === 0) // true
+     * Guardian.isSomeOf([1, 3, 5], x => x % 2 === 0) // false
+     */
+    static isSomeOf(array, predicate) {
+        return array.some(predicate);
+    }
+    /**
+     * Verifica se um valor que possui propriedade length tem exatamente o comprimento específico.
+     * @template T - Tipo do valor com propriedade length
+     * @param value - Valor a ser verificado
+     * @param length - Comprimento esperado
+     * @returns true se o comprimento é exatamente o especificado, false caso contrário
+     * @example
+     * Guardian.hasLength("hello", 5) // true
+     * Guardian.hasLength([1, 2, 3], 3) // true
+     * Guardian.hasLength([1, 2], 3) // false
+     */
+    static hasLength(value, length) {
+        return value.length === length;
+    }
+    /**
+     * Verifica se um valor existe dentro de uma coleção.
+     * @template T - Tipo dos valores
+     * @param value - Valor a ser procurado
+     * @param collection - Coleção onde procurar
+     * @returns true se value está na coleção, false caso contrário
+     * @example
+     * Guardian.isWithin(3, [1, 2, 3, 4]) // true
+     * Guardian.isWithin(5, [1, 2, 3, 4]) // false
+     */
+    static isWithin(value, collection) {
+        return collection.includes(value);
+    }
+    /**
+     * Verifica se um valor não existe dentro de uma coleção.
+     * @template T - Tipo dos valores
+     * @param value - Valor a ser procurado
+     * @param collection - Coleção onde procurar
+     * @returns true se value não está na coleção, false caso contrário
+     * @example
+     * Guardian.isNotWithin(5, [1, 2, 3, 4]) // true
+     * Guardian.isNotWithin(3, [1, 2, 3, 4]) // false
+     */
+    static isNotWithin(value, collection) {
+        return !collection.includes(value);
+    }
+    // ==================== Validação de Objetos ====================
+    /**
+     * Verifica se um objeto possui uma propriedade específica (própria ou herdada).
+     * @template T - Tipo do objeto
+     * @param value - Objeto a ser verificado
+     * @param property - Nome da propriedade a procurar
+     * @returns true se o objeto possui a propriedade, false caso contrário
+     * @example
+     * Guardian.hasProperty({ name: "João" }, "name") // true
+     * Guardian.hasProperty({ name: "João" }, "age") // false
+     */
+    static hasProperty(value, property) {
+        return property in value;
+    }
+    /**
+     * Verifica se um objeto possui uma propriedade própria (não herdada).
+     * @template T - Tipo do objeto
+     * @param value - Objeto a ser verificado
+     * @param property - Nome da propriedade a procurar
+     * @returns true se o objeto possui a propriedade própria, false caso contrário
+     * @example
+     * Guardian.hasOwnProperty({ name: "João" }, "name") // true
+     * Guardian.hasOwnProperty({ name: "João" }, "toString") // false
+     */
+    static hasOwnProperty(value, property) {
+        return Object.prototype.hasOwnProperty.call(value, property);
+    }
+    // ==================== Validação de Tipos ====================
+    /**
+     * Verifica se um valor é do tipo primitivo especificado.
+     * @template T - Tipo esperado do valor
+     * @param value - Valor a ser verificado
+     * @param type - Tipo primitivo esperado (string, number, boolean, etc)
+     * @returns true se value é do tipo especificado, false caso contrário
+     * @example
+     * Guardian.isTypeOf("hello", "string") // true
+     * Guardian.isTypeOf(42, "number") // true
+     * Guardian.isTypeOf(42, "string") // false
+     */
+    static isTypeOf(value, type) {
+        return Guardian.isEqual(typeof value, type);
+    }
+    /**
+     * Verifica se um valor não é do tipo primitivo especificado.
+     * @template T - Tipo esperado do valor
+     * @param value - Valor a ser verificado
+     * @param type - Tipo primitivo a ser descartado
+     * @returns true se value não é do tipo especificado, false caso contrário
+     * @example
+     * Guardian.isNotTypeOf(42, "string") // true
+     * Guardian.isNotTypeOf("hello", "string") // false
+     */
+    static isNotTypeOf(value, type) {
+        return Guardian.isDifferent(typeof value, type);
+    }
+    /**
+     * Verifica se um valor é uma instância de uma classe/construtor específico.
+     * @template T - Tipo esperado da instância
+     * @param value - Valor a ser verificado
+     * @param instance - Construtor/classe a ser verificado
+     * @returns true se value é uma instância de instance, false caso contrário
+     * @example
+     * Guardian.isInstanceOf(new Date(), Date) // true
+     * Guardian.isInstanceOf(new Date(), Array) // false
+     * Guardian.isInstanceOf(new User(), User) // true
+     */
+    static isInstanceOf(value, instance) {
+        return value instanceof instance;
     }
+    // ==================== Métodos Privados ====================
+    /**
+     * Verifica se um valor é do tipo numérico.
+     * @param value - Valor a ser verificado
+     * @returns true se value é um número, false caso contrário
+     */
     static isNumber(value) {
         return typeof value === "number";
     }
+    /**
+     * Verifica se um valor é do tipo string.
+     * @param value - Valor a ser verificado
+     * @returns true se value é uma string, false caso contrário
+     */
     static isString(value) {
         return typeof value === "string";
     }
+    /**
+     * Verifica se um valor é um array.
+     * @param value - Valor a ser verificado
+     * @returns true se value é um array, false caso contrário
+     */
     static isArray(value) {
         return Array.isArray(value);
     }
+    /**
+     * Verifica se um valor é um objeto.
+     * @param value - Valor a ser verificado
+     * @returns true se value é um objeto, false caso contrário
+     */
     static isObject(value) {
         return typeof value === "object";
     }
-    static isTypeOf(value, type) {
-        return Guardian.isEqual(typeof value, type);
-    }
-    static isNotTypeOf(value, type) {
-        return Guardian.isDifferent(typeof value, type);
-    }
 }
 exports._ = Guardian;

package/objects/@common/edges/cron-expression.edge.d.ts

@@ -1,6 +1,34 @@
 import { StringEdgeSketch } from "../../primitives/string.edge.sketch";
 export declare class CronExpressionEdge extends StringEdgeSketch {
-    private readonly _expression;
-    constructor(_expression: string);
+    constructor(expression: string);
     protected validateCronExpression(): void;
+    /**
+     * Retorna a expressão cron.
+     */
+    toString(): string;
+    /**
+     * Retorna os campos da expressão cron.
+     */
+    getFields(): string[];
+    /**
+     * Compara com outra expressão cron (string ou edge).
+     */
+    isEqual(other: string | CronExpressionEdge): boolean;
+    isDifferent(other: string | CronExpressionEdge): boolean;
+    /**
+     * Retorna a próxima execução a partir de uma data base.
+     */
+    nextDate(fromDate?: Date): Date;
+    /**
+     * Retorna a execução anterior a partir de uma data base.
+     */
+    previousDate(fromDate?: Date): Date;
+    /**
+     * Retorna as próximas N execuções.
+     */
+    nextDates(count: number, fromDate?: Date): Date[];
+    /**
+     * Valida expressão cron sem lançar exceção.
+     */
+    static isValid(expression: string): boolean;
 }