cron-converter-u2q 1.2.1 → 1.3.0

package/README.md

@@ -54,7 +54,7 @@ pnpm add cron-converter-u2q
 ## 🚀 Quick Start
 
 ```typescript
-import { CronConverterU2Q } from 'cron-converter-u2q';
+import { CronConverterU2Q, CronDescriberU2Q } from 'cron-converter-u2q';
 
 // Convert Unix to Quartz
 const quartzExpression = CronConverterU2Q.unixToQuartz('5 * * * *');
@@ -63,9 +63,8 @@ console.log(quartzExpression); // "0 5 * * * ? *"
 // Convert Quartz to Unix
 const unixExpression = CronConverterU2Q.quartzToUnix('0 0 8 * * ?');
 console.log(unixExpression); // "0 8 * * *"
-
 // Get human-readable description
-const description = CronConverterU2Q.describeUnix('*/5 * * * *');
+const description = CronDescriberU2Q.describeUnix('*/5 * * * *');
 console.log(description); // "Every 5 minutes"
 ```
 
@@ -77,7 +76,6 @@ console.log(description); // "Every 5 minutes"
 // Unix to Quartz
 CronConverterU2Q.unixToQuartz('0 12 * * *');     // "0 0 12 * * ? *"
 CronConverterU2Q.unixToQuartz('*/15 * * * *');   // "0 */15 * * * ? *"
-
 // Quartz to Unix
 CronConverterU2Q.quartzToUnix('0 0 8 * * ?');    // "0 8 * * *"
 CronConverterU2Q.quartzToUnix('0 */5 * * * ?');  // "*/5 * * * *"
@@ -87,12 +85,12 @@ CronConverterU2Q.quartzToUnix('0 */5 * * * ?');  // "*/5 * * * *"
 
 ```typescript
 // Unix format descriptions
-CronConverterU2Q.describeUnix('0 12 * * *');     // "At 12:00 PM"
-CronConverterU2Q.describeUnix('*/15 * * * *');   // "Every 15 minutes"
+CronDescriberU2Q.describeUnix('0 12 * * *');     // "At 12 o'clock"
+CronDescriberU2Q.describeUnix('*/15 * * * *');   // "Every 15 minutes"
 
 // Quartz format descriptions
-CronConverterU2Q.describeQuartz('0 0 8 * * ?');  // "At 8:00 AM"
-CronConverterU2Q.describeQuartz('0 */5 * * * ?'); // "Every 5 minutes"
+CronDescriberU2Q.describeQuartz('0 0 8 * * ?');  // "At 8 o'clock"
+CronDescriberU2Q.describeQuartz('0 */5 * * * ?'); // "Every 5 minutes"
 ```
 
 ## 🤝 Contributing
@@ -121,3 +119,13 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - Inspired by the need for a simple, reliable cron expression converter
 - Built with TypeScript for better developer experience
 
