@oneuptime/common 7.0.2513 → 7.0.2550

package/Tests/Types/Database/EqualToOrNull.test.ts

@@ -1,71 +1,71 @@
-import EqualToOrNull from '../../../Types/BaseDatabase/EqualToOrNull';
-import BadDataException from '../../../Types/Exception/BadDataException';
-import { JSONObject } from '../../../Types/JSON';
-import { describe, expect, it } from '@jest/globals';
+import EqualToOrNull from "../../../Types/BaseDatabase/EqualToOrNull";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
 
-describe('EqualToOrNull', () => {
-    it('should create an EqualToOrNull object with a valid value', () => {
-        const value: string = 'oneuptime';
-        const equalObj: EqualToOrNull = new EqualToOrNull(value);
-        expect(equalObj.value).toBe(value);
-    });
+describe("EqualToOrNull", () => {
+  it("should create an EqualToOrNull object with a valid value", () => {
+    const value: string = "oneuptime";
+    const equalObj: EqualToOrNull = new EqualToOrNull(value);
+    expect(equalObj.value).toBe(value);
+  });
 
-    it('should get the value property of an EqualToOrNull object', () => {
-        const value: string = 'oneuptime';
-        const equalObj: EqualToOrNull = new EqualToOrNull(value);
-        expect(equalObj.value).toBe(value);
-    });
+  it("should get the value property of an EqualToOrNull object", () => {
+    const value: string = "oneuptime";
+    const equalObj: EqualToOrNull = new EqualToOrNull(value);
+    expect(equalObj.value).toBe(value);
+  });
 
-    it('should set the value property of an EqualToOrNull object', () => {
-        const equalObj: EqualToOrNull = new EqualToOrNull('oldValue');
-        equalObj.value = 'newValue';
-        expect(equalObj.value).toBe('newValue');
-    });
+  it("should set the value property of an EqualToOrNull object", () => {
+    const equalObj: EqualToOrNull = new EqualToOrNull("oldValue");
+    equalObj.value = "newValue";
+    expect(equalObj.value).toBe("newValue");
+  });
 
-    it('should return the correct string representation using toString method', () => {
-        const equalObj: EqualToOrNull = new EqualToOrNull('oneuptime');
-        expect(equalObj.toString()).toBe('oneuptime');
-    });
+  it("should return the correct string representation using toString method", () => {
+    const equalObj: EqualToOrNull = new EqualToOrNull("oneuptime");
+    expect(equalObj.toString()).toBe("oneuptime");
+  });
 
-    it('should generate the correct JSON representation using toJSON method', () => {
-        const equalObj: EqualToOrNull = new EqualToOrNull('oneuptime');
-        const expectedJSON: JSONObject = {
-            _type: 'EqualToOrNull',
-            value: 'oneuptime',
-        };
-        expect(equalObj.toJSON()).toEqual(expectedJSON);
-    });
+  it("should generate the correct JSON representation using toJSON method", () => {
+    const equalObj: EqualToOrNull = new EqualToOrNull("oneuptime");
+    const expectedJSON: JSONObject = {
+      _type: "EqualToOrNull",
+      value: "oneuptime",
+    };
+    expect(equalObj.toJSON()).toEqual(expectedJSON);
+  });
 
-    it('should create an EqualToOrNull object from valid JSON input', () => {
-        const jsonInput: JSONObject = {
-            _type: 'EqualToOrNull',
-            value: 'oneuptime',
-        };
-        const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
-        expect(equalObj.value).toBe('oneuptime');
-    });
+  it("should create an EqualToOrNull object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "EqualToOrNull",
+      value: "oneuptime",
+    };
+    const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
+    expect(equalObj.value).toBe("oneuptime");
+  });
 
-    it('should throw a BadDataException when using invalid JSON input', () => {
-        const jsonInput: JSONObject = {
-            _type: 'InvalidType',
-            value: 'oneuptime',
-        };
-        expect(() => {
-            return EqualToOrNull.fromJSON(jsonInput);
-        }).toThrow(BadDataException);
-    });
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      value: "oneuptime",
+    };
+    expect(() => {
+      return EqualToOrNull.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
 
-    it('should be a type of EqualToOrNull', () => {
-        const equalObj: EqualToOrNull = new EqualToOrNull('oneuptime');
-        expect(equalObj).toBeInstanceOf(EqualToOrNull);
-    });
+  it("should be a type of EqualToOrNull", () => {
+    const equalObj: EqualToOrNull = new EqualToOrNull("oneuptime");
+    expect(equalObj).toBeInstanceOf(EqualToOrNull);
+  });
 
-    it('should handle null value when using fromJSON method', () => {
-        const jsonInput: JSONObject = {
-            _type: 'EqualToOrNull',
-            value: null,
-        };
-        const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
-        expect(equalObj.value).toBeNull();
-    });
+  it("should handle null value when using fromJSON method", () => {
+    const jsonInput: JSONObject = {
+      _type: "EqualToOrNull",
+      value: null,
+    };
+    const equalObj: EqualToOrNull = EqualToOrNull.fromJSON(jsonInput);
+    expect(equalObj.value).toBeNull();
+  });
 });

package/Tests/Types/Database/InBetween.test.ts

@@ -1,81 +1,81 @@
-import InBetween from '../../../Types/BaseDatabase/InBetween';
-import BadDataException from '../../../Types/Exception/BadDataException';
-import { JSONObject } from '../../../Types/JSON';
-import { describe, expect, it } from '@jest/globals';
+import InBetween from "../../../Types/BaseDatabase/InBetween";
+import BadDataException from "../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../Types/JSON";
+import { describe, expect, it } from "@jest/globals";
 
-describe('InBetween', () => {
-    it('should create an InBetween object with valid start and end values', () => {
-        const startValue: number = 10;
-        const endValue: number = 20;
-        const betweenObj: InBetween = new InBetween(startValue, endValue);
-        expect(betweenObj.startValue).toBe(10);
-        expect(betweenObj.endValue).toBe(20);
-    });
+describe("InBetween", () => {
+  it("should create an InBetween object with valid start and end values", () => {
+    const startValue: number = 10;
+    const endValue: number = 20;
+    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    expect(betweenObj.startValue).toBe(10);
+    expect(betweenObj.endValue).toBe(20);
+  });
 
-    it('should generate the correct JSON representation using toJSON method', () => {
-        const startValue: number = 10;
-        const endValue: number = 20;
-        const betweenObj: InBetween = new InBetween(startValue, endValue);
-        const expectedJSON: JSONObject = {
-            _type: 'InBetween',
-            startValue: 10,
-            endValue: 20,
-        };
-        expect(betweenObj.toJSON()).toEqual(expectedJSON);
-    });
+  it("should generate the correct JSON representation using toJSON method", () => {
+    const startValue: number = 10;
+    const endValue: number = 20;
+    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    const expectedJSON: JSONObject = {
+      _type: "InBetween",
+      startValue: 10,
+      endValue: 20,
+    };
+    expect(betweenObj.toJSON()).toEqual(expectedJSON);
+  });
 
-    it('should create an InBetween object from valid JSON input', () => {
-        const jsonInput: JSONObject = {
-            _type: 'InBetween',
-            startValue: 10,
-            endValue: 20,
-        };
-        const betweenObj: InBetween = InBetween.fromJSON(jsonInput);
-        expect(betweenObj.startValue).toBe(10);
-        expect(betweenObj.endValue).toBe(20);
-    });
+  it("should create an InBetween object from valid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InBetween",
+      startValue: 10,
+      endValue: 20,
+    };
+    const betweenObj: InBetween = InBetween.fromJSON(jsonInput);
+    expect(betweenObj.startValue).toBe(10);
+    expect(betweenObj.endValue).toBe(20);
+  });
 
-    it('should throw a BadDataException when using invalid JSON input', () => {
-        const jsonInput: JSONObject = {
-            _type: 'InvalidType',
-            startValue: 10,
-            endValue: 20,
-        };
-        expect(() => {
-            return InBetween.fromJSON(jsonInput);
-        }).toThrow(BadDataException);
-    });
+  it("should throw a BadDataException when using invalid JSON input", () => {
+    const jsonInput: JSONObject = {
+      _type: "InvalidType",
+      startValue: 10,
+      endValue: 20,
+    };
+    expect(() => {
+      return InBetween.fromJSON(jsonInput);
+    }).toThrow(BadDataException);
+  });
 
-    it('should return a string with start and end values matching', () => {
-        const startValue: number = 15;
-        const endValue: number = 15;
-        const betweenObj: InBetween = new InBetween(startValue, endValue);
-        expect(betweenObj.toString()).toBe('15');
-    });
+  it("should return a string with start and end values matching", () => {
+    const startValue: number = 15;
+    const endValue: number = 15;
+    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    expect(betweenObj.toString()).toBe("15");
+  });
 
-    it('should return a string with start and end values different', () => {
-        const startValue: number = 10;
-        const endValue: number = 20;
-        const betweenObj: InBetween = new InBetween(startValue, endValue);
-        expect(betweenObj.toString()).toBe('10 - 20');
-    });
+  it("should return a string with start and end values different", () => {
+    const startValue: number = 10;
+    const endValue: number = 20;
+    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    expect(betweenObj.toString()).toBe("10 - 20");
+  });
 
-    it('should return the start value as a string', () => {
-        const startValue: number = 10;
-        const endValue: number = 20;
-        const betweenObj: InBetween = new InBetween(startValue, endValue);
-        expect(betweenObj.toStartValueString()).toBe('10');
-    });
+  it("should return the start value as a string", () => {
+    const startValue: number = 10;
+    const endValue: number = 20;
+    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    expect(betweenObj.toStartValueString()).toBe("10");
+  });
 
-    it('should return the end value as a string', () => {
-        const startValue: number = 10;
-        const endValue: number = 20;
-        const betweenObj: InBetween = new InBetween(startValue, endValue);
-        expect(betweenObj.toEndValueString()).toBe('20');
-    });
+  it("should return the end value as a string", () => {
+    const startValue: number = 10;
+    const endValue: number = 20;
+    const betweenObj: InBetween = new InBetween(startValue, endValue);
+    expect(betweenObj.toEndValueString()).toBe("20");
+  });
 
-    it('should be a type of InBetween', () => {
-        const inBetweenObj: InBetween = new InBetween(10, 15);
-        expect(inBetweenObj).toBeInstanceOf(InBetween);
-    });
+  it("should be a type of InBetween", () => {
+    const inBetweenObj: InBetween = new InBetween(10, 15);
+    expect(inBetweenObj).toBeInstanceOf(InBetween);
+  });
 });

package/Tests/Types/Database/LimitMax.test.ts

@@ -1,20 +1,20 @@
-import LIMIT_MAX, { LIMIT_PER_PROJECT } from '../../../Types/Database/LimitMax';
+import LIMIT_MAX, { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 
-describe('LIMIT_MAX', () => {
-    test('it should be number', () => {
-        expect(typeof LIMIT_MAX).toBe('number');
-    });
+describe("LIMIT_MAX", () => {
+  test("it should be number", () => {
+    expect(typeof LIMIT_MAX).toBe("number");
+  });
 });
 
-describe('LIMIT_MAX', () => {
-    test('it be positive', () => {
-        expect(LIMIT_MAX).toBeGreaterThan(0);
-    });
+describe("LIMIT_MAX", () => {
+  test("it be positive", () => {
+    expect(LIMIT_MAX).toBeGreaterThan(0);
+  });
 });
 
-describe('LIMIT_PER_PROJECT', () => {
-    test('should be positive number', () => {
-        expect(typeof LIMIT_PER_PROJECT).toBe('number');
-        expect(LIMIT_PER_PROJECT).toBeGreaterThan(0);
-    });
+describe("LIMIT_PER_PROJECT", () => {
+  test("should be positive number", () => {
+    expect(typeof LIMIT_PER_PROJECT).toBe("number");
+    expect(LIMIT_PER_PROJECT).toBeGreaterThan(0);
+  });
 });

package/Tests/Types/Database/NotEqual.test.ts

@@ -1,19 +1,19 @@
-import NotEqual from '../../../Types/BaseDatabase/NotEqual';
-import { describe, expect, it } from '@jest/globals';
+import NotEqual from "../../../Types/BaseDatabase/NotEqual";
+import { describe, expect, it } from "@jest/globals";
 
-describe('NotEqual', () => {
-    describe('constructor', () => {
-        it('should set the value property', () => {
-            const value: string = 'test';
-            const notEqual: NotEqual = new NotEqual(value);
-            expect(notEqual.value).toBe(value);
-        });
+describe("NotEqual", () => {
+  describe("constructor", () => {
+    it("should set the value property", () => {
+      const value: string = "test";
+      const notEqual: NotEqual = new NotEqual(value);
+      expect(notEqual.value).toBe(value);
     });
-    describe('toString', () => {
-        it('should return the string value', () => {
-            const value: string = 'test';
-            const notEqual: NotEqual = new NotEqual(value);
-            expect(notEqual.toString()).toBe(value);
-        });
+  });
+  describe("toString", () => {
+    it("should return the string value", () => {
+      const value: string = "test";
+      const notEqual: NotEqual = new NotEqual(value);
+      expect(notEqual.toString()).toBe(value);
     });
+  });
 });

package/Tests/Types/Database/Search.test.ts

@@ -1,10 +1,10 @@
-import Search from '../../../Types/BaseDatabase/Search';
+import Search from "../../../Types/BaseDatabase/Search";
 
-describe('Search', () => {
-    test('new Search() should return a valid object', () => {
-        expect(new Search('Demo').toString()).toBe('Demo');
-    });
-    test('value should return a valid string', () => {
-        expect(new Search('Item1').value).toBe('Item1');
-    });
+describe("Search", () => {
+  test("new Search() should return a valid object", () => {
+    expect(new Search("Demo").toString()).toBe("Demo");
+  });
+  test("value should return a valid string", () => {
+    expect(new Search("Item1").value).toBe("Item1");
+  });
 });

package/Tests/Types/DatabaseType.test.ts

@@ -1,7 +1,7 @@
-import DatabaseType from '../../Types/DatabaseType';
+import DatabaseType from "../../Types/DatabaseType";
 
-describe('enum DatabaseType', () => {
-    test('DatabaseType.Postgres should be Postgres', () => {
-        expect(DatabaseType.Postgres).toEqual('postgres');
-    });
+describe("enum DatabaseType", () => {
+  test("DatabaseType.Postgres should be Postgres", () => {
+    expect(DatabaseType.Postgres).toEqual("postgres");
+  });
 });

package/Tests/Types/Date.test.ts

@@ -1,95 +1,89 @@
-import OneUptimeDate from '../../Types/Date';
-import PositiveNumber from '../../Types/PositiveNumber';
-import moment, { isMoment } from 'moment';
+import OneUptimeDate from "../../Types/Date";
+import PositiveNumber from "../../Types/PositiveNumber";
+import moment, { isMoment } from "moment";
 
-describe('class OneUptimeDate', () => {
-    test('OneUptimeDate.getCurrentDate should return current date', () => {
-        expect(OneUptimeDate.getCurrentDate().getFullYear()).toEqual(
-            new Date().getFullYear()
-        );
-        expect(OneUptimeDate.getCurrentDate().getDay()).toEqual(
-            new Date().getDay()
-        );
-        expect(OneUptimeDate.getCurrentDate().getDate()).toEqual(
-            new Date().getDate()
-        );
-        expect(OneUptimeDate.getCurrentDate().getHours()).toEqual(
-            new Date().getHours()
-        );
-        expect(isMoment(OneUptimeDate.getCurrentDate())).toBeFalsy();
-    });
-    test('OneUptimeDAte.getCurrentMomentDate() should return moment Date', () => {
-        expect(isMoment(OneUptimeDate.getCurrentMomentDate())).toBeTruthy();
-    });
-    test('OneUptimeDAte.getSomeMinutesAgo should return someMinutes ago Date from current time', () => {
-        expect(
-            OneUptimeDate.getSomeMinutesAgo(new PositiveNumber(4)).getMinutes()
-        ).toEqual(moment().add(-4, 'minutes').toDate().getMinutes());
-    });
-    test('OneUptimeDAte.getOneMinAgo should return one minute age Date from current time', () => {
-        expect(OneUptimeDate.getOneMinAgo().getMinutes()).toEqual(
-            moment().add(-1, 'minute').toDate().getMinutes()
-        );
-    });
-    test('OneUptimeDAte.getOneDayAgo should return oneDate ago Date', () => {
-        expect(OneUptimeDate.getOneDayAgo().getDay()).toEqual(
-            moment().add(-1, 'day').toDate().getDay()
-        );
-    });
-    test('OneUptimeDAte.getSomeHoursAgo should return moment Date', () => {
-        expect(
-            OneUptimeDate.getSomeHoursAgo(new PositiveNumber(4)).getHours()
-        ).toEqual(moment().add(-4, 'hours').toDate().getHours());
-    });
-    test('OneUptimeDAte.getSomeDaysAgo should return moment Date', () => {
-        expect(
-            OneUptimeDate.getSomeDaysAgo(new PositiveNumber(4)).getDay()
-        ).toEqual(moment().add(-4, 'days').toDate().getDay());
-    });
-    test('OneUptimeDAte.getSomeSecondsAgo should return moment Date', () => {
-        expect(
-            OneUptimeDate.getSomeSecondsAgo(new PositiveNumber(4)).getSeconds()
-        ).toEqual(moment().add(-4, 'seconds').toDate().getSeconds());
-    });
-    test('OneUptimeDAte.getOneMinAfter should return moment Date', () => {
-        expect(OneUptimeDate.getOneMinAfter().getMinutes()).toEqual(
-            moment().add(1, 'minute').toDate().getMinutes()
-        );
-    });
-    test('OneUptimeDAte.getOneDayAfter should return moment Date', () => {
-        expect(OneUptimeDate.getOneDayAfter().getDay()).toEqual(
-            moment().add(1, 'day').toDate().getDay()
-        );
-    });
-    test('OneUptimeDAte.getSomeMinutesAfter should return moment Date', () => {
-        expect(
-            OneUptimeDate.getSomeMinutesAfter(
-                new PositiveNumber(4)
-            ).getMinutes()
-        ).toEqual(moment().add(4, 'minutes').toDate().getMinutes());
-    });
-    test('OneUptimeDAte.getSomeHoursAfter should return moment Date', () => {
-        expect(
-            OneUptimeDate.getSomeHoursAfter(new PositiveNumber(4)).getHours()
-        ).toEqual(moment().add(4, 'hours').toDate().getHours());
-    });
-    test('OneUptimeDAte.getSomeDaysAfter should return moment Date', () => {
-        expect(
-            OneUptimeDate.getSomeDaysAfter(new PositiveNumber(4)).getDay()
-        ).toEqual(moment().add(4, 'days').toDate().getDay());
-    });
-    test('OneUptimeDAte.getSomeSecondsAfter should return moment Date', () => {
-        expect(
-            OneUptimeDate.getSomeSecondsAfter(
-                new PositiveNumber(4)
-            ).getSeconds()
-        ).toEqual(moment().add(4, 'seconds').toDate().getSeconds());
-    });
-    test('OneUptimeDAte.getCurrentYear should return the current year', () => {
-        expect(
-            OneUptimeDate.getSomeSecondsAfter(
-                new PositiveNumber(4)
-            ).getSeconds()
-        ).toEqual(moment().add(4, 'seconds').toDate().getSeconds());
-    });
+describe("class OneUptimeDate", () => {
+  test("OneUptimeDate.getCurrentDate should return current date", () => {
+    expect(OneUptimeDate.getCurrentDate().getFullYear()).toEqual(
+      new Date().getFullYear(),
+    );
+    expect(OneUptimeDate.getCurrentDate().getDay()).toEqual(
+      new Date().getDay(),
+    );
+    expect(OneUptimeDate.getCurrentDate().getDate()).toEqual(
+      new Date().getDate(),
+    );
+    expect(OneUptimeDate.getCurrentDate().getHours()).toEqual(
+      new Date().getHours(),
+    );
+    expect(isMoment(OneUptimeDate.getCurrentDate())).toBeFalsy();
+  });
+  test("OneUptimeDAte.getCurrentMomentDate() should return moment Date", () => {
+    expect(isMoment(OneUptimeDate.getCurrentMomentDate())).toBeTruthy();
+  });
+  test("OneUptimeDAte.getSomeMinutesAgo should return someMinutes ago Date from current time", () => {
+    expect(
+      OneUptimeDate.getSomeMinutesAgo(new PositiveNumber(4)).getMinutes(),
+    ).toEqual(moment().add(-4, "minutes").toDate().getMinutes());
+  });
+  test("OneUptimeDAte.getOneMinAgo should return one minute age Date from current time", () => {
+    expect(OneUptimeDate.getOneMinAgo().getMinutes()).toEqual(
+      moment().add(-1, "minute").toDate().getMinutes(),
+    );
+  });
+  test("OneUptimeDAte.getOneDayAgo should return oneDate ago Date", () => {
+    expect(OneUptimeDate.getOneDayAgo().getDay()).toEqual(
+      moment().add(-1, "day").toDate().getDay(),
+    );
+  });
+  test("OneUptimeDAte.getSomeHoursAgo should return moment Date", () => {
+    expect(
+      OneUptimeDate.getSomeHoursAgo(new PositiveNumber(4)).getHours(),
+    ).toEqual(moment().add(-4, "hours").toDate().getHours());
+  });
+  test("OneUptimeDAte.getSomeDaysAgo should return moment Date", () => {
+    expect(
+      OneUptimeDate.getSomeDaysAgo(new PositiveNumber(4)).getDay(),
+    ).toEqual(moment().add(-4, "days").toDate().getDay());
+  });
+  test("OneUptimeDAte.getSomeSecondsAgo should return moment Date", () => {
+    expect(
+      OneUptimeDate.getSomeSecondsAgo(new PositiveNumber(4)).getSeconds(),
+    ).toEqual(moment().add(-4, "seconds").toDate().getSeconds());
+  });
+  test("OneUptimeDAte.getOneMinAfter should return moment Date", () => {
+    expect(OneUptimeDate.getOneMinAfter().getMinutes()).toEqual(
+      moment().add(1, "minute").toDate().getMinutes(),
+    );
+  });
+  test("OneUptimeDAte.getOneDayAfter should return moment Date", () => {
+    expect(OneUptimeDate.getOneDayAfter().getDay()).toEqual(
+      moment().add(1, "day").toDate().getDay(),
+    );
+  });
+  test("OneUptimeDAte.getSomeMinutesAfter should return moment Date", () => {
+    expect(
+      OneUptimeDate.getSomeMinutesAfter(new PositiveNumber(4)).getMinutes(),
+    ).toEqual(moment().add(4, "minutes").toDate().getMinutes());
+  });
+  test("OneUptimeDAte.getSomeHoursAfter should return moment Date", () => {
+    expect(
+      OneUptimeDate.getSomeHoursAfter(new PositiveNumber(4)).getHours(),
+    ).toEqual(moment().add(4, "hours").toDate().getHours());
+  });
+  test("OneUptimeDAte.getSomeDaysAfter should return moment Date", () => {
+    expect(
+      OneUptimeDate.getSomeDaysAfter(new PositiveNumber(4)).getDay(),
+    ).toEqual(moment().add(4, "days").toDate().getDay());
+  });
+  test("OneUptimeDAte.getSomeSecondsAfter should return moment Date", () => {
+    expect(
+      OneUptimeDate.getSomeSecondsAfter(new PositiveNumber(4)).getSeconds(),
+    ).toEqual(moment().add(4, "seconds").toDate().getSeconds());
+  });
+  test("OneUptimeDAte.getCurrentYear should return the current year", () => {
+    expect(
+      OneUptimeDate.getSomeSecondsAfter(new PositiveNumber(4)).getSeconds(),
+    ).toEqual(moment().add(4, "seconds").toDate().getSeconds());
+  });
 });

package/Tests/Types/Dictionary.test.ts

@@ -1,26 +1,26 @@
-import Dictionary from '../../Types/Dictionary';
+import Dictionary from "../../Types/Dictionary";
 
-describe('Dictionary', () => {
-    test('should allow basic types   compile', () => {
-        const dictionary: Dictionary<string> = {
-            property: 'string',
-        };
-        const numberDictionary: Dictionary<number> = {
-            property: 1,
-        };
+describe("Dictionary", () => {
+  test("should allow basic types   compile", () => {
+    const dictionary: Dictionary<string> = {
+      property: "string",
+    };
+    const numberDictionary: Dictionary<number> = {
+      property: 1,
+    };
 
-        expect(dictionary['property']).toEqual('string');
-        expect(numberDictionary['property']).toEqual(1);
-    });
-    test('should allow the complex type', () => {
-        const nestedDictionary: Dictionary<{ nested: string }> = {
-            property: { nested: 'stringValue' },
-        };
-        const nestedArrayDictionary: Dictionary<{ nested: Array<string> }> = {
-            property: { nested: ['stringValue'] },
-        };
+    expect(dictionary["property"]).toEqual("string");
+    expect(numberDictionary["property"]).toEqual(1);
+  });
+  test("should allow the complex type", () => {
+    const nestedDictionary: Dictionary<{ nested: string }> = {
+      property: { nested: "stringValue" },
+    };
+    const nestedArrayDictionary: Dictionary<{ nested: Array<string> }> = {
+      property: { nested: ["stringValue"] },
+    };
 
-        expect(nestedDictionary['property']?.nested).toEqual('stringValue');
-        expect(nestedArrayDictionary['property']?.nested.length).toEqual(1);
-    });
+    expect(nestedDictionary["property"]?.nested).toEqual("stringValue");
+    expect(nestedArrayDictionary["property"]?.nested.length).toEqual(1);
+  });
 });