@atmosx/event-product-parser 2.0.16 → 3.0.1

package/src/@parsers/@events/api.ts

@@ -1,146 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as types from '../../types';
-import * as loader from '../../bootstrap';
-import EventParser from '../events';
-import TextParser from '../text';
-
-export class APIAlerts {
-    
-    /**
-     * @function getTracking
-     * @description
-     *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
-     *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
-     *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
-     *
-     * @private
-     * @static
-     * @param {Record<string, string>} extracted 
-     * @returns {string} 
-     */
-     private static getTracking(extracted: Record<string, string>): string {
-        if (extracted.pVtec) {
-            const vtecValue = Array.isArray(extracted.pVtec) 
-                ? extracted.pVtec[0] : extracted.pVtec;
-            const splitPVTEC = vtecValue.split('.');
-            return `${splitPVTEC[2]}-${splitPVTEC[3]}-${splitPVTEC[4]}-${splitPVTEC[5]}`;
-        }
-        const wmoMatch = extracted.wmoidentifier?.match(/([A-Z]{4}\d{2})\s+([A-Z]{4})/);
-        const station = wmoMatch?.[2] ?? 'N/A';
-        if (extracted.featureId) {
-            const idMatch = extracted.featureId.match(/([a-f0-9]+)\.(\d+)\.(\d+)$/);
-            return `${station}-${idMatch?.[1] ?? 'N/A'}`;
-        }
-        const id = wmoMatch?.[1] ?? 'N/A';
-        return `${station}-${id}`;
-     }
-
-    /**
-     * @function getICAO
-     * @description
-     *    Extracts the sender's ICAO code and corresponding name from a VTEC string.    
-     *
-     * @private
-     * @static
-     * @param {string} pVtec 
-     * @returns {{ icao: any; name: any; }} 
-     */
-    private static getICAO(pVtec: string): { icao: any; name: any; } {
-        const icao = pVtec ? pVtec.split(`.`)[2] : null;
-        const name = loader.definitions.ICAO?.[icao] ?? null;
-        return { icao, name };
-    }
-    
-    /**
-     * @function event
-     * @description
-     *   Processes validated API alert messages, extracting relevant information and compiling it into structured event objects.
-     *
-     * @public
-     * @static
-     * @async
-     * @param {types.StanzaCompiled} validated 
-     * @returns {*} 
-     */
-    public static async event(validated: types.StanzaCompiled): Promise<void> {
-        let processed = [] as unknown[];
-        const messages = Object.values(JSON.parse(validated.message).features) as types.EventCompiled[];
-        for (let feature of messages) {
-            const tick = performance.now();
-            const getPVTEC = feature?.properties?.parameters?.VTEC?.[0] ?? null;
-            const getWmo = feature?.properties?.parameters?.WMOidentifier?.[0] ?? null;
-            const getUgc = feature?.properties?.geocode?.UGC ?? null;
-            const getHeadline = feature?.properties?.parameters?.NWSheadline?.[0] ?? "";
-            const getDescription = `${getHeadline} ${feature?.properties?.description ?? ``}`
-            const getAWIP = feature?.properties?.parameters?.AWIPSidentifier?.[0] ?? null;
-            const getHeader = EventParser.getHeader({ ...{ getAwip: {prefix: getAWIP?.slice(0, -3) }},} as types.StanzaAttributes);
-            const getSource = TextParser.textProductToString(getDescription, `SOURCE...`, [`.`]) ?? null;
-            const getOffice = this.getICAO(getPVTEC ?? ``);
-            processed.push({
-                type: "Feature",
-                properties: {
-                    locations: feature?.properties?.areaDesc ?? null,
-                    event: feature?.properties?.event ?? null,
-                    issued: feature?.properties?.sent ? new Date(feature?.properties?.sent).toISOString() : null,
-                    expires: feature?.properties?.expires ? new Date(feature?.properties?.expires).toISOString() : null,
-                    parent: feature?.properties?.event ?? null,
-                    action_type: feature?.properties?.messageType ?? null,
-                    description: feature?.properties?.description ?? null,
-                    instruction: feature?.properties?.instruction ?? null,
-                    sender_name: getOffice.name ?? null,
-                    sender_icao: getOffice.icao ?? null,
-                    attributes: validated.attributes,
-                    geocode: {
-                        UGC: feature?.properties?.geocode?.UGC ?? [], 
-                        generated: feature?.geometry?.coordinates.length > 0 ? Buffer.from(JSON.stringify([feature?.geometry?.coordinates[0]])).toString('base64') : null,
-                    },
-                    raw: {},
-                    parameters: {
-                        wmo: feature?.properties?.parameters?.WMOidentifier?.[0] ?? getWmo ?? null,
-                        source: getSource,
-                        max_hail_size: feature?.properties?.parameters?.maxHailSize ?? null,
-                        max_wind_gust: feature?.properties?.parameters?.maxWindGust ?? null,
-                        damage_threat: feature?.properties?.parameters?.thunderstormDamageThreat?.[0] ?? null,
-                        tornado_detection: feature?.properties?.parameters?.tornadoDetection?.[0] ?? null,
-                        flood_detection: feature?.properties?.parameters?.floodDetection?.[0] ?? null,
-                        discussion_tornado_intensity: null, 
-                        discussion_wind_intensity: null,
-                        discussion_hail_intensity: null,
-                    },
-                    details: {
-                        performance: performance.now() - tick,
-                        source: `api-parser`,
-                        tracking: this.getTracking({ 
-                            pVtec: getPVTEC, 
-                            wmoidentifier: getWmo, 
-                            featureId: feature?.id, 
-                            ugc: getUgc ? getUgc.join(`,`) : null 
-                        }),
-                        header: getHeader,
-                        pvtec: getPVTEC ?? null,
-                        history: [{
-                            description: feature?.properties?.description ?? null,
-                            action: feature?.properties?.messageType ?? null,
-                            issued: feature?.properties?.sent ? new Date(feature?.properties?.sent).toISOString() : null
-                        }],
-                    },
-                },
-            })
-        }
-        EventParser.validateEvents(processed);
-    }
-}
-
-export default APIAlerts;

