@atmosx/event-product-parser 3.0.61 → 3.0.63

package/src/@modules/@utilities/SetCronSchedule.ts

@@ -18,17 +18,17 @@
     
 */
 
-import { TypeSettings } from "../../@types/Settings";
-import { ReconnectXMPP } from "../@xmpp/ReconnectXMPP"
-import { bootstrap } from "../../bootstrap";
-import { CreateHttp } from "./CreateHttp";
-import { CreateEvent } from "../../@building/CreateEvent";
-import { SetEventEmit } from "./SetEventEmit";
-import { readdirSync, unlinkSync, statSync, existsSync } from "fs";
-import { join } from "path";
+import { TypeSettings } from "types/Settings"
+import { ReconnectXMPP } from "@xmpp/ReconnectXMPP"
+import { Bootstrap } from "@bootstrap"
+import { CreateHttp } from "@utilities/CreateHttp"
+import { SetEventEmit } from "@utilities/SetEventEmit"
+import { CreateEvent } from "@building/CreateEvent"
+import { readdirSync, unlinkSync, statSync, existsSync } from "fs"
+import { join } from "path"
 
 export const SetCronSchedule = async (): Promise<void> => {
-    const settings = bootstrap.settings as TypeSettings;
+    const settings = Bootstrap.Settings as TypeSettings;
 
     const TTL = settings.GlobalSettings.ArchiveSettings.TTL
     const TTLCUT = Date.now() - TTL * 1000;
@@ -62,15 +62,15 @@ export const SetCronSchedule = async (): Promise<void> => {
         }
     } else { 
         const response = await CreateHttp({
-            url: settings.NationalWeatherServiceSettings.EventsEndpoint,
-            headers: {
+            URL: settings.NationalWeatherServiceSettings.EventsEndpoint,
+            Headers: {
                 "User-Agent": "@atmosx/event-product-parser"
             }
         })
         if (response.error) {
             return SetEventEmit({
-                event: `onServiceStatus`,
-                metadata: {
+                Event: `onServiceStatus`,
+                Metadata: {
                     type: "fetch-api",
                     message: `Failed to fetch latest events from National Weather Service API - ${response.message}`,
                     data: {},
@@ -79,15 +79,15 @@ export const SetCronSchedule = async (): Promise<void> => {
             })
         }
         SetEventEmit({
-            event: `onServiceStatus`,
-            metadata: {
-                message: `Fetched latest events from National Weather Service API`,
-                data: {},
-                type: "fetch-api",
-                error: false
+            Event: `onServiceStatus`,
+            Metadata: {
+                Message: `Fetched latest events from National Weather Service API`,
+                Data: {},
+                Type: "fetch-api",
+                Error: false
             },
         })
-        await CreateEvent({ message: response.message, isNWWS: false })
+        await CreateEvent({ Message: response.message, NWWS: false })
     }
 }
 

package/src/@modules/@utilities/SetDebug.ts

@@ -17,21 +17,21 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings";
-import { bootstrap } from "../../bootstrap"
+import { TypeSettings } from "types/Settings"
+import { Bootstrap } from "@bootstrap"
 
 interface SetDebugOptions { 
-    title?: string
-    message: string
+    Title?: string
+    Message: string
 }
 
-export const SetDebug = (options: SetDebugOptions): void => {
-    const settings = bootstrap.settings as TypeSettings;
-    bootstrap.listener.emit(`debug`, {
-        message: options.message,
-        function: options.title ?? `debug`,
+export const SetDebug = ({ Title, Message }: SetDebugOptions): void => {
+    const settings = Bootstrap.Settings as TypeSettings;
+    Bootstrap.Listener.emit(`debug`, {
+        message: Message,
+        function: Title ?? `debug`,
     })
     if (settings.EnableDebugging) { 
-        console.log(`[${bootstrap.ansi_colors.BLUE}${options.title ?? `debug`}${bootstrap.ansi_colors.RESET}] ${options.message}`)
+        console.log(`[${Bootstrap.Colors.Blue}${Title ?? `debug`}${Bootstrap.Colors.Reset}] ${Message}`)
     }
 }

package/src/@modules/@utilities/SetEventEmit.ts

@@ -17,25 +17,25 @@
 
 */
 
-import { bootstrap } from "../../bootstrap"
-import { SetTimeoutAction } from "./SetTimeoutAction";
-import { SetWarning } from "./SetWarning";
+import { Bootstrap } from "@bootstrap"
+import { SetTimeoutAction } from "@utilities/SetTimeoutAction"
+import { SetWarning } from "@utilities/SetWarning"
 
 interface SetEventEmitOptions { 
-    event: string
-    metadata: any
-    message?: string
-    limited?: boolean
+    Event: string
+    Metadata: any
+    Message?: string
+    Limited?: boolean
 }
 
-export const SetEventEmit = (options: SetEventEmitOptions): void => {
-    if (options.limited) {
-        const isTimeout = SetTimeoutAction({ identifier: `event.${options.event}`, addTime: true, max: 1, interval: 1 })
-        if (isTimeout.limited) return;
+export const SetEventEmit = ({ Event, Metadata, Message, Limited }: SetEventEmitOptions): void => {
+    if (Limited) {
+        const isTimeout = SetTimeoutAction({ Identifier: `event.${Event}`, AddTime: true, Max: 1, Interval: 1 })
+        if (isTimeout.Limited) return;
     }
-    bootstrap.listener.emit(options.event, options.metadata)
-    if (options.event != `log`) { bootstrap.listener.emit(`*`, {event: options.event, data: options.metadata}) }
-    if (options.message) {
-        SetWarning({ message: options.message })
+    Bootstrap.Listener.emit(Event, Metadata)
+    if (Event != `log`) { Bootstrap.Listener.emit(`*`, {event: Event, data: Metadata}) }
+    if (Message) {
+        SetWarning({ Message: Message })
     }
 }

package/src/@modules/@utilities/SetListener.ts

@@ -17,14 +17,14 @@
 
 */
 
-import { bootstrap } from "../../bootstrap"
+import { Bootstrap } from "@bootstrap"
 
 interface SetListenerOptions { 
-    event: string,
-    callback: () => void
+    Event: string,
+    Callback: () => void
 }
 
-export const SetListener = (options: SetListenerOptions): (() => void) => {
-    bootstrap.listener.on(options.event, options.callback)
-    return () => { void bootstrap.listener.off(options.event, options.callback) };
+export const SetListener = ({ Event, Callback }: SetListenerOptions): (() => void) => {
+    Bootstrap.Listener.on(Event, Callback)
+    return () => { void Bootstrap.Listener.off(Event, Callback) };
 }

package/src/@modules/@utilities/SetSettings.ts

@@ -17,11 +17,11 @@
 
 */
 
-import { TypeSettings } from '../../@types/Settings'
-import { bootstrap } from "../../bootstrap"
+import { TypeSettings } from "types/Settings"
+import { Bootstrap } from "@bootstrap"
 
-export const SetSettings = (newSettings: TypeSettings): TypeSettings => {
-    const settings = bootstrap.settings as Record<string, unknown>;
+export const SetSettings = (imported: TypeSettings): TypeSettings => {
+    const settings = Bootstrap.Settings as Record<string, unknown>;
     const merge = (target: Record<string, unknown>, source: Record<string, unknown>) => {
         for (const key in source) {
             if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
@@ -37,6 +37,6 @@ export const SetSettings = (newSettings: TypeSettings): TypeSettings => {
             }
         }
     };
-    merge(settings, newSettings as Record<string, unknown>);
+    merge(settings, imported as Record<string, unknown>);
     return settings as TypeSettings;
 }

package/src/@modules/@utilities/SetSleep.ts

@@ -19,14 +19,14 @@
 */
 
 interface SetSleepOptions { 
-    timeout: number
+    Timeout: number
 }
 
-export const SetSleep = async (options: SetSleepOptions): Promise<void> => {
+export const SetSleep = async ({ Timeout }: SetSleepOptions): Promise<void> => {
     return new Promise((resolve) => {
         setTimeout(() => {
             resolve();
-        }, options.timeout);
+        }, Timeout);
     });
 }
 

package/src/@modules/@utilities/SetTimeoutAction.ts

@@ -17,48 +17,48 @@
 
 */
 
-import { bootstrap } from "../../bootstrap"
+import { Bootstrap } from "@bootstrap"
 
 interface SetTimeoutActionOptions {
-    identifier: string
-    addTime?: boolean
-    max?: number
-    interval?: number
-    expire?: boolean
+    Identifier: string
+    AddTime?: boolean
+    Max?: number
+    Interval?: number
+    Expire?: boolean
 }
 
 type SetTimeoutActionResponse = {
-    limited: boolean
-    remaining?: number
-    response?: string
+    Limited: boolean
+    Remaining?: number
+    Response?: string
 }
 
-export const SetTimeoutAction = (options: SetTimeoutActionOptions): SetTimeoutActionResponse =>  {
-    let target = bootstrap?.ratelimits?.[options?.identifier];
+export const SetTimeoutAction = ({ Identifier, AddTime, Max, Interval, Expire }: SetTimeoutActionOptions): SetTimeoutActionResponse =>  {
+    let target = Bootstrap?.Ratelimits?.[Identifier];
     if (!target) {
-        bootstrap.ratelimits[options?.identifier] = [];
-        target = bootstrap.ratelimits[options?.identifier];
+        Bootstrap.Ratelimits[Identifier] = [];
+        target = Bootstrap.Ratelimits[Identifier];
     }
-    if (options?.expire) {
-        delete bootstrap.ratelimits[options?.identifier];
-        return { limited: false };
+    if (Expire) {
+        delete Bootstrap.Ratelimits[Identifier];
+        return { Limited: false };
     }
     if (target?.length > 0) {
-       bootstrap.ratelimits[options?.identifier] = target.filter((ts: number) => Date.now() - ts < options?.interval * 1000);
-       target = bootstrap.ratelimits[options?.identifier];
+       Bootstrap.Ratelimits[Identifier] = target.filter((ts: number) => Date.now() - ts < Interval * 1000);
+       target = Bootstrap.Ratelimits[Identifier];
     }
 
     const oldestTimestamp = target?.[0];
-    const getWait = oldestTimestamp ? Math.ceil((options?.interval * 1000) - (Date.now() - oldestTimestamp)) : 0;
-    const max = options?.max ?? 1;
+    const getWait = oldestTimestamp ? Math.ceil((Interval * 1000) - (Date.now() - oldestTimestamp)) : 0;
+    const max = Max ?? 1;
     
     if (target?.length >= max && getWait > 0) {
         return {
-            limited: true,
-            remaining: getWait,
-            response: `You are being rate limited, please wait ${(getWait / 1e3).toFixed(1)} second(s) before performing this action again.`
+            Limited: true,
+            Remaining: getWait,
+            Response: `You are being rate limited, please wait ${(getWait / 1e3).toFixed(1)} second(s) before performing this action again.`
         }
     }
-    bootstrap.ratelimits[options?.identifier].push(Date.now());
-    return { limited: false };
+    Bootstrap.Ratelimits[Identifier].push(Date.now());
+    return { Limited: false };
 }

package/src/@modules/@utilities/SetWarning.ts

@@ -17,18 +17,18 @@
 
 */
 
-import { bootstrap } from "../../bootstrap"
-import { TypeSettings } from "../../@types/Settings";
+import { Bootstrap } from "@bootstrap"
+import { TypeSettings } from "types/Settings"
 
 interface SetWarningOptions { 
-    title?: string
-    message: string
+    Title?: string
+    Message: string
 }
 
-export const SetWarning = (options: SetWarningOptions): void => {
-    const settings = bootstrap.settings as TypeSettings;
-    bootstrap.listener.emit(`log`, `${options.title ?? `[${bootstrap.ansi_colors.YELLOW}@atmosx/product-parser${bootstrap.ansi_colors.RESET}]`} ${options.message}`)
+export const SetWarning = ({ Title, Message }: SetWarningOptions): void => {
+    const settings = Bootstrap.Settings as TypeSettings;
+    Bootstrap.Listener.emit(`log`, `${Title ?? `[${Bootstrap.Colors.Yellow}@atmosx/product-parser${Bootstrap.Colors.Reset}]`} ${Message}`)
     if (settings.EnableJournal) { 
-        console.log(`${options.title ?? `[${bootstrap.ansi_colors.YELLOW}@atmosx/product-parser${bootstrap.ansi_colors.RESET}]`} ${options.message}`)
+        console.log(`${Title ?? `[${Bootstrap.Colors.Yellow}@atmosx/product-parser${Bootstrap.Colors.Reset}]`} ${Message}`)
     }
 }

package/src/@modules/@xmpp/DeployXMPP.ts

@@ -17,21 +17,21 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings";
-import { bootstrap } from "../../bootstrap"
-import { OnlineXMPP } from "./OnlineXMPP";
-import { OfflineXMPP } from "./OfflineXMPP";
-import { ErrorXMPP } from "./ErrorXMPP";
-import { StanzaXMPP } from "./StanzaXMPP";
-import { SetEventEmit } from '../@utilities/SetEventEmit';
-import { client } from '@xmpp/client';
+import { TypeSettings } from "types/Settings"
+import { Bootstrap } from "@bootstrap"
+import { OnlineXMPP } from "@xmpp/OnlineXMPP"
+import { OfflineXMPP } from "@xmpp/OfflineXMPP"
+import { ErrorXMPP } from "@xmpp/ErrorXMPP"
+import { StanzaXMPP } from "@xmpp/StanzaXMPP"
+import { SetEventEmit } from "@utilities/SetEventEmit"
+import { client } from "@xmpp/client"
 
 export const DeployXMPP = async (): Promise<void> => {
     let session;
-    const settings = bootstrap.settings as TypeSettings
+    const settings = Bootstrap.Settings as TypeSettings
     settings.NOAAWeatherWireServiceSettings.CredentialSettings.Nickname 
         ??= settings.NOAAWeatherWireServiceSettings.CredentialSettings.Username;
-    session = bootstrap.session_xmpp = client({
+    session = Bootstrap.Session = client({
         service: 'xmpp://nwws-oi.weather.gov',
         domain: 'nwws-oi.weather.gov',
         username: settings.NOAAWeatherWireServiceSettings.CredentialSettings.Username,
@@ -45,12 +45,12 @@ export const DeployXMPP = async (): Promise<void> => {
         await session.start()
     } catch (error) {
         SetEventEmit({
-            event: `onServiceStatus`,
-            metadata: {
-                message: `Error occured while starting XMPP Session: ${error}`,
-                data: {},
-                type: `error`,
-                error: true 
+            Event: `onServiceStatus`,
+            Metadata: {
+                Message: `Error occured while starting XMPP Session: ${error}`,
+                Data: {},
+                Type: `error`,
+                Error: true 
             },
         })
     }

package/src/@modules/@xmpp/ErrorXMPP.ts

@@ -17,11 +17,11 @@
 
 */
 
-import { bootstrap } from "../../bootstrap";
+import { Bootstrap } from "@bootstrap"
 
 export const ErrorXMPP = () => {
-    bootstrap.session_xmpp.on(`error`, async (error: Error) => {
-        bootstrap.cache.isConnected = false;
-        bootstrap.cache.sigHault = true;
+    Bootstrap.Session.on(`error`, async () => {
+        Bootstrap.Cache.Connected = false;
+        Bootstrap.Cache.Hault = true;
     })
 }

package/src/@modules/@xmpp/OfflineXMPP.ts

@@ -17,20 +17,20 @@
 
 */
 
-import { bootstrap } from "../../bootstrap";
-import { SetEventEmit } from "../@utilities/SetEventEmit";
+import { Bootstrap } from "@bootstrap"
+import { SetEventEmit } from "@utilities/SetEventEmit"
 
 export const OfflineXMPP = () => {
-    bootstrap.session_xmpp.on(`offline`, async () => {
-        bootstrap.cache.isConnected = false;
-        bootstrap.cache.sigHault = true;
+    Bootstrap.Session.on(`offline`, async () => {
+        Bootstrap.Cache.Connected = false;
+        Bootstrap.Cache.Hault = true;
         SetEventEmit({
-            event: `onServiceStatus`,
-            metadata: {
-                message: `Client has gone offline`,
-                data: {},
-                type: `offline`,
-                error: true 
+            Event: `onServiceStatus`,
+            Metadata: {
+                Message: `Client has gone offline`,
+                Data: {},
+                Type: `offline`,
+                Error: true 
             },
         })
     })

package/src/@modules/@xmpp/OnlineXMPP.ts

@@ -17,30 +17,30 @@
 
 */
 
-import { bootstrap } from "../../bootstrap";
-import { SetEventEmit } from '../@utilities/SetEventEmit';
-import { xml } from '@xmpp/client'
+import { Bootstrap } from "@bootstrap"
+import { SetEventEmit } from "@utilities/SetEventEmit"
+import { xml } from "@xmpp/client"
 
 export const OnlineXMPP = () => {
-    const settings = bootstrap.settings;
-    bootstrap.session_xmpp.on(`online`, async (address: string) => {
-        bootstrap.cache.sigHault = false;
-        bootstrap.cache.isConnected = true;
-        bootstrap.cache.tReconnects = 0;
+    const settings = Bootstrap.Settings;
+    Bootstrap.Session.on(`online`, async () => {
+        Bootstrap.Cache.Hault = false;
+        Bootstrap.Cache.Connected = true;
+        Bootstrap.Cache.TotalReconnects = 0;
         const nickname = settings.NOAAWeatherWireServiceSettings.CredentialSettings.Nickname;
-        bootstrap.session_xmpp.send(xml('presence', {
+        Bootstrap.Session.send(xml('presence', {
             to: `nwws@conference.nwws-oi.weather.gov/${nickname}`,
             xmlns: 'http://jabber.org/protocol/muc',
         }))
         SetEventEmit({
-            event: `onServiceStatus`,
-            metadata: {
-                message: `Succesfully connected to NOAA Weather Wire Service as "${nickname}"`,
-                data: {},
-                type: `online`,
-                error: false
+            Event: `onServiceStatus`,
+            Metadata: {
+                Message: `Succesfully connected to NOAA Weather Wire Service as "${nickname}"`,
+                Data: {},
+                Type: `online`,
+                Error: false
             },
-            message: `Succesfully connected to NOAA Weather Wire Service as "${nickname}"`,
+            Message: `Succesfully connected to NOAA Weather Wire Service as "${nickname}"`,
         })
     })
 }

package/src/@modules/@xmpp/ReconnectXMPP.ts

@@ -17,47 +17,47 @@
 
 */
 
-import { TypeSettings } from "../../@types/Settings";
-import { bootstrap } from "../../bootstrap"
-import { SetEventEmit } from "../@utilities/SetEventEmit";
-import { SetWarning } from "../@utilities/SetWarning";
+import { TypeSettings } from "types/Settings"
+import { Bootstrap } from "@bootstrap"
+import { SetEventEmit } from "@utilities/SetEventEmit"
+import { SetWarning } from "@utilities/SetWarning"
 
 export const ReconnectXMPP = async (interval: number): Promise<void> => {
-    const settings = bootstrap.settings as TypeSettings;
-    const lastStanza = Date.now() - bootstrap.cache.lastStanza
+    const settings = Bootstrap.Settings as TypeSettings;
+    const last = Date.now() - Bootstrap.Cache.LastStanzaTime
     if (interval < 15) { 
-        SetWarning({ message: `Reconnection interval of ${interval} seconds is too low, setting to 15 seconds` })
+        SetWarning({ Message: `Reconnection interval of ${interval} seconds is too low, setting to 15 seconds` })
         interval = 15;
-        bootstrap.settings.NOAAWeatherWireServiceSettings.ReconnectionSettings.ReconnectionInterval = 15;
+        Bootstrap.Settings.NOAAWeatherWireServiceSettings.ReconnectionSettings.ReconnectionInterval = 15;
     }
     const reconnectThreshold = interval * 1e3
-    if ((!bootstrap.cache.isConnected && !bootstrap.cache.sigHault) || !bootstrap.session_xmpp) { 
+    if ((!Bootstrap.Cache.Connected && !Bootstrap.Cache.Hault) || !Bootstrap.Session) { 
         return; 
     }
-    if (lastStanza > reconnectThreshold) {
-        if (!bootstrap.cache.isReconnecting) {
-            bootstrap.cache.isReconnecting = true;
-            bootstrap.cache.isConnected = false;
-            bootstrap.cache.tReconnects += 1;
+    if (last > reconnectThreshold) {
+        if (!Bootstrap.Cache.Reconnecting) {
+            Bootstrap.Cache.Reconnecting = true;
+            Bootstrap.Cache.Connected = false;
+            Bootstrap.Cache.TotalReconnects += 1;
             try { 
                 SetEventEmit({
-                    event: `onServiceStatus`,
-                    metadata: {
-                        message: `Attempting to reconnect to XMPP Service (Reconnect Attempt ${bootstrap.cache.tReconnects})`,
-                        data: {
-                            last_stanza: lastStanza,
-                            nickname: settings.NOAAWeatherWireServiceSettings.CredentialSettings.Nickname
+                    Event: `onServiceStatus`,
+                    Metadata: {
+                        Message: `Attempting to reconnect to XMPP Service (Reconnect Attempt ${Bootstrap.Cache.TotalReconnects})`,
+                        Data: {
+                            Last: last,
+                            Nickname: settings.NOAAWeatherWireServiceSettings.CredentialSettings.Nickname
                         },
-                        type: `reconnect`,
-                        error: true
-                    }, message: `Attempting to reconnect to XMPP Service (Reconnect Attempt ${bootstrap.cache.tReconnects})`,
+                        Type: `reconnect`,
+                        Error: true
+                    }, Message: `Attempting to reconnect to XMPP Service (Reconnect Attempt ${Bootstrap.Cache.TotalReconnects})`,
                 })
-                await bootstrap.session_xmpp.stop().catch(() => {});
-                await bootstrap.session_xmpp.start().catch(() => {});
+                await Bootstrap.Session.stop().catch(() => {});
+                await Bootstrap.Session.start().catch(() => {});
             } catch (error) {
-                SetWarning({ message: `XMPP Reconnect Failed - ${(error as Error).message}` })
+                SetWarning({ Message: `XMPP Reconnect Failed - ${(error as Error).message}` })
             } finally { 
-                bootstrap.cache.isReconnecting = false;
+                Bootstrap.Cache.Reconnecting = false;
             }
         }
     }

package/src/@modules/@xmpp/StanzaXMPP.ts

@@ -17,31 +17,31 @@
 
 */
 
-import { TypeStanza } from "../../@types/Stanza";
-import { bootstrap } from "../../bootstrap";
-import { ValidateStanza } from "../@stanza/ValidateStanza";
-import { CreateEvent } from "../../@building/CreateEvent";
-import { ImportStanza } from "../@database/ImportStanza";
-import { SetEventEmit } from "../@utilities/SetEventEmit";
+import { TypeStanza } from "types-lower/Stanza"
+import { Bootstrap } from "@bootstrap"
+import { ValidateStanza } from "@stanza/ValidateStanza"
+import { CreateEvent } from "@building/CreateEvent"
+import { ImportStanza } from "@database/ImportStanza"
+import { SetEventEmit } from "@utilities/SetEventEmit"
 
 export const StanzaXMPP = () => {
-    bootstrap.session_xmpp.on(`stanza`, async (stanza: TypeStanza) => {
+    Bootstrap.Session.on(`stanza`, async (stanza: TypeStanza) => {
         const msgFrom = stanza?.attrs?.from ?? ``
         const msgType = stanza?.attrs?.type ?? ``
         SetEventEmit({
-            event: `onServiceStatus`,
-            metadata: {
-                message: stanza,
-                from: msgFrom,
-                type: `stanza`
+            Event: `onServiceStatus`,
+            Metadata: {
+                Message: stanza,
+                From: msgFrom,
+                Type: `stanza`
             },
         })
-        bootstrap.cache.lastStanza = Date.now();
+        Bootstrap.Cache.LastStanzaTime = Date.now();
         if (stanza.is(`message`)) {
-            const result = ValidateStanza({ stanza });
-            const isSkippable = result.isIgnored ||
-                (result.isCapEvent) ||
-                (result.isCapEvent && !result.isCapAreaDescription)
+            const result = ValidateStanza({ Stanza: stanza });
+            const isSkippable = result.Ignored ||
+                (result.CapEvent) ||
+                (result.CapEvent && !result.CapAreaDescription)
             if (isSkippable) { return; }
             await CreateEvent(result);
             await ImportStanza(result);
@@ -50,12 +50,12 @@ export const StanzaXMPP = () => {
             const getOccupant = msgFrom.split(`/`).slice(1).join(`/`)
             const getAvailability = msgType === `unavailable`
             SetEventEmit({
-                event: `onServiceStatus`,
-                metadata: {
-                    message: `Occupant ${getOccupant} has ${getAvailability ? `left` : `joined`} the room`,
-                    data: {},
-                    type: `occupant`,
-                    error: false 
+                Event: `onServiceStatus`,
+                Metadata: {
+                    Message: `Occupant ${getOccupant} has ${getAvailability ? `left` : `joined`} the room`,
+                    Data: {},
+                    Type: `occupant`,
+                    Error: false 
                 },
             })
         }

package/src/@parsers/@hvtec/HVExtract.ts

@@ -17,11 +17,11 @@
 
 */
 
-import { TypeHVTEC } from "../../@types/HVTEC";
-import { EnumCauses } from "../../@enums/Causes";
-import { EnumRecords } from "../../@enums/Records";
-import { EnumExpressions } from "../../@enums/Expressions";
-import { EnumSeverity } from "../../@enums/Severity";
+import { TypeHVTEC } from "types/HVTEC"
+import { EnumCauses } from "@enums/Causes"
+import { EnumRecords } from "@enums/Records"
+import { EnumExpressions } from "@enums/Expressions"
+import { EnumSeverity } from "@enums/Severity"
 
 export const HVExtract = (message: string): TypeHVTEC[] | null => {
     const getHVTECs = message.match(EnumExpressions.hvtec) ?? [];
@@ -30,10 +30,10 @@ export const HVExtract = (message: string): TypeHVTEC[] | null => {
         const sub = vtec.split(`.`);
         if (sub.length < 7) continue;
         vtecs.push({
-            hvtec: vtec,
-            severity: EnumSeverity[sub[1]],
-            cause: EnumCauses[sub[2]],
-            record: EnumRecords[sub[6]]
+            HVTEC: vtec,
+            Severity: EnumSeverity[sub[1]],
+            Cause: EnumCauses[sub[2]],
+            Record: EnumRecords[sub[6]]
         })
     }
     return vtecs.length > 0 ? vtecs : null;