+## 📖 Specifications
+
+This library's conversion logic is grounded in the following official specifications:
+
+- **POSIX IEEE Std 1003.1** – Defines the standard Unix cron expression format (5 fields: minute, hour, day-of-month, month, day-of-week).
+  [https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/crontab.html)
+
+- **Quartz Scheduler** – Defines the extended Quartz cron trigger format (6–7 fields: seconds, minute, hour, day-of-month, month, day-of-week, optional year). Notably, exactly one of `day-of-month` or `day-of-week` must be `?` to avoid scheduling conflicts.
+  [https://www.quartz-scheduler.org/documentation/quartz-2.3.0/tutorials/crontrigger.html](https://www.quartz-scheduler.org/documentation/quartz-2.3.0/tutorials/crontrigger.html)
+

package/lib/converter.d.ts

@@ -1,7 +1,4 @@
 export declare class CronConverterU2Q {
-    static readonly delimiter = " ";
-    static readonly unixExpressionLength = 5;
-    static readonly quartzExpressionLengths: number[];
     /**
      * Converts a unix cron expression to a quartz cron expression by adding '0' seconds
      * @param unixExpression - the unix expression
@@ -14,5 +11,21 @@ export declare class CronConverterU2Q {
      * @returns the corresponding unix expression
      */
     static quartzToUnix(quartzExpression: string): string;
-    private static validateIfNullOrEmpty;
+    /**
+     * Converts interval parts for both Unix and Quartz expressions.
+     * In both directions, normalises step notation to the Unix `*\/N` format.
+     */
+    private static convertIntervalParts;
+    /**
+     * Converts Unix DOW to Quartz DOW, supporting lists, ranges, and special cases.
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat, 7=Sun(alias)
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     */
+    private static unixDowToQuartz;
+    /**
+     * Converts Quartz DOW to Unix DOW, supporting lists, ranges, and special cases.
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat
+     */
+    static quartzDowToUnix(dow: string): string;
 }

package/lib/converter.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CronConverterU2Q = void 0;
+const helper_1 = require("./helper");
+const validator_1 = require("./validator");
 class CronConverterU2Q {
     /**
      * Converts a unix cron expression to a quartz cron expression by adding '0' seconds
@@ -8,18 +10,21 @@ class CronConverterU2Q {
      * @returns the corresponding quartz expression
      */
     static unixToQuartz(unixExpression) {
-        this.validateIfNullOrEmpty(unixExpression);
-        const parts = unixExpression.split(this.delimiter);
-        if (parts.length !== this.unixExpressionLength)
-            throw new Error(`Invalid unix cron format`);
-        const [min, hour, dom, month, dow] = parts;
+        validator_1.CronValidatorU2Q.validateUnix(unixExpression);
+        const parts = helper_1.ExpressionHelper.GetExpressionParts(unixExpression);
+        const [min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part));
+        // Enhanced DOW conversion: handle lists, ranges, and special cases
+        let quartzDow = this.unixDowToQuartz(dow);
         let quartzDom = dom;
-        let quartzDow = dow;
-        if (dom === '*' && (dow === '*' || dow !== '*'))
+        // Per Quartz spec, exactly one of DOM or DOW must be '?'
+        // When DOM is '*' and DOW is specific, DOM gets '?'; otherwise DOW gets '?'
+        if (dom === '*' && dow !== '*') {
             quartzDom = '?';
-        else if (dom !== '*' && dow === '*')
+        }
+        else if (dom !== '*' && dow === '*') {
             quartzDow = '?';
-        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow}`;
+        }
+        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow} *`;
     }
     /**
      * Converts a quartz cron expression to a unix cron expression
@@ -27,27 +32,87 @@ class CronConverterU2Q {
      * @returns the corresponding unix expression
      */
     static quartzToUnix(quartzExpression) {
-        this.validateIfNullOrEmpty(quartzExpression);
-        const parts = quartzExpression.split(this.delimiter);
-        if (!this.quartzExpressionLengths.includes(parts.length))
-            throw new Error(`Invalid quartz cron format`);
-        const [_, min, hour, dom, month, dow] = parts;
-        let unixDom = dom;
-        let unixDow = dow;
-        if (dom === '?' && dow === '*')
-            unixDom = '*';
-        else if (dow === '?' && dom === '*')
-            unixDow = '*';
-        else if (dom !== '?' && dom === '?')
-            unixDom = '*';
+        validator_1.CronValidatorU2Q.validateQuartz(quartzExpression);
+        const parts = helper_1.ExpressionHelper.GetExpressionParts(quartzExpression);
+        const [_, min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part, true));
+        if (dom.includes('L') || dom.includes('W')) {
+            throw new Error("Unix cron does not support 'L' or 'W' in Day of Month");
+        }
+        if (dow.includes('L') || dow.includes('#')) {
+            throw new Error("Unix cron does not support 'L' or '#' in Day of Week");
+        }
+        // Enhanced DOW conversion: handle lists, ranges, and special cases
+        let unixDow = this.quartzDowToUnix(dow);
+        let unixDom = dom === '?' ? '*' : dom;
         return `${min} ${hour} ${unixDom} ${month} ${unixDow}`;
     }