package/src/@parsers/@events/cap.ts

@@ -1,123 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as types from '../../types';
-import * as loader from '../../bootstrap';
-import EventParser from '../events';
-import TextParser from '../text';
-
-export class CapAlerts {
-    
-    /**
-     * @function getTracking
-     * @description
-     *   Generates a unique tracking identifier for a CAP alert based on extracted XML values.
-     *   If VTEC information is available, it constructs the tracking ID from the VTEC components.
-     *   Otherwise, it uses the WMO identifier along with TTAI and CCCC attributes.
-     *
-     * @private
-     * @static
-     * @param {Record<string, string>} extracted 
-     * @returns {string} 
-     */
-    private static getTracking(extracted: Record<string, string>, metadata: types.StanzaAttributes): string {
-        return extracted.vtec ? (() => {
-            const vtecValue = Array.isArray(extracted.vtec) ? extracted.vtec[0] : extracted.vtec;
-            const splitPVTEC = vtecValue.split('.');
-            return `${splitPVTEC[2]}-${splitPVTEC[3]}-${splitPVTEC[4]}-${splitPVTEC[5]}`;
-        })() : `${extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4)}-${metadata.attributes.ttaaii}-${metadata.attributes.id.slice(-4)}`;
-    }
-
-    /**
-     * @function event
-     * @description
-     *    Processes validated CAP alert messages, extracting relevant information and compiling it into structured event objects.   
-     *
-     * @public
-     * @static
-     * @async
-     * @param {types.StanzaCompiled} validated 
-     * @returns {*} 
-     */
-    public static async event(validated: types.StanzaCompiled): Promise<void> {
-      let processed = [] as unknown[];
-      const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
-      if (!messages || messages.length == 0) { return }
-      for (let i = 0; i < messages.length; i++) {
-          const tick = performance.now();
-          let message = messages[i]
-          const attributes = validated as types.StanzaAttributes;
-            message = message.substring(message.indexOf(`<?xml version="1.0"`), message.lastIndexOf(`>`) + 1);
-            const parser = new loader.packages.xml2js.Parser({ explicitArray: false, mergeAttrs: true, trim: true })
-            const parsed = await parser.parseStringPromise(message);
-            if (parsed == null || parsed.alert == null) continue;
-            const extracted = TextParser.getXmlValues(parsed, [
-                `vtec`, `wmoidentifier`, `ugc`, `areadesc`, 
-                `expires`, `sent`, `msgtype`, `description`,
-                `event`, `sendername`, `tornadodetection`, `polygon`,
-                `maxHailSize`, `maxWindGust`, `thunderstormdamagethreat`,
-                `tornadodamagethreat`, `waterspoutdetection`, `flooddetection`,
-            ]);
-            const getHeader = EventParser.getHeader({ ...validated.attributes,} as types.StanzaAttributes);
-            const getSource = TextParser.textProductToString(extracted.description, `SOURCE...`, [`.`]) ?? null;
-            processed.push({
-                type: "Feature",
-                properties: {
-                    locations: extracted.areadesc ?? null,
-                    event: extracted.event ?? null,
-                    issued: extracted.sent ? new Date(extracted.sent).toISOString() : null,
-                    expires: extracted.expires ? new Date(extracted.expires).toISOString() : null,
-                    parent: extracted.event ?? null,
-                    action_type: extracted.msgtype ?? null,
-                    description: extracted.description ?? null,
-                    instruction: null,
-                    sender_name: extracted.sendername ?? null,
-                    sender_icao: extracted.wmoidentifier ? extracted.wmoidentifier.substring(extracted.wmoidentifier.length - 4) : null,
-                    attributes: attributes,
-                    geocode: {
-                        UGC: extracted.ugc ? (Array.isArray(extracted.ugc) ? extracted.ugc : [extracted.ugc]) : [],
-                        generated: extracted?.polygon?.length > 0 ? Buffer.from(JSON.stringify([extracted.polygon.split(' ').map((coord: string) => {
-                            const [lat, lon] = coord.split(',').map(Number);
-                            return [lon, lat];
-                        })])).toString('base64') : null,
-                    },
-                    raw: {attributes},
-                    parameters: {
-                        wmo: extracted.wmoidentifier ?? null,
-                        source: getSource,
-                        max_hail_size: extracted.maxHailSize ?? null,
-                        max_wind_gust: extracted.maxWindGust ?? null,
-                        damage_threat: extracted.thunderstormdamagethreat ?? null,
-                        tornado_detection: extracted.tornadodetection ?? extracted.waterspoutdetection ?? null,
-                        flood_detection: extracted.flooddetection ?? null,
-                        discussion_tornado_intensity: null,
-                        discussion_wind_intensity: null,
-                        discussion_hail_intensity: null,
-                    },
-                    details: {
-                        performance: performance.now() - tick,
-                        source: `cap-parser`,
-                        tracking: this.getTracking(extracted, attributes),
-                        header: getHeader,
-                        pvtec: extracted.vtec ?? null,
-                        hvtec: null,
-                        history: [{ description: extracted.description ?? null, issued: extracted.sent ? new Date(extracted.sent).toISOString() : null, type: extracted.msgtype ?? null }],
-                    },
-                },
-            })
-        }
-        EventParser.validateEvents(processed);
-    }
-}
-
-export default CapAlerts;

