@eliasrrosa/tutorhub-public-assets 0.0.10 → 0.0.11

package/dist/domain/entities/ISO8601TimezoneParser.test.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601TimezoneParser_1 = require("./ISO8601TimezoneParser");
+describe("ISO8601TimezoneParser", () => {
+    describe("ISO8601TimezoneParser constructor", () => {
+        it("Should be instantiable without arguments", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser).toBeDefined();
+        });
+    });
+    describe("ISO8601TimezoneParser.toString()", () => {
+        it("Should return Z for UTC.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(0)).toEqual("Z");
+        });
+        it("Should return Z for invalid timezone.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(1000)).toEqual("Z");
+        });
+        it("Should return +03:00 for 180.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(180)).toEqual("+03:00");
+        });
+        it("Should return -03:00 for -180.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(-180)).toEqual("-03:00");
+        });
+        it("Should return -02:00 for -120.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(-120)).toEqual("-02:00");
+        });
+        it("Should return -02:30 for -150.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(-150)).toEqual("-02:30");
+        });
+        it("Should return +02:30 for 150.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(150)).toEqual("+02:30");
+        });
+        it("Should return +04:00 for 240.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(240)).toEqual("+04:00");
+        });
+        it("Should return +07:00 for 420.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(420)).toEqual("+07:00");
+        });
+        it("Should return -07:00 for -420.", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toString(-420)).toEqual("-07:00");
+        });
+    });
+    describe("ISO8601TimezoneParser.toMinutes()", () => {
+        it("Should return 0 given Z", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes("Z")).toEqual(0);
+        });
+        it("Should return 0 given Z plus milliseconds", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes(".192Z")).toEqual(0);
+        });
+        it("Should return 60 given +01:00", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes("+01:00")).toEqual(60);
+        });
+        it("Should return 90 given +01:30", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes("+01:30")).toEqual(90);
+        });
+        it("Should return 130 given +02:10", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes("+02:10")).toEqual(130);
+        });
+        it("Should return -60 given -01:00", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes("-01:00")).toEqual(-60);
+        });
+        it("Should return 90 given +01:30", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes("+01:30")).toEqual(90);
+        });
+        it("Should return 130 given +02:10", () => {
+            const parser = new ISO8601TimezoneParser_1.ISO8601TimezoneParser();
+            expect(parser.toMinutes("+02:10")).toEqual(130);
+        });
+    });
+});

package/dist/domain/entities/ISO8601TimezoneSelector.d.ts

@@ -0,0 +1,32 @@
+export interface IISO8601TimezoneSelector {
+    /**
+     * Accepts any string with a timezone on it,
+     * eg:. `Z, .sssZ, (+|-)HH:MM`, or any valid timezone number
+     * in minutes (-840 up to 720) and returns only the timezone string.
+     * If the timezone is not valid, returns Z.
+     */
+    getTimezoneString: (timezone: string) => string;
+    /**
+     * Returns a string representing the difference of hours of the timezone
+     * from UTC, rounded down. If timezone is UTC or invalid, returns undefined.
+     */
+    getHoursString: (timezone: string) => string | undefined;
+    /**
+     * Returns a string representing the difference of minutes of the timezone
+     * from UTC minus the hours. Eg:. `+02:30` returns `"30"`. If timezone is UTC
+     * or invalid, returns undefined.
+     */
+    getMinutesString: (timezone: string) => string | undefined;
+    /**
+     * Returns "+" for positive timezones likes +03:00, "-" for negative timezones
+     * like -02:00, or undefined if timezone is UTC or invalid.
+     */
+    getTimezoneSign: (timezone: string) => string | undefined;
+}
+export declare class ISO8601TimezoneSelector implements IISO8601TimezoneSelector {
+    private timezoneValidator;
+    getTimezoneString: (timezone: string) => string;
+    getHoursString: (timezone: string) => string | undefined;
+    getMinutesString: (timezone: string) => string | undefined;
+    getTimezoneSign: (timezone: string) => string | undefined;
+}