-    static validateIfNullOrEmpty(cronExpression) {
-        if (!cronExpression || cronExpression.trim() === '')
-            throw new Error('Empty or null expression');
+    /**
+     * Converts interval parts for both Unix and Quartz expressions.
+     * In both directions, normalises step notation to the Unix `*\/N` format.
+     */
+    static convertIntervalParts(part, isQuartz = false) {
+        if (isQuartz) {
+            return part.replace(/^0\/(\d+)$/, '*/$1');
+        }
+        return part;
+    }
+    /**
+     * Converts Unix DOW to Quartz DOW, supporting lists, ranges, and special cases.
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat, 7=Sun(alias)
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     */
+    static unixDowToQuartz(dow) {
+        if (dow === '*' || dow === '?')
+            return dow;
+        if (dow.includes(','))
+            return dow.split(',').map(d => this.unixDowToQuartz(d)).join(',');
+        if (dow.includes('-'))
+            return dow.split('-').map(d => this.unixDowToQuartz(d)).join('-');
+        if (dow.endsWith('L')) {
+            const day = dow.slice(0, -1);
+            return `${this.unixDowToQuartz(day)}L`;
+        }
+        if (dow.includes('#')) {
+            const [day, nth] = dow.split('#');
+            return `${this.unixDowToQuartz(day)}#${nth}`;
+        }
+        if (dow === '0' || dow === '7')
+            return '1'; // Sunday
+        const num = parseInt(dow, 10);
+        if (!isNaN(num) && num >= 1 && num <= 6)
+            return (num + 1).toString(); // Mon(1)→2 … Sat(6)→7
+        return dow;
+    }
+    /**
+     * Converts Quartz DOW to Unix DOW, supporting lists, ranges, and special cases.
+     * Quartz: 1=Sun, 2=Mon, ..., 7=Sat
+     * Unix: 0=Sun, 1=Mon, ..., 6=Sat
+     */
+    static quartzDowToUnix(dow) {
+        if (dow === '*' || dow === '?')
+            return dow === '?' ? '*' : dow;
+        // Split compound expressions so each element is converted individually
+        if (dow.includes(','))
+            return dow.split(',').map(d => this.quartzDowToUnix(d)).join(',');
+        if (dow.includes('-'))
+            return dow.split('-').map(d => this.quartzDowToUnix(d)).join('-');
+        // Last (L) — convert the numeric day part, preserve L suffix
+        if (dow.endsWith('L')) {
+            const day = dow.slice(0, -1);
+            return `${this.quartzDowToUnix(day)}L`;
+        }
+        // Nth weekday (#) — convert the numeric day part, preserve #N
+        if (dow.includes('#')) {
+            const [day, nth] = dow.split('#');
+            return `${this.quartzDowToUnix(day)}#${nth}`;
+        }
+        // Numeric mapping
+        if (dow === '1')
+            return '0'; // Sunday
+        const num = parseInt(dow, 10);
+        if (!isNaN(num) && num >= 2 && num <= 7)
+            return (num - 1).toString(); // Mon(2)→1 … Sat(7)→6
+        return dow;
     }
 }
 exports.CronConverterU2Q = CronConverterU2Q;
-CronConverterU2Q.delimiter = ' ';
-CronConverterU2Q.unixExpressionLength = 5;
-CronConverterU2Q.quartzExpressionLengths = [6, 7];

package/lib/describer.d.ts