package/src/@parsers/@events/text.ts

@@ -1,104 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as types from '../../types';
-import * as loader from '../../bootstrap';
-import EventParser from '../events';
-
-export class TextAlerts {
-
-    /**
-     * @function getTracking
-     * @description
-     *    Generates a unique tracking identifier for an event using the sender's ICAO
-     *    and some attributes.
-     *
-     * @private
-     * @static
-     * @param {types.EventProperties} properties 
-     * @returns {string} 
-     */
-    private static getTracking(properties: types.EventProperties): string {
-        return `${properties.sender_icao}-${properties.raw.attributes.ttaaii}-${properties?.raw?.attributes?.id.slice(-4) ?? 'N/A'}`;
-    }
-
-    /**
-     * @function getEvent
-     * @description
-     *     Determines the event name from a text message and its AWIPS attributes.
-     *     If the message contains a known offshore event keyword, that offshore
-     *     event is returned. Otherwise, the event type from the AWIPS attributes
-     *     is formatted into a human-readable string with each word capitalized.
-     *
-     * @private
-     * @static
-     * @param {string} message
-     * @param {types.StanzaAttributes} metadata
-     * @returns {string}
-     */
-    private static getEvent(message: string, metadata: types.StanzaAttributes): string {
-        const offshoreEvent = Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
-        if (offshoreEvent != undefined ) return Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
-        return metadata.awipsType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
-    }
-
-    /**
-     * @function event
-     * @description
-     *     Processes a compiled text-based NOAA Stanza message and extracts relevant
-     *     event information. Splits the message into multiple segments based on
-     *     markers such as "$$", "ISSUED TIME...", or separator lines, generates
-     *     base properties, headers, event names, and tracking information for
-     *     each segment, then validates and emits the processed events.
-     *
-     * @public
-     * @static
-     * @async
-     * @param {types.StanzaCompiled} validated
-     * @returns {Promise<void>}
-     */
-    public static async event(validated: types.StanzaCompiled): Promise<void> {
-        let processed = [] as unknown[];
-        const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
-        if (!messages || messages.length == 0) { return }
-        for (let i = 0; i < messages.length; i++) {
-            const tick = performance.now();
-            const message = messages[i]
-            const attributes = validated as types.StanzaAttributes;
-            const baseProperties = await EventParser.getBaseProperties(message, attributes) as types.EventProperties;
-            const getHeader = EventParser.getHeader({ ...validated.attributes, ...baseProperties.raw } as types.StanzaAttributes, baseProperties)
-            const getEvent = this.getEvent(message, attributes);
-            processed.push({
-                properties: { 
-                    event: getEvent, 
-                    parent: getEvent, 
-                    action_type: `Issued`, 
-                    ...baseProperties,
-                    details: {
-                        type: "Feature",
-                        performance: performance.now() - tick,
-                        source: `text-parser`,
-                        tracking: this.getTracking(baseProperties),
-                        header: getHeader,
-                        pvtec: null,
-                        hvtec: null,
-                        history: [{ description: baseProperties.description, issued: baseProperties.issued, type: `Issued` }],
-                    }, 
-                },
-            })
-        }
-        EventParser.validateEvents(processed);
-    }
-}
-
-export default TextAlerts;

