eventmodeler 0.1.0

package/dist/slices/export-eventmodel-to-json/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function exportEventmodelToJson(model: EventModel): void;

package/dist/slices/export-eventmodel-to-json/index.js

@@ -0,0 +1,296 @@
+function mapFieldType(fieldType) {
+    // Map our field types to spec field types
+    const typeMap = {
+        'UUID': 'UUID',
+        'Boolean': 'Boolean',
+        'Double': 'Double',
+        'Decimal': 'Decimal',
+        'Date': 'Date',
+        'DateTime': 'DateTime',
+        'Long': 'Long',
+        'Int': 'Int',
+        'String': 'String',
+        'Custom': 'Custom',
+    };
+    return typeMap[fieldType] || 'String';
+}
+function mapStatus(status) {
+    const statusMap = {
+        'created': 'Created',
+        'done': 'Done',
+        'in-progress': 'InProgress',
+        'blocked': 'InProgress', // No blocked in spec, map to InProgress
+    };
+    return statusMap[status];
+}
+function convertField(field) {
+    const specField = {
+        name: field.name,
+        type: mapFieldType(field.fieldType),
+    };
+    if (field.isOptional)
+        specField.optional = true;
+    if (field.isGenerated)
+        specField.generated = true;
+    if (field.subfields && field.subfields.length > 0) {
+        specField.subfields = field.subfields.map(convertField);
+    }
+    return specField;
+}
+function isInSlice(slice, pos, width, height) {
+    const centerX = pos.x + width / 2;
+    const centerY = pos.y + height / 2;
+    return (centerX >= slice.position.x &&
+        centerX <= slice.position.x + slice.size.width &&
+        centerY >= slice.position.y &&
+        centerY <= slice.position.y + slice.size.height);
+}
+function getInboundDependencies(model, entityId, entityType) {
+    const deps = [];
+    for (const flow of model.flows.values()) {
+        if (flow.targetId === entityId) {
+            let sourceTitle = '';
+            let sourceType = 'COMMAND';
+            const cmd = model.commands.get(flow.sourceId);
+            const evt = model.events.get(flow.sourceId);
+            const rm = model.readModels.get(flow.sourceId);
+            const scr = model.screens.get(flow.sourceId);
+            const proc = model.processors.get(flow.sourceId);
+            if (cmd) {
+                sourceTitle = cmd.name;
+                sourceType = 'COMMAND';
+            }
+            else if (evt) {
+                sourceTitle = evt.name;
+                sourceType = 'EVENT';
+            }
+            else if (rm) {
+                sourceTitle = rm.name;
+                sourceType = 'READMODEL';
+            }
+            else if (scr) {
+                sourceTitle = scr.name;
+                sourceType = 'SCREEN';
+            }
+            else if (proc) {
+                sourceTitle = proc.name;
+                sourceType = 'AUTOMATION';
+            }
+            if (sourceTitle) {
+                deps.push({
+                    id: flow.id,
+                    title: sourceTitle,
+                    type: 'INBOUND',
+                    elementType: sourceType,
+                });
+            }
+        }
+    }
+    return deps;
+}
+function getOutboundDependencies(model, entityId, entityType) {
+    const deps = [];
+    for (const flow of model.flows.values()) {
+        if (flow.sourceId === entityId) {
+            let targetTitle = '';
+            let targetType = 'EVENT';
+            const cmd = model.commands.get(flow.targetId);
+            const evt = model.events.get(flow.targetId);
+            const rm = model.readModels.get(flow.targetId);
+            const scr = model.screens.get(flow.targetId);
+            const proc = model.processors.get(flow.targetId);
+            if (cmd) {
+                targetTitle = cmd.name;
+                targetType = 'COMMAND';
+            }
+            else if (evt) {
+                targetTitle = evt.name;
+                targetType = 'EVENT';
+            }
+            else if (rm) {
+                targetTitle = rm.name;
+                targetType = 'READMODEL';
+            }
+            else if (scr) {
+                targetTitle = scr.name;
+                targetType = 'SCREEN';
+            }
+            else if (proc) {
+                targetTitle = proc.name;
+                targetType = 'AUTOMATION';
+            }
+            if (targetTitle) {
+                deps.push({
+                    id: flow.id,
+                    title: targetTitle,
+                    type: 'OUTBOUND',
+                    elementType: targetType,
+                });
+            }
+        }
+    }
+    return deps;
+}
+function determineSliceType(commands, events, processors) {
+    // If there are processors, it's an automation slice
+    if (processors.length > 0)
+        return 'AUTOMATION';
+    // If there are commands and events, it's a state change
+    if (commands.length > 0 && events.length > 0)
+        return 'STATE_CHANGE';
+    // Otherwise it's a state view (read-only)
+    return 'STATE_VIEW';
+}
+export function exportEventmodelToJson(model) {
+    const specSlices = [];
+    // Sort slices by position
+    const sortedSlices = [...model.slices.values()].sort((a, b) => a.position.x - b.position.x);
+    for (const slice of sortedSlices) {
+        // Find components in this slice
+        const commands = [];
+        const events = [];
+        const readModels = [];
+        const screens = [];
+        const processors = [];
+        for (const cmd of model.commands.values()) {
+            if (isInSlice(slice, cmd.position, cmd.width, cmd.height)) {
+                commands.push(cmd);
+            }
+        }
+        for (const evt of model.events.values()) {
+            if (isInSlice(slice, evt.position, evt.width, evt.height)) {
+                events.push(evt);
+            }
+        }
+        for (const rm of model.readModels.values()) {
+            if (isInSlice(slice, rm.position, rm.width, rm.height)) {
+                readModels.push(rm);
+            }
+        }
+        for (const scr of model.screens.values()) {
+            if (isInSlice(slice, scr.position, scr.width, scr.height)) {
+                screens.push(scr);
+            }
+        }
+        for (const proc of model.processors.values()) {
+            if (isInSlice(slice, proc.position, proc.width, proc.height)) {
+                processors.push(proc);
+            }
+        }
+        // Find scenarios for this slice
+        const scenarios = [...model.scenarios.values()].filter(s => s.sliceId === slice.id);
+        // Convert to spec format
+        const specSlice = {
+            id: slice.id,
+            title: slice.name,
+            sliceType: determineSliceType(commands, events, processors),
+            status: mapStatus(slice.status),
+            commands: commands.map(cmd => ({
+                id: cmd.id,
+                title: cmd.name,
+                type: 'COMMAND',
+                fields: cmd.fields.map(convertField),
+                dependencies: [
+                    ...getInboundDependencies(model, cmd.id, 'COMMAND'),
+                    ...getOutboundDependencies(model, cmd.id, 'COMMAND'),
+                ],
+            })),
+            events: events.map(evt => ({
+                id: evt.id,
+                title: evt.name,
+                type: 'EVENT',
+                fields: evt.fields.map(convertField),
+                dependencies: [
+                    ...getInboundDependencies(model, evt.id, 'EVENT'),
+                    ...getOutboundDependencies(model, evt.id, 'EVENT'),
+                ],
+            })),
+            readmodels: readModels.map(rm => ({
+                id: rm.id,
+                title: rm.name,
+                type: 'READMODEL',
+                fields: rm.fields.map(convertField),
+                dependencies: [
+                    ...getInboundDependencies(model, rm.id, 'READMODEL'),
+                    ...getOutboundDependencies(model, rm.id, 'READMODEL'),
+                ],
+            })),
+            screens: screens.map(scr => ({
+                id: scr.id,
+                title: scr.name,
+                type: 'SCREEN',
+                fields: scr.fields.map(convertField),
+                dependencies: [
+                    ...getInboundDependencies(model, scr.id, 'SCREEN'),
+                    ...getOutboundDependencies(model, scr.id, 'SCREEN'),
+                ],
+            })),
+            processors: processors.map(proc => ({
+                id: proc.id,
+                title: proc.name,
+                type: 'AUTOMATION',
+                fields: proc.fields.map(convertField),
+                dependencies: [
+                    ...getInboundDependencies(model, proc.id, 'AUTOMATION'),
+                    ...getOutboundDependencies(model, proc.id, 'AUTOMATION'),
+                ],
+            })),
+            tables: [],
+            specifications: scenarios.map(scenario => {
+                const givenSteps = scenario.givenEvents.map(given => {
+                    const evt = model.events.get(given.eventStickyId);
+                    return {
+                        id: given.eventStickyId,
+                        title: evt?.name ?? 'Unknown',
+                        elementType: 'EVENT',
+                        fields: given.fieldValues,
+                    };
+                });
+                const whenSteps = [];
+                if (scenario.whenCommand) {
+                    const cmd = model.commands.get(scenario.whenCommand.commandStickyId);
+                    whenSteps.push({
+                        id: scenario.whenCommand.commandStickyId,
+                        title: cmd?.name ?? 'Unknown',
+                        elementType: 'COMMAND',
+                        fields: scenario.whenCommand.fieldValues,
+                    });
+                }
+                const thenSteps = [];
+                if (scenario.then.type === 'events' && scenario.then.expectedEvents) {
+                    for (const expected of scenario.then.expectedEvents) {
+                        const evt = model.events.get(expected.eventStickyId);
+                        thenSteps.push({
+                            id: expected.eventStickyId,
+                            title: evt?.name ?? 'Unknown',
+                            elementType: 'EVENT',
+                            fields: expected.fieldValues,
+                        });
+                    }
+                }
+                else if (scenario.then.type === 'readModelAssertion' && scenario.then.readModelAssertion) {
+                    const rm = model.readModels.get(scenario.then.readModelAssertion.readModelStickyId);
+                    thenSteps.push({
+                        id: scenario.then.readModelAssertion.readModelStickyId,
+                        title: rm?.name ?? 'Unknown',
+                        elementType: 'READMODEL',
+                        fields: scenario.then.readModelAssertion.expectedFieldValues,
+                    });
+                }
+                return {
+                    id: scenario.id,
+                    title: scenario.name,
+                    linkedId: slice.id,
+                    given: givenSteps,
+                    when: whenSteps,
+                    then: thenSteps,
+                };
+            }),
+        };
+        specSlices.push(specSlice);
+    }
+    const exportData = {
+        slices: specSlices,
+    };
+    console.log(JSON.stringify(exportData, null, 2));
+}