@@ -0,0 +1,41 @@
+export declare class CronDescriberU2Q {
+    /**
+     * Generates a human-readable description for a Unix-style cron expression.
+     *
+     * Unix-style cron expressions consist of 5 parts:
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (0-6, where 0 = Sunday)
+     * @param unixExpression - A string containing the Unix-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeUnix(unixExpression: string): string;
+    /**
+     * Generates a human-readable description for a Quartz-style cron expression.
+     *
+     * Quartz-style cron expressions consist of 6 or 7 parts:
+     * - Second (0-59)
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (1-7, where 1 = Sunday)
+     * - Year (optional)
+     * @param quartzExpression - A string containing the Quartz-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeQuartz(quartzExpression: string): string;
+    private static describeSecond;
+    private static describeMinute;
+    private static describeHour;
+    private static describeDayOfMonth;
+    private static describeMonth;
+    private static describeDayOfWeek;
+    private static describeYear;
+    private static resolveValue;
+    private static describeField;
+    private static ordinalSuffix;
+    private static combineDescriptions;
+}

package/lib/describer.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronDescriberU2Q = void 0;
+const helper_1 = require("./helper");
+const validator_1 = require("./validator");
+const converter_1 = require("./converter");
+class CronDescriberU2Q {
+    /**
+     * Generates a human-readable description for a Unix-style cron expression.
+     *
+     * Unix-style cron expressions consist of 5 parts:
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (0-6, where 0 = Sunday)
+     * @param unixExpression - A string containing the Unix-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeUnix(unixExpression) {
+        try {
+            validator_1.CronValidatorU2Q.validateUnix(unixExpression);
+            const parts = helper_1.ExpressionHelper.GetExpressionParts(unixExpression);
+            const [min, hour, dom, month, dow] = parts;
+            const descriptions = [
+                this.describeMinute(min, true),
+                this.describeHour(hour),
+                this.describeDayOfMonth(dom),
+                this.describeMonth(month),
+                this.describeDayOfWeek(dow),
+            ];
+            return this.combineDescriptions(descriptions);
+        }
+        catch (error) {
+            return "Invalid Unix cron expression";
+        }
+    }
+    /**
+     * Generates a human-readable description for a Quartz-style cron expression.
+     *
+     * Quartz-style cron expressions consist of 6 or 7 parts:
+     * - Second (0-59)
+     * - Minute (0-59)
+     * - Hour (0-23)
+     * - Day of Month (1-31)
+     * - Month (1-12)
+     * - Day of Week (1-7, where 1 = Sunday)
+     * - Year (optional)
+     * @param quartzExpression - A string containing the Quartz-style cron expression.
+     * @returns A human-readable description or an error message if invalid.
+     */
+    static describeQuartz(quartzExpression) {
+        try {
+            validator_1.CronValidatorU2Q.validateQuartz(quartzExpression);
+            const parts = helper_1.ExpressionHelper.GetExpressionParts(quartzExpression);
+            const [second, min, hour, dom, month, dow, year] = parts;
+            // Normalize Quartz DOW to Unix DOW for consistent description mapping
+            const normalizedDow = converter_1.CronConverterU2Q.quartzDowToUnix(dow);
+            const descriptions = [
+                this.describeSecond(second, true),
+                this.describeMinute(min, true),
+                this.describeHour(hour),
+                this.describeDayOfMonth(dom),
+                this.describeMonth(month),
+                this.describeDayOfWeek(normalizedDow),
+                this.describeYear(year),
+            ];
+            return this.combineDescriptions(descriptions);
+        }
+        catch (error) {
+            return "Invalid Quartz cron expression";
+        }
+    }
+    static describeSecond(second, suppressZero = false) {
+        if (second === "*" || (suppressZero && second === "0"))
+            return "";
+        const desc = this.describeField(second, { nameMap: null, unitSingular: "second", unitPlural: "seconds" });
+        if (desc.startsWith("every") || desc.startsWith("from")) {
+            return desc.charAt(0).toUpperCase() + desc.slice(1);
+        }
+        return `At second ${desc}`;
+    }
+    static describeMinute(min, suppressZero = false) {
+        if (min === "*" || (suppressZero && min === "0"))
+            return "";
+        const desc = this.describeField(min, { nameMap: null, unitSingular: "minute", unitPlural: "minutes" });
+        if (desc.startsWith("every") || desc.startsWith("from")) {
+            return desc.charAt(0).toUpperCase() + desc.slice(1);
+        }
+        return `At minute ${desc}`;
+    }
+    static describeHour(hour) {
+        if (hour === "*")
+            return "";
+        const desc = this.describeField(hour, { nameMap: null, unitSingular: "hour", unitPlural: "hours" });
+        if (desc.startsWith("every") || desc.startsWith("from")) {
+            return desc.charAt(0).toUpperCase() + desc.slice(1);
+        }
+        return `At ${desc} o'clock`;
+    }
+    static describeDayOfMonth(dom) {
+        const desc = this.describeField(dom, {
+            nameMap: null,
+            unitSingular: "day of month",
+            unitPlural: "days of month",
+            isDom: true
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `on the ${desc} of the month`;
+    }
+    static describeMonth(month) {
+        const desc = this.describeField(month, {
+            nameMap: [
+                "January",
+                "February",
+                "March",
+                "April",
+                "May",
+                "June",
+                "July",
+                "August",
+                "September",
+                "October",
+                "November",
+                "December",
+            ],
+            unitSingular: "month",
+            unitPlural: "months"
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `in ${desc}`;
+    }
+    static describeDayOfWeek(dow) {
+        const desc = this.describeField(dow, {
+            nameMap: [
+                "Sunday",
+                "Monday",
+                "Tuesday",
+                "Wednesday",
+                "Thursday",
+                "Friday",
+                "Saturday",
+            ],
+            unitSingular: "day of week",
+            unitPlural: "days of week",
+            isDow: true
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `on ${desc}`;
+    }
+    static describeYear(year) {
+        if (!year || year === "*")
+            return "";
+        const desc = this.describeField(year, {
+            nameMap: null,
+            unitSingular: "year",
+            unitPlural: "years"
+        });
+        if (!desc)
+            return "";
+        if (desc.startsWith("every") || desc.startsWith("from"))
+            return desc;
+        return `in ${desc}`;
+    }
+    static resolveValue(val, config) {
+        if (config.isDow) {
+            if (val.endsWith("L")) {
+                const day = val.slice(0, -1);
+                return `last ${this.resolveValue(day, config)}`;
+            }
+            if (val.includes("#")) {
+                const [day, nth] = val.split("#");
+                const nthStr = this.ordinalSuffix(Number(nth));
+                return `${nthStr} ${this.resolveValue(day, config)}`;
+            }
+            let dowVal = val.toUpperCase();
+            const dayNames = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
+            const aliasIndex = dayNames.indexOf(dowVal);
+            let index = aliasIndex !== -1 ? aliasIndex : Number(val);
+            if (index === 7)
+                index = 0;
+            return config.nameMap ? config.nameMap[index] || val : val;
+        }
+        if (config.isDom) {
+            if (val === "L")
+                return "last day";
+            if (val === "LW")
+                return "last weekday";
+            if (val.endsWith("W")) {
+                const day = val.slice(0, -1);
+                return `nearest weekday to the ${this.resolveValue(day, config)}`;
+            }
+            if (val.startsWith("L-")) {
+                const offset = val.slice(2);
+                return `${offset} days before the last day`;
+            }
+            return this.ordinalSuffix(Number(val));
+        }
+        if (config.nameMap) {
+            let mVal = val.toUpperCase();
+            const monthNames = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
+            const aliasIndex = monthNames.indexOf(mVal);
+            let index = aliasIndex !== -1 ? aliasIndex : Number(val) - 1;
+            return config.nameMap[index] || val;
+        }
+        return val;
+    }
+    static describeField(value, config) {
+        if (value === "*" || value === "?")
+            return "";
+        const parts = value.split(",");
+        const descriptions = parts.map(part => {
+            if (part.includes("/")) {
+                const [start, step] = part.split("/");
+                const stepNum = Number(step);
+                const unit = stepNum === 1 ? config.unitSingular : config.unitPlural;
+                if (start === "*" || start === "0") {
+                    return `every ${step} ${unit}`;
+                }
+                else {
+                    const startDesc = this.resolveValue(start, config);
+                    return `every ${step} ${unit} starting from ${startDesc}`;
+                }
+            }
+            if (part.includes("-")) {
+                const [start, end] = part.split("-");
+                const startDesc = this.resolveValue(start, config);
+                const endDesc = this.resolveValue(end, config);
+                return `from ${startDesc} to ${endDesc}`;
+            }
+            return this.resolveValue(part, config);
+        });
+        if (descriptions.length === 1) {
+            return descriptions[0];
+        }
+        else if (descriptions.length === 2) {
+            return `${descriptions[0]} and ${descriptions[1]}`;
+        }
+        else {
+            return `${descriptions.slice(0, -1).join(", ")}, and ${descriptions[descriptions.length - 1]}`;
+        }
+    }
+    static ordinalSuffix(i) {
+        if (isNaN(i) || i <= 0)
+            return "Invalid day";
+        const j = i % 10;
+        const k = i % 100;
+        if (j === 1 && k !== 11)
+            return i + "st";
+        if (j === 2 && k !== 12)
+            return i + "nd";
+        if (j === 3 && k !== 13)
+            return i + "rd";
+        return i + "th";
+    }
+    static combineDescriptions(descriptions) {
+        const filteredDescriptions = descriptions.filter((part) => part && part !== "");
+        return filteredDescriptions.length > 0
+            ? filteredDescriptions.join(" ").trim()
+            : "Every moment";
+    }
+}
+exports.CronDescriberU2Q = CronDescriberU2Q;

package/lib/helper.d.ts

@@ -0,0 +1,7 @@
+export declare class ExpressionHelper {
+    static readonly delimiter = " ";
+    static readonly unixExpressionLength = 5;
+    static readonly quartzExpressionLengths: number[];
+    static GetExpressionParts(expression: string): string[];
+    private static validateIfNullOrEmpty;
+}

package/lib/helper.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionHelper = void 0;
+class ExpressionHelper {
+    static GetExpressionParts(expression) {
+        this.validateIfNullOrEmpty(expression);
+        const parts = expression.split(this.delimiter).map(part => part.trim());
+        if (this.quartzExpressionLengths.includes(parts.length))
+            return parts;
+        if (this.unixExpressionLength == parts.length)
+            return parts;
+        throw new Error(`Invalid cron expression!`);
+    }
+    static validateIfNullOrEmpty(cronExpression) {
+        if (!cronExpression || cronExpression.trim() === '')
+            throw new Error('Empty or null expression');
+    }
+}
+exports.ExpressionHelper = ExpressionHelper;
+ExpressionHelper.delimiter = ' ';
+ExpressionHelper.unixExpressionLength = 5;
+ExpressionHelper.quartzExpressionLengths = [6, 7];

package/lib/index.d.ts

@@ -1 +1,3 @@
 export * from './converter';
+export * from './describer';
+export * from './validator';

package/lib/index.js

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./converter"), exports);
+__exportStar(require("./describer"), exports);
+__exportStar(require("./validator"), exports);

package/lib/validator.d.ts

@@ -0,0 +1,6 @@
+export declare class CronValidatorU2Q {
+    static validateUnix(expression: string): void;
+    static validateQuartz(expression: string): void;
+    static isValidUnix(expression: string): boolean;
+    static isValidQuartz(expression: string): boolean;
+}