package/src/@parsers/@events/ugc.ts

@@ -1,107 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as types from '../../types';
-import * as loader from '../../bootstrap';
-import UgcParser from '../ugc';
-import EventParser from '../events';
-
-export class UGCAlerts {
-
-    /**
-     * @function getTracking
-     * @description
-     *    Generates a unique tracking identifier for an event using the sender's ICAO
-     *    and some attributes.
-     *
-     * @private
-     * @static
-     * @param {types.EventProperties} properties 
-     * @returns {string} 
-     */
-    private static getTracking(properties: types.EventProperties): string {
-        return `${properties.sender_icao}-${properties.raw.attributes.ttaaii}-${properties?.raw?.attributes?.id.slice(-4) ?? 'N/A'}`;
-    }
-
-    /**
-     * @function getEvent
-     * @description
-     *     Determines the human-readable event name from a message and AWIPS attributes.
-     *     - Checks if the message contains any predefined offshore event keywords
-     *       and returns the matching offshore event if found.
-     *     - Otherwise, returns a formatted event type string from the provided attributes,
-     *       capitalizing the first letter of each word.
-     *
-     * @private
-     * @static
-     * @param {string} message
-     * @param {Record<string, any>} metadata
-     * @returns {string}
-     */
-    private static getEvent(message: string, metadata: types.StanzaAttributes): string {
-        const offshoreEvent = Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
-        if (offshoreEvent != undefined ) return Object.keys(loader.definitions.offshore).find(event => message.toLowerCase().includes(event.toLowerCase()));
-        return metadata.awipsType.type.split(`-`).map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(` `)
-    }
-
-    /**
-     * @function event
-     * @description
-     *     Processes a validated stanza message, extracting UGC entries and
-     *     computing base properties for non-VTEC events. Each extracted event
-     *     is enriched with metadata, performance timing, and history information,
-     *     then filtered and emitted via `EventParser.validateEvents`.
-     *
-     * @static
-     * @async
-     * @param {types.StanzaCompiled} validated
-     * @returns {Promise<void>}
-     */
-    public static async event(validated: types.StanzaCompiled): Promise<void> {
-        let processed = [] as unknown[];
-        const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
-        if (!messages || messages.length == 0) { return }
-        for (let i = 0; i < messages.length; i++) {
-            const tick = performance.now();
-            const message = messages[i]
-            const getUGC = await UgcParser.ugcExtractor(message) as types.UGCEntry
-            if (getUGC != null) {
-                const attributes = validated as types.StanzaAttributes;
-                const baseProperties = await EventParser.getBaseProperties(message, attributes, getUGC) as types.EventProperties;
-                const getHeader = EventParser.getHeader({ ...attributes, ...baseProperties.raw } as types.StanzaAttributes, baseProperties);
-                const getEvent = this.getEvent(message, attributes);
-                processed.push({
-                    type: "Feature",
-                    properties: { 
-                        event: getEvent, 
-                        parent: getEvent, 
-                        action_type: `Issued`, 
-                        ...baseProperties, 
-                        details: {
-                            performance: performance.now() - tick,
-                            source: `ugc-parser`,
-                            tracking: this.getTracking(baseProperties),
-                            header: getHeader,
-                            pvtec: null,
-                            hvtec: null,
-                            history: [{ description: baseProperties.description, issued: baseProperties.issued, type: `Issued` }],
-                        }  
-                    },
-                })
-            }
-        }
-        EventParser.validateEvents(processed);
-    }
-}
-
-export default UGCAlerts;