package/dist/slices/list-chapters/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function listChapters(model: EventModel): void;

package/dist/slices/list-chapters/index.js

@@ -0,0 +1,22 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function listChapters(model) {
+    const chapters = [...model.chapters.values()];
+    if (chapters.length === 0) {
+        console.log('<chapters/>');
+        return;
+    }
+    // Sort by x position (left to right on timeline)
+    const sorted = [...chapters].sort((a, b) => a.position.x - b.position.x);
+    console.log('<chapters>');
+    for (const chapter of sorted) {
+        console.log(`  <chapter name="${escapeXml(chapter.name)}"/>`);
+    }
+    console.log('</chapters>');
+}

package/dist/slices/list-commands/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function listCommands(model: EventModel): void;

package/dist/slices/list-commands/index.js

@@ -0,0 +1,21 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function listCommands(model) {
+    const commands = [...model.commands.values()];
+    if (commands.length === 0) {
+        console.log('<commands/>');
+        return;
+    }
+    const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
+    console.log('<commands>');
+    for (const cmd of sorted) {
+        console.log(`  <command name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}"/>`);
+    }
+    console.log('</commands>');
+}

package/dist/slices/list-events/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function listEvents(model: EventModel): void;

package/dist/slices/list-events/index.js

@@ -0,0 +1,21 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function listEvents(model) {
+    const events = [...model.events.values()];
+    if (events.length === 0) {
+        console.log('<events/>');
+        return;
+    }
+    const sorted = [...events].sort((a, b) => a.name.localeCompare(b.name));
+    console.log('<events>');
+    for (const evt of sorted) {
+        console.log(`  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}"/>`);
+    }
+    console.log('</events>');
+}