package/dist/domain/entities/ISO8601TimezoneSelector.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601TimezoneSelector = void 0;
+const ISO8601TimezoneValidator_1 = require("./ISO8601TimezoneValidator");
+class ISO8601TimezoneSelector {
+    constructor() {
+        this.timezoneValidator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+        this.getTimezoneString = (timezone) => {
+            const timezoneFormatIsValid = this.timezoneValidator.formatIsValid(timezone);
+            if (!timezoneFormatIsValid) {
+                return "Z";
+            }
+            if (typeof timezone == "string" &&
+                (this.timezoneValidator.timezoneIsZ(timezone) ||
+                    this.timezoneValidator.timezoneIsZandMilliseconds(timezone))) {
+                return "Z";
+            }
+            if (typeof timezone == "string" &&
+                this.timezoneValidator.timezoneIsNumbered(timezone)) {
+                const match = timezone.match(this.timezoneValidator.numberedTimezonePattern);
+                if (!match)
+                    return "Z";
+                return match[0];
+            }
+            return "Z";
+        };
+        this.getHoursString = (timezone) => {
+            var _a;
+            if (this.timezoneValidator.timezoneIsNumbered(timezone)) {
+                const matches = timezone.match(this.timezoneValidator.numberedTimezonePatternString);
+                if (matches == null || matches.length < 1)
+                    return undefined;
+                return (_a = matches[0].split(":")) === null || _a === void 0 ? void 0 : _a[0].split("").slice(1).join("");
+            }
+            return undefined;
+        };
+        this.getMinutesString = (timezone) => {
+            var _a;
+            if (this.timezoneValidator.timezoneIsNumbered(timezone)) {
+                const matches = timezone.match(this.timezoneValidator.numberedTimezonePatternString);
+                if (matches == null || matches.length < 1)
+                    return undefined;
+                return (_a = matches[0].split(":")) === null || _a === void 0 ? void 0 : _a[1];
+            }
+            return undefined;
+        };
+        this.getTimezoneSign = (timezone) => {
+            if (this.timezoneValidator.timezoneIsNumbered(timezone)) {
+                const matches = timezone.match(this.timezoneValidator.numberedTimezonePatternString);
+                if (matches == null || matches.length < 1)
+                    return undefined;
+                if (matches[0].includes("+"))
+                    return "+";
+                if (matches[0].includes("-"))
+                    return "-";
+            }
+            return undefined;
+        };
+    }
+}
+exports.ISO8601TimezoneSelector = ISO8601TimezoneSelector;

package/dist/domain/entities/ISO8601TimezoneSelector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/domain/entities/ISO8601TimezoneSelector.test.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601TimezoneSelector_1 = require("./ISO8601TimezoneSelector");
+describe("ISO8601TimezoneSelector", () => {
+    describe("ISO8601TimezoneSelector constructor", () => {
+        it("Should be instantiable without arguments.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector).toBeDefined();
+        });
+    });
+    describe("ISO8601TimezoneSelector.getTimezoneString()", () => {
+        it("Should return 'Z' for no timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneString("")).toEqual("Z");
+        });
+        it("Should return 'Z' for UTC timezone without milliseconds.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneString("12:00:00Z")).toEqual("Z");
+        });
+        it("Should return 'Z' for UTC timezone with milliseconds.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneString("12:00:00.000Z")).toEqual("Z");
+        });
+        it("Should return timezone given timezone presence in argument", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneString("12:00:00+03:00")).toEqual("+03:00");
+        });
+        it("Should return negative timezone given timezone presence in argument", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneString("12:00:00-03:00")).toEqual("-03:00");
+        });
+    });
+    describe("ISO8601TimezoneSelector.getMinutesString()", () => {
+        it("Should return undefined for no timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC timezone plus hours.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("12:00:00Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC plus milliseconds timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString(".123Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC plus milliseconds timezone plus hours.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("12:00:00.123Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC plus milliseconds timezone plus hours.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("12:00:00.123Z")).toEqual(undefined);
+        });
+        it("Should return 00 given +01:00 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("+01:00")).toEqual("00");
+        });
+        it("Should return 00 given -01:00 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("-01:00")).toEqual("00");
+        });
+        it("Should return 30 given +01:30 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("+01:30")).toEqual("30");
+        });
+        it("Should return 30 given -01:30 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("-01:30")).toEqual("30");
+        });
+        it("Should return 00 given +03:00 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("+03:00")).toEqual("00");
+        });
+        it("Should return 00 given timezone with time.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getMinutesString("12:00:00+03:00")).toEqual("00");
+        });
+    });
+    describe("ISO8601TimezoneSelector.getHoursString()", () => {
+        it("Should return undefined for no timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC timezone plus hours.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("12:00:00Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC plus milliseconds timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString(".123Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC plus milliseconds timezone plus hours.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("12:00:00.123Z")).toEqual(undefined);
+        });
+        it("Should return undefined for no UTC plus milliseconds timezone plus hours.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("12:00:00.123Z")).toEqual(undefined);
+        });
+        it("Should return 01 given +01:00 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("+01:00")).toEqual("01");
+        });
+        it("Should return 01 given -01:00 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("-01:00")).toEqual("01");
+        });
+        it("Should return 01 given +01:30 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("+01:30")).toEqual("01");
+        });
+        it("Should return 01 given -01:30 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("-01:30")).toEqual("01");
+        });
+        it("Should return 03 given +03:00 timezone.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("+03:00")).toEqual("03");
+        });
+        it("Should return 03 given timezone with time.", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getHoursString("12:00:00+03:00")).toEqual("03");
+        });
+    });
+    describe("ISO8601TimezoneSelector.getTimezoneSign()", () => {
+        it("Should return + for positive timezones", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneSign("12:00:00+03:00")).toEqual("+");
+        });
+        it("Should return - for negative timezones", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneSign("12:00:00-03:00")).toEqual("-");
+        });
+        it("Should return undefined for UTC timezones", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneSign("12:00:00Z")).toEqual(undefined);
+        });
+        it("Should return undefined for invalid timezones", () => {
+            const selector = new ISO8601TimezoneSelector_1.ISO8601TimezoneSelector();
+            expect(selector.getTimezoneSign("asdasdasd")).toEqual(undefined);
+        });
+    });
+});