package/src/@parsers/@events/vtec.ts

@@ -1,76 +0,0 @@
-/*
-                                            _               _     __   __
-         /\  | |                           | |             (_)    \ \ / /
-        /  \ | |_ _ __ ___   ___  ___ _ __ | |__   ___ _ __ _  ___ \ V / 
-       / /\ \| __| "_ ` _ \ / _ \/ __| "_ \| "_ \ / _ \ "__| |/ __| > <  
-      / ____ \ |_| | | | | | (_) \__ \ |_) | | | |  __/ |  | | (__ / . \ 
-     /_/    \_\__|_| |_| |_|\___/|___/ .__/|_| |_|\___|_|  |_|\___/_/ \_\
-                                     | |                                 
-                                     |_|                                                                                                                
-    
-    Written by: KiyoWx (k3yomi)                
-*/
-
-import * as types from '../../types';
-import pVtecParser from '../pvtec';
-import hVtecParser from '../hvtec';
-import UgcParser from '../ugc';
-import EventParser from '../events';
-
-export class VTECAlerts {
-
-    /**
-     * @function event
-     * @description
-     *     Processes a validated stanza message, extracting VTEC and UGC entries,
-     *     computing base properties, generating headers, and preparing structured
-     *     event objects for downstream handling. Each extracted event is enriched
-     *     with metadata, performance timing, and history information.
-     *
-     * @static
-     * @async
-     * @param {types.StanzaCompiled} validated
-     * @returns {Promise<void>}
-     */
-    public static async event(validated: types.StanzaCompiled): Promise<void> {
-        let processed = [] as unknown[];
-        const messages = validated?.message?.split(/(?=\$\$)/g)?.map(msg => msg.trim())?.filter(msg => msg && msg !== "$$");
-        if (!messages || messages.length == 0) { return }
-        for (let i = 0; i < messages.length; i++) {
-            const tick = performance.now();
-            const message = messages[i]
-            const attributes = validated as types.StanzaAttributes;
-            const getPVTEC = await pVtecParser.pVtecExtractor(message) as types.PVtecEntry[]
-            const getHVTEC = await hVtecParser.HVtecExtractor(message) as types.HVtecEntry
-            const getUGC = await UgcParser.ugcExtractor(message) as types.UGCEntry
-            if (getPVTEC != null && getUGC != null) {
-                for (let j = 0; j < getPVTEC.length; j++) {
-                    const pVtec = getPVTEC[j];
-                    const baseProperties = await EventParser.getBaseProperties(message, attributes, getUGC, pVtec, getHVTEC) as types.EventProperties;
-                    const getHeader = EventParser.getHeader({ ...validated.attributes, ...baseProperties.raw } as types.StanzaAttributes, baseProperties, pVtec);
-                    processed.push({
-                        type: "Feature",
-                        properties: { 
-                            event: pVtec.event, 
-                            parent: pVtec.event, 
-                            action_type: pVtec.status, 
-                            ...baseProperties, 
-                            details: {
-                                performance: performance.now() - tick,
-                                source: `pvtec-parser`,
-                                tracking: pVtec.tracking,
-                                header: getHeader,
-                                pvtec: pVtec.raw,
-                                hvtec: getHVTEC != null ? getHVTEC.raw : null,
-                                history: [{ description: baseProperties.description, issued: baseProperties.issued, type: pVtec.status }],
-                            },
-                        },
-                    })
-                }
-            }
-        }
-        EventParser.validateEvents(processed);
-    }
-}
-
-export default VTECAlerts;