package/dist/slices/list-slices/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function listSlices(model: EventModel): void;

package/dist/slices/list-slices/index.js

@@ -0,0 +1,21 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+export function listSlices(model) {
+    const slices = [...model.slices.values()];
+    if (slices.length === 0) {
+        console.log('<slices/>');
+        return;
+    }
+    const sorted = [...slices].sort((a, b) => a.position.x - b.position.x);
+    console.log('<slices>');
+    for (const slice of sorted) {
+        console.log(`  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
+    }
+    console.log('</slices>');
+}

package/dist/slices/mark-slice-status/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function markSliceStatus(model: EventModel, filePath: string, sliceName: string, status: string): void;

package/dist/slices/mark-slice-status/index.js

@@ -0,0 +1,38 @@
+import { appendEvent } from '../../lib/file-loader.js';
+const validStatuses = ['created', 'in-progress', 'blocked', 'done'];
+const eventTypeMap = {
+    'created': 'SliceMarkedAsCreated',
+    'in-progress': 'SliceMarkedAsInProgress',
+    'blocked': 'SliceMarkedAsBlocked',
+    'done': 'SliceMarkedAsDone',
+};
+export function markSliceStatus(model, filePath, sliceName, status) {
+    if (!validStatuses.includes(status)) {
+        console.error(`Error: Invalid status: ${status}`);
+        console.error('Valid statuses: created, in-progress, blocked, done');
+        process.exit(1);
+    }
+    const newStatus = status;
+    const slices = [...model.slices.values()];
+    const sliceNameLower = sliceName.toLowerCase();
+    const slice = slices.find(s => s.name.toLowerCase() === sliceNameLower || s.name.toLowerCase().includes(sliceNameLower));
+    if (!slice) {
+        console.error(`Error: Slice not found: ${sliceName}`);
+        console.error('Available slices:');
+        for (const s of slices) {
+            console.error(`  - ${s.name}`);
+        }
+        process.exit(1);
+    }
+    if (slice.status === newStatus) {
+        console.log(`Slice "${slice.name}" is already marked as ${newStatus}`);
+        return;
+    }
+    const event = {
+        type: eventTypeMap[newStatus],
+        sliceId: slice.id,
+        timestamp: Date.now(),
+    };
+    appendEvent(filePath, event);
+    console.log(`Marked slice "${slice.name}" as ${newStatus}`);
+}

package/dist/slices/open-app/index.d.ts

@@ -0,0 +1 @@
+export declare function openApp(): void;

package/dist/slices/open-app/index.js

@@ -0,0 +1,36 @@
+import { exec } from 'node:child_process';
+import { platform } from 'node:os';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const APP_URL = 'https://www.eventmodeling.app';
+function getOpenCommand() {
+    switch (platform()) {
+        case 'darwin':
+            return 'open';
+        case 'win32':
+            return 'start';
+        default:
+            return 'xdg-open';
+    }
+}
+function findLocalEventModel() {
+    const files = fs.readdirSync(process.cwd());
+    const eventModelFiles = files.filter(f => f.endsWith('.eventmodel'));
+    if (eventModelFiles.length === 1) {
+        return path.join(process.cwd(), eventModelFiles[0]);
+    }
+    return null;
+}
+export function openApp() {
+    const command = getOpenCommand();
+    const localFile = findLocalEventModel();
+    console.log(`Opening ${APP_URL}...`);
+    if (localFile) {
+        console.log(`Then open: ${localFile}`);
+    }
+    exec(`${command} ${APP_URL}`, (error) => {
+        if (error) {
+            console.error(`Could not open browser. Please visit: ${APP_URL}`);
+        }
+    });
+}

package/dist/slices/search/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function search(model: EventModel, term: string): void;

package/dist/slices/search/index.js

@@ -0,0 +1,175 @@
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function isInSlice(slice, pos, width, height) {
+    const centerX = pos.x + width / 2;
+    const centerY = pos.y + height / 2;
+    return (centerX >= slice.position.x &&
+        centerX <= slice.position.x + slice.size.width &&
+        centerY >= slice.position.y &&
+        centerY <= slice.position.y + slice.size.height);
+}
+function findSlicesContaining(model, pos, width, height) {
+    return [...model.slices.values()].filter(slice => isInSlice(slice, pos, width, height));
+}
+export function search(model, term) {
+    const termLower = term.toLowerCase();
+    const results = [];
+    // Search commands
+    for (const cmd of model.commands.values()) {
+        if (cmd.name.toLowerCase().includes(termLower)) {
+            const slices = findSlicesContaining(model, cmd.position, cmd.width, cmd.height);
+            const incomingFlows = [...model.flows.values()].filter(f => f.targetId === cmd.id);
+            const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === cmd.id);
+            let xml = `  <command name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}">\n`;
+            if (slices.length > 0) {
+                xml += '    <in-slices>\n';
+                for (const slice of slices) {
+                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
+                }
+                xml += '    </in-slices>\n';
+            }
+            if (incomingFlows.length > 0) {
+                xml += '    <triggered-by>\n';
+                for (const flow of incomingFlows) {
+                    const screen = model.screens.get(flow.sourceId);
+                    const processor = model.processors.get(flow.sourceId);
+                    if (screen)
+                        xml += `      <screen name="${escapeXml(screen.name)}"/>\n`;
+                    if (processor)
+                        xml += `      <processor name="${escapeXml(processor.name)}"/>\n`;
+                }
+                xml += '    </triggered-by>\n';
+            }
+            if (outgoingFlows.length > 0) {
+                xml += '    <produces>\n';
+                for (const flow of outgoingFlows) {
+                    const evt = model.events.get(flow.targetId);
+                    if (evt)
+                        xml += `      <event name="${escapeXml(evt.name)}"/>\n`;
+                }
+                xml += '    </produces>\n';
+            }
+            xml += '  </command>';
+            results.push(xml);
+        }
+    }
+    // Search events
+    for (const evt of model.events.values()) {
+        if (evt.name.toLowerCase().includes(termLower)) {
+            const slices = findSlicesContaining(model, evt.position, evt.width, evt.height);
+            const incomingFlows = [...model.flows.values()].filter(f => f.targetId === evt.id);
+            const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === evt.id);
+            let xml = `  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}">\n`;
+            if (slices.length > 0) {
+                xml += '    <in-slices>\n';
+                for (const slice of slices) {
+                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
+                }
+                xml += '    </in-slices>\n';
+            }
+            if (incomingFlows.length > 0) {
+                xml += '    <produced-by>\n';
+                for (const flow of incomingFlows) {
+                    const cmd = model.commands.get(flow.sourceId);
+                    if (cmd)
+                        xml += `      <command name="${escapeXml(cmd.name)}"/>\n`;
+                }
+                xml += '    </produced-by>\n';
+            }
+            if (outgoingFlows.length > 0) {
+                xml += '    <consumed-by>\n';
+                for (const flow of outgoingFlows) {
+                    const rm = model.readModels.get(flow.targetId);
+                    if (rm)
+                        xml += `      <read-model name="${escapeXml(rm.name)}"/>\n`;
+                }
+                xml += '    </consumed-by>\n';
+            }
+            xml += '  </event>';
+            results.push(xml);
+        }
+    }
+    // Search read models
+    for (const rm of model.readModels.values()) {
+        if (rm.name.toLowerCase().includes(termLower)) {
+            const slices = findSlicesContaining(model, rm.position, rm.width, rm.height);
+            let xml = `  <read-model name="${escapeXml(rm.name)}" fields="${rm.fields.length}">\n`;
+            if (slices.length > 0) {
+                xml += '    <in-slices>\n';
+                for (const slice of slices) {
+                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
+                }
+                xml += '    </in-slices>\n';
+            }
+            xml += '  </read-model>';
+            results.push(xml);
+        }
+    }
+    // Search screens
+    for (const scr of model.screens.values()) {
+        if (scr.name.toLowerCase().includes(termLower)) {
+            const slices = findSlicesContaining(model, scr.position, scr.width, scr.height);
+            let xml = `  <screen name="${escapeXml(scr.name)}" fields="${scr.fields.length}">\n`;
+            if (slices.length > 0) {
+                xml += '    <in-slices>\n';
+                for (const slice of slices) {
+                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
+                }
+                xml += '    </in-slices>\n';
+            }
+            xml += '  </screen>';
+            results.push(xml);
+        }
+    }
+    // Search processors
+    for (const proc of model.processors.values()) {
+        if (proc.name.toLowerCase().includes(termLower)) {
+            const slices = findSlicesContaining(model, proc.position, proc.width, proc.height);
+            let xml = `  <processor name="${escapeXml(proc.name)}" fields="${proc.fields.length}">\n`;
+            if (slices.length > 0) {
+                xml += '    <in-slices>\n';
+                for (const slice of slices) {
+                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
+                }
+                xml += '    </in-slices>\n';
+            }
+            xml += '  </processor>';
+            results.push(xml);
+        }
+    }
+    // Search slices
+    for (const slice of model.slices.values()) {
+        if (slice.name.toLowerCase().includes(termLower)) {
+            let xml = `  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`;
+            results.push(xml);
+        }
+    }
+    // Search scenarios
+    for (const scenario of model.scenarios.values()) {
+        if (scenario.name.toLowerCase().includes(termLower)) {
+            const slice = model.slices.get(scenario.sliceId);
+            let xml = `  <scenario name="${escapeXml(scenario.name)}">\n`;
+            if (slice) {
+                xml += `    <in-slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
+            }
+            xml += '  </scenario>';
+            results.push(xml);
+        }
+    }
+    if (results.length === 0) {
+        console.log(`<search-results query="${escapeXml(term)}" count="0"/>`);
+    }
+    else {
+        console.log(`<search-results query="${escapeXml(term)}" count="${results.length}">`);
+        for (const result of results) {
+            console.log(result);
+        }
+        console.log('</search-results>');
+    }
+}

package/dist/slices/show-chapter/index.d.ts

@@ -0,0 +1,2 @@
+import type { EventModel } from '../../types.js';
+export declare function showChapter(model: EventModel, name: string): void;