package/dist/domain/entities/ISO8601TimezoneValidator.d.ts

@@ -0,0 +1,22 @@
+export interface IISO8601TimezoneValidator {
+    /**Returns `true` if timezone is a string and contains a (+|-)HH:MM format,
+     * with a range of +12:00 and -14:00, or a number between -840 (-14:00) and 720 (+12:00).
+     * Otherwise returns `false` */
+    formatIsValid: (timezone: number | string) => boolean;
+}
+export declare class ISO8601TimezoneValidator implements IISO8601TimezoneValidator {
+    private upTo59;
+    private upTo11;
+    private upTo13;
+    zTimezonePatternString: string;
+    zTimezonePattern: RegExp;
+    zAndMillisecondsPatternString: string;
+    zAndMillisecondsPattern: RegExp;
+    numberedTimezonePatternString: string;
+    numberedTimezonePattern: RegExp;
+    formatIsValid: (timezone: number | string) => boolean;
+    timezoneIsNumbered(timezone: string): boolean;
+    timezoneIsZ(timezone: string): boolean;
+    timezoneIsZandMilliseconds(timezone: string): boolean;
+    timezoneNumberIsValid(timezone: number): boolean;
+}

package/dist/domain/entities/ISO8601TimezoneValidator.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ISO8601TimezoneValidator = void 0;
+class ISO8601TimezoneValidator {
+    constructor() {
+        this.upTo59 = "[0-5][0-9]";
+        this.upTo11 = "(0[0-9]|1[0-1])";
+        this.upTo13 = "(0[0-9]|1[0-4])";
+        this.zTimezonePatternString = "Z";
+        this.zTimezonePattern = new RegExp(`${this.zTimezonePatternString}$`);
+        this.zAndMillisecondsPatternString = `.[0-9]{3}Z`;
+        this.zAndMillisecondsPattern = new RegExp(`${this.zAndMillisecondsPatternString}$`);
+        this.numberedTimezonePatternString = `(\\+(${this.upTo11}:${this.upTo59}|12:00)|\\-(${this.upTo13}:${this.upTo59}|14:00))`;
+        this.numberedTimezonePattern = new RegExp(`${this.numberedTimezonePatternString}$`);
+        this.formatIsValid = (timezone) => {
+            if (typeof timezone == "number") {
+                return this.timezoneNumberIsValid(timezone);
+            }
+            return (this.timezoneIsNumbered(timezone) ||
+                this.timezoneIsZ(timezone) ||
+                this.timezoneIsZandMilliseconds(timezone));
+        };
+    }
+    timezoneIsNumbered(timezone) {
+        return this.numberedTimezonePattern.test(timezone);
+    }
+    timezoneIsZ(timezone) {
+        return this.zTimezonePattern.test(timezone);
+    }
+    timezoneIsZandMilliseconds(timezone) {
+        return this.zAndMillisecondsPattern.test(timezone);
+    }
+    timezoneNumberIsValid(timezone) {
+        return timezone >= -840 && timezone <= 720;
+    }
+}
+exports.ISO8601TimezoneValidator = ISO8601TimezoneValidator;

