@oneuptime/common 1.0.0

package/Types/Day/DayOfWeek.ts

@@ -0,0 +1,32 @@
+enum DayOfWeek {
+    Sunday = 'Sunday',
+    Monday = 'Monday',
+    Tuesday = 'Tuesday',
+    Wednesday = 'Wednesday',
+    Thursday = 'Thursday',
+    Friday = 'Friday',
+    Saturday = 'Saturday',
+}
+
+export class DayOfWeekUtil {
+    public static getNumberOfDayOfWeek(dayOfWeek: DayOfWeek): number {
+        switch (dayOfWeek) {
+            case DayOfWeek.Sunday:
+                return 0;
+            case DayOfWeek.Monday:
+                return 1;
+            case DayOfWeek.Tuesday:
+                return 2;
+            case DayOfWeek.Wednesday:
+                return 3;
+            case DayOfWeek.Thursday:
+                return 4;
+            case DayOfWeek.Friday:
+                return 5;
+            case DayOfWeek.Saturday:
+                return 6;
+        }
+    }
+}
+
+export default DayOfWeek;

package/Types/Decimal.ts

@@ -0,0 +1,78 @@
+// This is for Object ID for all the things in our database.
+import { FindOperator } from 'typeorm';
+import DatabaseProperty from './Database/DatabaseProperty';
+import { JSONObject, ObjectType } from './JSON';
+import BadDataException from './Exception/BadDataException';
+
+export default class Decimal extends DatabaseProperty {
+    private _value: number = 0;
+    public get value(): number {
+        return this._value;
+    }
+    public set value(v: number) {
+        this._value = v;
+    }
+
+    public constructor(value: number | Decimal | string) {
+        super();
+
+        if (typeof value === 'string') {
+            value = parseFloat(value);
+        }
+
+        if (value instanceof Decimal) {
+            value = value.value;
+        }
+
+        this.value = value;
+    }
+
+    public equals(other: Decimal): boolean {
+        return this.value.toString() === other.value.toString();
+    }
+
+    public override toString(): string {
+        return this.value.toString();
+    }
+
+    protected static override toDatabase(
+        value: Decimal | FindOperator<Decimal>
+    ): string | null {
+        if (value) {
+            if (typeof value === 'string') {
+                value = new Decimal(value);
+            }
+
+            return value.toString();
+        }
+
+        return null;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.Decimal,
+            value: (this as Decimal).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): Decimal {
+        if (json['_type'] === ObjectType.Decimal) {
+            return new Decimal((json['value'] as number) || 0);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    protected static override fromDatabase(_value: number): Decimal | null {
+        if (_value) {
+            return new Decimal(_value);
+        }
+
+        return null;
+    }
+
+    public static fromString(value: string): Decimal {
+        return new Decimal(value);
+    }
+}

package/Types/Dictionary.ts

@@ -0,0 +1,3 @@
+export default interface Dictionary<T> {
+    [x: string]: T;
+}

package/Types/DiskSize.ts

@@ -0,0 +1,46 @@
+import BadDataException from './Exception/BadDataException';
+
+export default class DiskSize {
+    public static convertToDecimalPlaces(
+        value: number,
+        decimalPlaces: number = 2
+    ): number {
+        if (decimalPlaces < 0) {
+            throw new BadDataException(
+                'decimalPlaces must be greater than or equal to 0.'
+            );
+        }
+
+        if (typeof value === 'string') {
+            value = parseFloat(value);
+        }
+
+        if (decimalPlaces === 0) {
+            return Math.ceil(value);
+        }
+
+        value = value * Math.pow(10, decimalPlaces);
+
+        // convert to int.
+
+        value = Math.round(value);
+
+        // convert back to float.
+
+        value = value / Math.pow(10, decimalPlaces);
+
+        return value;
+    }
+
+    public static byteSizeToGB(byteSize: number): number {
+        return byteSize / 1024 / 1024 / 1024;
+    }
+
+    public static byteSizeToMB(byteSize: number): number {
+        return byteSize / 1024 / 1024;
+    }
+
+    public static byteSizeToKB(byteSize: number): number {
+        return byteSize / 1024;
+    }
+}

package/Types/Domain.ts

@@ -0,0 +1,94 @@
+import { FindOperator } from 'typeorm/find-options/FindOperator';
+import DatabaseProperty from './Database/DatabaseProperty';
+import BadDataException from './Exception/BadDataException';
+import { JSONObject, ObjectType } from './JSON';
+
+export default class Domain extends DatabaseProperty {
+    private _domain: string = '';
+    public get domain(): string {
+        return this._domain;
+    }
+    public set domain(v: string) {
+        const isValid: boolean = Domain.isValidDomain(v);
+        if (!isValid) {
+            throw new BadDataException('Domain is not in valid format.');
+        }
+        this._domain = v;
+    }
+
+    public static isValidDomain(domain: string): boolean {
+        if (!domain.includes('.')) {
+            return false;
+        }
+
+        const firstTLDs: Array<string> =
+            'ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|be|bf|bg|bh|bi|bj|bm|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|cl|cm|cn|co|cr|cu|cv|cw|cx|cz|de|dj|dk|dm|do|dz|ec|ee|eg|es|et|eu|fi|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|im|in|io|iq|ir|is|it|je|jo|jp|kg|ki|km|kn|kp|kr|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|na|nc|ne|nf|ng|nl|no|nr|nu|nz|om|pa|pe|pf|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|st|su|sv|sx|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|yt'.split(
+                '|'
+            );
+        const secondTLDs: Array<string> =
+            'ac|academy|accountant|accountants|actor|adult|ag|agency|ai|airforce|am|amsterdam|apartments|app|archi|army|art|asia|associates|at|attorney|au|auction|auto|autos|baby|band|bar|barcelona|bargains|basketball|bayern|be|beauty|beer|berlin|best|bet|bid|bike|bingo|bio|biz|biz.pl|black|blog|blue|boats|boston|boutique|broker|build|builders|business|buzz|bz|ca|cab|cafe|camera|camp|capital|car|cards|care|careers|cars|casa|cash|casino|catering|cc|center|ceo|ch|charity|chat|cheap|church|city|cl|claims|cleaning|clinic|clothing|cloud|club|cn|co|co.in|co.jp|co.kr|co.nz|co.uk|co.za|coach|codes|coffee|college|com|com.ag|com.au|com.br|com.bz|com.cn|com.co|com.es|com.ky|com.mx|com.pe|com.ph|com.pl|com.ru|com.tw|community|company|computer|condos|construction|consulting|contact|contractors|cooking|cool|country|coupons|courses|credit|creditcard|cricket|cruises|cymru|cz|dance|date|dating|de|deals|degree|delivery|democrat|dental|dentist|design|dev|diamonds|digital|direct|directory|discount|dk|doctor|dog|domains|download|earth|education|email|energy|engineer|engineering|enterprises|equipment|es|estate|eu|events|exchange|expert|exposed|express|fail|faith|family|fan|fans|farm|fashion|film|finance|financial|firm.in|fish|fishing|fit|fitness|flights|florist|fm|football|forsale|foundation|fr|fun|fund|furniture|futbol|fyi|gallery|games|garden|gay|gen.in|gg|gifts|gives|giving|glass|global|gmbh|gold|golf|graphics|gratis|green|gripe|group|gs|guide|guru|hair|haus|health|healthcare|hockey|holdings|holiday|homes|horse|hospital|host|house|idv.tw|immo|immobilien|in|inc|ind.in|industries|info|info.pl|ink|institute|insure|international|investments|io|irish|ist|istanbul|it|jetzt|jewelry|jobs|jp|kaufen|kids|kim|kitchen|kiwi|kr|ky|la|land|lat|law|lawyer|lease|legal|lgbt|life|lighting|limited|limo|live|llc|llp|loan|loans|london|love|ltd|ltda|luxury|maison|makeup|management|market|marketing|mba|me|me.uk|media|melbourne|memorial|men|menu|miami|mobi|moda|moe|money|monster|mortgage|motorcycles|movie|ms|music|mx|nagoya|name|navy|ne.kr|net|net.ag|net.au|net.br|net.bz|net.cn|net.co|net.in|net.ky|net.nz|net.pe|net.ph|net.pl|net.ru|network|news|ninja|nl|no|nom.co|nom.es|nom.pe|nrw|nyc|okinawa|one|onl|online|org|org.ag|org.au|org.cn|org.es|org.in|org.ky|org.nz|org.pe|org.ph|org.pl|org.ru|org.uk|organic|page|paris|partners|parts|party|pe|pet|ph|photography|photos|pictures|pink|pizza|pl|place|plumbing|plus|poker|porn|press|pro|productions|promo|properties|protection|pub|pw|quebec|quest|racing|re.kr|realestate|recipes|red|rehab|reise|reisen|rent|rentals|repair|report|republican|rest|restaurant|review|reviews|rich|rip|rocks|rodeo|rugby|run|ryukyu|sale|salon|sarl|school|schule|science|se|security|services|sex|sg|sh|shiksha|shoes|shop|shopping|show|singles|site|ski|skin|soccer|social|software|solar|solutions|space|storage|store|stream|studio|study|style|supplies|supply|support|surf|surgery|sydney|systems|tax|taxi|team|tech|technology|tel|tennis|theater|theatre|tickets|tienda|tips|tires|today|tokyo|tools|tours|town|toys|trade|trading|training|travel|tube|tv|tw|uk|university|uno|us|vacations|vc|vegas|ventures|vet|viajes|video|villas|vin|vip|vision|vodka|vote|voto|voyage|wales|watch|web|webcam|website|wedding|wiki|win|wine|work|works|world|ws|wtf|xxx|xyz|yachts|yoga|yokohama|zone|移动|dev|com|edu|gov|net|mil|org|nom|sch|sbs|caa|res|off|gob|int|tur|ip6|uri|urn|asn|act|nsw|qld|tas|vic|pro|biz|adm|adv|agr|arq|art|ato|bio|bmd|cim|cng|cnt|ecn|eco|emp|eng|esp|etc|eti|far|fnd|fot|fst|g12|ggf|imb|ind|inf|jor|jus|leg|lel|mat|med|mus|not|ntr|odo|ppg|psc|psi|qsl|rec|slg|srv|teo|tmp|trd|vet|zlg|web|ltd|sld|pol|fin|k12|lib|pri|aip|fie|eun|sci|prd|cci|pvt|mod|idv|rel|sex|gen|nic|abr|bas|cal|cam|emr|fvg|laz|lig|lom|mar|mol|pmn|pug|sar|sic|taa|tos|umb|vao|vda|ven|mie|北海道|和歌山|神奈川|鹿児島|ass|rep|tra|per|ngo|soc|grp|plc|its|air|and|bus|can|ddr|jfk|mad|nrw|nyc|ski|spy|tcm|ulm|usa|war|fhs|vgs|dep|eid|fet|fla|flå|gol|hof|hol|sel|vik|cri|iwi|ing|abo|fam|gok|gon|gop|gos|aid|atm|gsm|sos|elk|waw|est|aca|bar|cpa|jur|law|sec|plo|www|bir|cbg|jar|khv|msk|nov|nsk|ptz|rnd|spb|stv|tom|tsk|udm|vrn|cmw|kms|nkz|snz|pub|fhv|red|ens|nat|rns|rnu|bbs|tel|bel|kep|nhs|dni|fed|isa|nsn|gub|e12|tec|орг|обр|упр|alt|nis|jpn|mex|ath|iki|nid|gda|inc|za'.split(
+                '|'
+            );
+
+        const parts: Array<string> = domain.split('.');
+        const lastItem: string = parts[parts.length - 1] as string;
+        const beforeLastItem: string = parts[parts.length - 2] as string;
+
+        if (firstTLDs.includes(lastItem)) {
+            if (secondTLDs.includes(beforeLastItem)) {
+                return true;
+            }
+            return true;
+        } else if (secondTLDs.includes(lastItem)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public constructor(domain: string) {
+        super();
+        this.domain = domain;
+    }
+
+    public override toString(): string {
+        return this.domain;
+    }
+
+    protected static override toDatabase(
+        value: Domain | FindOperator<Domain>
+    ): string | null {
+        if (value) {
+            if (typeof value === 'string') {
+                value = new Domain(value);
+            }
+
+            return value.toString();
+        }
+
+        return null;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.Domain,
+            value: (this as Domain).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): Domain {
+        if (json['_type'] === ObjectType.Domain) {
+            return new Domain((json['value'] as string) || '');
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    protected static override fromDatabase(_value: string): Domain | null {
+        if (_value) {
+            return new Domain(_value);
+        }
+
+        return null;
+    }
+}

package/Types/Email/EmailBody.ts

@@ -0,0 +1,4 @@
+export default interface EmailBody {
+    subject: string;
+    body: string;
+}

package/Types/Email/EmailMessage.ts

@@ -0,0 +1,14 @@
+import Email from '../Email';
+import Dictionary from '../Dictionary';
+import EmailTemplateType from './EmailTemplateType';
+
+export interface EmailEnvelope {
+    subject: string;
+    templateType?: EmailTemplateType;
+    vars: Dictionary<string>;
+    body?: string;
+}
+
+export default interface EmailMessage extends EmailEnvelope {
+    toEmail: Email;
+}

package/Types/Email/EmailServer.ts

@@ -0,0 +1,15 @@
+import Email from '../Email';
+import Port from '../Port';
+import Hostname from '../API/Hostname';
+import ObjectID from '../ObjectID';
+
+export default interface EmailServer {
+    id?: ObjectID | undefined; // If this is custom SMTP, this is the ID of the SMTP config. Otherwise, it's undefined
+    host: Hostname;
+    port: Port;
+    username: string | undefined;
+    password: string | undefined;
+    secure: boolean;
+    fromEmail: Email;
+    fromName: string;
+}

package/Types/Email/EmailTemplate.ts

@@ -0,0 +1,8 @@
+import EmailBody from './EmailBody';
+import EmailTemplateType from './EmailTemplateType';
+
+export default interface EmailTemplate {
+    allowedVariables: Array<string>;
+    emailType: EmailTemplateType;
+    emailBody: EmailBody;
+}

package/Types/Email/EmailTemplateType.ts

@@ -0,0 +1,39 @@
+enum EmailTemplateType {
+    ForgotPassword = 'ForgotPassword.hbs',
+    SignupWelcomeEmail = 'SignupWelcomeEmail.hbs',
+    EmailVerified = 'EmailVerified.hbs',
+    PasswordChanged = 'PasswordChanged.hbs',
+    InviteMember = 'InviteMember.hbs',
+    EmailChanged = 'EmailChanged.hbs',
+    SubscribedToStatusPage = 'SubscribedToStatusPage.hbs',
+    SubscriberAnnouncementCreated = 'SubscriberAnnouncementCreated.hbs',
+    SubscriberIncidentCreated = 'SubscriberIncidentCreated.hbs',
+    SubscriberIncidentNoteCreated = 'SubscriberIncidentNoteCreated.hbs',
+    SubscriberIncidentStateChanged = 'SubscriberIncidentStateChanged.hbs',
+    SubscriberScheduledMaintenanceEventCreated = 'SubscriberScheduledMaintenanceEventCreated.hbs',
+    SubscriberScheduledMaintenanceEventStateChanged = 'SubscriberScheduledMaintenanceEventStateChanged.hbs',
+    StatusPageForgotPassword = 'StatusPageForgotPassword.hbs',
+    StatusPagePasswordChanged = 'StatusPagePasswordChanged.hbs',
+    StatusPageWelcomeEmail = 'StatusPageWelcomeEmail.hbs',
+    SubscriberScheduledMaintenanceEventNoteCreated = 'SubscriberScheduledMaintenanceEventNoteCreated.hbs',
+    SMTPTest = 'SMTPTest.hbs',
+    MonitorOwnerAdded = 'MonitorOwnerAdded.hbs',
+    MonitorOwnerResourceCreated = 'MonitorOwnerResourceCreated.hbs',
+    MonitorOwnerStatusChanged = 'MonitorOwnerStatusChanged.hbs',
+    IncidentOwnerAdded = 'IncidentOwnerAdded.hbs',
+    IncidentOwnerStateChanged = 'IncidentOwnerStateChanged.hbs',
+    IncidentOwnerNotePosted = 'IncidentOwnerNotePosted.hbs',
+    IncidentOwnerResourceCreated = 'IncidentOwnerResourceCreated.hbs',
+    ScheduledMaintenanceOwnerNotePosted = 'ScheduledMaintenanceOwnerNotePosted.hbs',
+    ScheduledMaintenanceOwnerAdded = 'ScheduledMaintenanceOwnerAdded.hbs',
+    ScheduledMaintenanceOwnerStateChanged = 'ScheduledMaintenanceOwnerStateChanged.hbs',
+    ScheduledMaintenanceOwnerResourceCreated = 'ScheduledMaintenanceOwnerResourceCreated.hbs',
+    StatusPageOwnerResourceCreated = 'StatusPageOwnerResourceCreated.hbs',
+    StatusPageOwnerAdded = 'StatusPageOwnerAdded.hbs',
+    StatusPageOwnerAnnouncementPosted = 'StatusPageOwnerAnnouncementPosted.hbs',
+    SimpleMessage = 'SimpleMessage.hbs',
+    VerificationCode = 'VerificationCode.hbs',
+    AcknowledgeIncident = 'AcknowledgeIncident.hbs',
+}
+
+export default EmailTemplateType;

package/Types/Email.ts

@@ -0,0 +1,121 @@
+import { FindOperator } from 'typeorm';
+import Hostname from './API/Hostname';
+import DatabaseProperty from './Database/DatabaseProperty';
+import BadDataException from './Exception/BadDataException';
+import { JSONObject, ObjectType } from './JSON';
+
+const nonBusinessEmailDomains: Array<string> = [
+    'gmail',
+    'yahoo',
+    'yahoomail',
+    'googlemail',
+    'ymail',
+    'icloud',
+    'aol',
+    'hotmail',
+    'outlook',
+    'msn',
+    'wanadoo',
+    'orange',
+    'comcast',
+    'facebook',
+    'hey.com',
+    'protonmail',
+    'inbox.com',
+    'mail.com',
+    'zoho',
+    'yandex',
+];
+
+export default class Email extends DatabaseProperty {
+    private _email: string = '';
+    public get email(): string {
+        return this._email;
+    }
+    public set email(value: string) {
+        if (value && typeof value === 'string') {
+            value = value.trim();
+            value = value.toLowerCase();
+        }
+
+        if (Email.isValid(value)) {
+            this._email = value;
+        } else {
+            throw new BadDataException(
+                `Email ${value} is not in valid format.`
+            );
+        }
+    }
+
+    public constructor(email: string) {
+        super();
+        this.email = email;
+    }
+
+    public static isValid(value: string): boolean {
+        const re: RegExp = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,10}$/i;
+        const isValid: boolean = re.test(value);
+        if (!isValid) {
+            return false;
+        }
+        return true;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.Email,
+            value: (this as Email).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): Email {
+        if (json['_type'] === ObjectType.Email) {
+            return new Email((json['value'] as string) || '');
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    public override toString(): string {
+        return this.email;
+    }
+
+    public getEmailDomain(): Hostname {
+        return new Hostname(this.email!.split('@')[1]!);
+    }
+
+    public isBusinessEmail(): boolean {
+        const domain: string = this.getEmailDomain().hostname || '';
+        if (domain) {
+            for (let i: number = 0; i < nonBusinessEmailDomains.length; i++) {
+                if (domain.includes(nonBusinessEmailDomains[i]!)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public static override toDatabase(
+        value: Email | FindOperator<Email>
+    ): string | null {
+        if (value) {
+            if (typeof value === 'string') {
+                value = new Email(value);
+            }
+
+            return value.toString();
+        }
+
+        return null;
+    }
+
+    public static override fromDatabase(_value: string): Email | null {
+        if (_value) {
+            return new Email(_value);
+        }
+
+        return null;
+    }
+}

package/Types/EmailWithName.ts

@@ -0,0 +1,35 @@
+import Email from './Email';
+import Typeof from './Typeof';
+
+export default class EmailWithName {
+    private _email: Email = new Email('noreply@oneuptime.com');
+    public get email(): Email {
+        return this._email;
+    }
+    public set email(v: Email | string) {
+        if (typeof v === Typeof.String) {
+            this._email = new Email(v.toString());
+        }
+
+        if (v instanceof Email) {
+            this._email = v;
+        }
+    }
+
+    private _name: string = '';
+    public get name(): string {
+        return this._name;
+    }
+    public set name(v: string) {
+        this._name = v;
+    }
+
+    public constructor(name: string, email: string | Email) {
+        this.email = email;
+        this.name = name;
+    }
+
+    public toString(): string {
+        return `"${this.name}" <${this.email}>`;
+    }
+}

package/Types/EncryptionAlgorithm.ts

@@ -0,0 +1,5 @@
+enum EncryptionAlgorithm {
+    SHA256 = 'SHA-256',
+}
+
+export default EncryptionAlgorithm;

package/Types/Events/EventInterval.ts

@@ -0,0 +1,9 @@
+enum EventInterval {
+    Hour = 'Hour',
+    Day = 'Day',
+    Week = 'Week',
+    Month = 'Month',
+    Year = 'Year',
+}
+
+export default EventInterval;

package/Types/Events/Recurring.ts

@@ -0,0 +1,119 @@
+import { FindOperator } from 'typeorm';
+import DatabaseProperty from '../Database/DatabaseProperty';
+import EventInterval from './EventInterval';
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import JSONFunctions from '../JSONFunctions';
+import PositiveNumber from '../PositiveNumber';
+
+export interface RecurringData extends JSONObject {
+    intervalType: EventInterval;
+    intervalCount: PositiveNumber;
+}
+
+export default class Recurring extends DatabaseProperty {
+    public static getDefaultRotationData(): RecurringData {
+        return {
+            intervalType: EventInterval.Day,
+            intervalCount: new PositiveNumber(1),
+        };
+    }
+
+    private data: RecurringData = Recurring.getDefaultRotationData();
+
+    public get intervalType(): EventInterval {
+        return this.data.intervalType;
+    }
+    public set intervalType(v: EventInterval) {
+        this.data.intervalType = v;
+    }
+
+    // intervalCount
+
+    public get intervalCount(): PositiveNumber {
+        return this.data.intervalCount;
+    }
+
+    public set intervalCount(v: PositiveNumber) {
+        this.data.intervalCount = v;
+    }
+
+    public constructor() {
+        super();
+
+        this.data = Recurring.getDefaultRotationData();
+    }
+
+    public static getDefault(): Recurring {
+        return new Recurring();
+    }
+
+    public override toJSON(): JSONObject {
+        return JSONFunctions.serialize({
+            _type: ObjectType.Recurring,
+            value: {
+                intervalType: this.intervalType,
+                intervalCount: this.intervalCount.toJSON(),
+            },
+        });
+    }
+
+    public static override fromJSON(json: JSONObject | Recurring): Recurring {
+        if (json instanceof Recurring) {
+            return json;
+        }
+
+        if (!json || json['_type'] !== ObjectType.Recurring) {
+            throw new BadDataException('Invalid Rotation');
+        }
+
+        if (!json['value']) {
+            throw new BadDataException('Invalid Rotation');
+        }
+
+        json = json['value'] as JSONObject;
+
+        let intervalType: EventInterval = EventInterval.Day;
+
+        if (json && json['intervalType']) {
+            intervalType = json['intervalType'] as EventInterval;
+        }
+
+        let intervalCount: PositiveNumber = new PositiveNumber(1);
+
+        if (json && json['intervalCount']) {
+            intervalCount = PositiveNumber.fromJSON(json['intervalCount']);
+        }
+
+        const rotation: Recurring = new Recurring();
+
+        rotation.data = {
+            intervalType,
+            intervalCount,
+        };
+
+        return rotation;
+    }
+
+    protected static override toDatabase(
+        value: Recurring | FindOperator<Recurring>
+    ): JSONObject | null {
+        if (value && value instanceof Recurring) {
+            return (value as Recurring).toJSON();
+        } else if (value) {
+            return JSONFunctions.serialize(value as any);
+        }
+
+        return null;
+    }
+
+    protected static override fromDatabase(
+        value: JSONObject
+    ): Recurring | null {
+        if (value) {
+            return Recurring.fromJSON(value);
+        }
+
+        return null;
+    }
+}

package/Types/Exception/ApiException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class APIException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.APIException, message);
+    }
+}

package/Types/Exception/BadDataException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class BadDataException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.BadDataException, message);
+    }
+}

package/Types/Exception/BadOperationException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class BadOperationException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.BadOperationException, message);
+    }
+}

package/Types/Exception/BadRequestException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class BadRequestException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.BadDataException, message);
+    }
+}