package/dist/domain/entities/ISO8601TimezoneValidator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/domain/entities/ISO8601TimezoneValidator.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ISO8601TimezoneValidator_1 = require("./ISO8601TimezoneValidator");
+describe("ISO8601TimezoneValidator", () => {
+    describe("ISO8601TimezoneValidator constructor", () => {
+        it("Should be instantiable with no arguments.", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator).toBeDefined();
+        });
+    });
+    describe("ISO8601TimezoneValidator.formatIsValid()", () => {
+        it("Should return true for time string with numbered timezone", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("12:00:00-03:00")).toBe(true);
+        });
+        it("Should return true for timezone string with numbered timezone", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("-03:00")).toBe(true);
+        });
+        it("Should return true for timestring string with Z", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("12:00:00Z")).toBe(true);
+        });
+        it("Should return true for timezone string with Z", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("Z")).toBe(true);
+        });
+        it("Should return true for timezone string with Z and miliseconds", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid(".999Z")).toBe(true);
+        });
+        it("Should return true for time string with Z and miliseconds", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("12:00:00.999Z")).toBe(true);
+        });
+        it("Should return false for numbered timezones greater than +12:00", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("12:00:00+12:01")).toBe(false);
+        });
+        it("Should return false for numbered timezones smaller than -14:00", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("12:00:00+14:01")).toBe(false);
+        });
+        it("Should return false for no timezone", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid("12:00:00")).toBe(false);
+        });
+        it("Should return false for numbers below -840", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid(-841)).toBe(false);
+        });
+        it("Should return false for numbers above 720", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid(721)).toBe(false);
+        });
+        it("Should return true for numbers between -840 and 720", () => {
+            const validator = new ISO8601TimezoneValidator_1.ISO8601TimezoneValidator();
+            expect(validator.formatIsValid(720)).toBe(true);
+            expect(validator.formatIsValid(-840)).toBe(true);
+            expect(validator.formatIsValid(0)).toBe(true);
+            expect(validator.formatIsValid(200)).toBe(true);
+            expect(validator.formatIsValid(180)).toBe(true);
+        });
+    });
+});

package/dist/domain/entities/Time.d.ts

@@ -1,9 +1,29 @@
+import { IISO8601Timezone } from "./ISO8601Timezone";
 import { ITimeValidator } from "./TimeValidator";
 export interface ITime {
-    validator: ITimeValidator;
-    getTime: () => string;
-    getHours: () => string;
-    getMinutes: () => string;
-    getSeconds: () => string;
-    getNow: () => string;
+    originalTimeString: string;
+    timeValidator: ITimeValidator;
+    /**
+     * returns time string in chosen format. Default is `HH:MM`.
+     *
+     *`convertToTimezone` accepts a timezone string like `(+|-)HH:MM` or `Z` or
+     * a number representing the difference of the timezone from UTC in minutes (eg:. +03:00 is 180, -02:00 is -120).
+     * If present, this function will return a time string converted to this timezone, based on the original
+     * timezone present on the time string passed to the constructor.
+     */
+    getTimeString: (opts?: {
+        format?: "HH:MM" | "HH:MM:SS" | "HH:MM:SS(+|-)HH:MM";
+        convertToTimezone?: string | number;
+    }) => string;
+    getHoursString: () => string;
+    getMinutesString: () => string;
+    getSecondsString: () => string;
+    getNowTimeString: () => string;
+    getTimezone: () => IISO8601Timezone;
+    addHours: (hours: number) => ITime;
+    addMinutes: (minutes: number) => ITime;
+    /**Adds a timezone without converting the time, following ISO8601 format, like `Z` for UTC,
+     * and `(+|-)HH:MM` for others. */
+    addTimezone: (timezone: string | number) => ITime;
+    getTimezoneString: () => string;
 }