eventmodeler 0.5.0 → 0.6.1

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

@@ -1,276 +0,0 @@
-export declare function listSlices(modelId: string, format?: OutputFormat, chapterFilter?: string): Promise<string>;
-export declare function listEvents(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function listCommands(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function listChapters(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function listActors(modelId: string, format?: OutputFormat): Promise<string>;
-export interface SearchResult {
-    type: string;
-    id: string;
-    name: string;
-    chapterId?: string;
-    chapterName?: string;
-    sliceId?: string;
-    sliceName?: string;
-    sliceStatus?: string;
-    parentChapterId?: string;
-    parentChapterName?: string;
-}
-export interface SearchResponse {
-    query: string;
-    count: number;
-    results: SearchResult[];
-}
-export declare function search(modelId: string, term: string): Promise<SearchResponse>;
-export interface ModelSummary {
-    modelName: string;
-    slices: {
-        total: number;
-        byStatus: {
-            created: number;
-            inProgress: number;
-            blocked: number;
-            done: number;
-        };
-        byType: {
-            stateChange: number;
-            automation: number;
-            stateView: number;
-            unknown: number;
-        };
-    };
-    events: number;
-    commands: number;
-    readModels: number;
-    screens: number;
-    processors: number;
-    chapters: number;
-    aggregates: number;
-    actors: number;
-    flows: number;
-    scenarios: number;
-}
-export declare function getSummary(modelId: string): Promise<ModelSummary>;
-export type SliceStatus = 'created' | 'in-progress' | 'blocked' | 'done';
-export declare function markSliceStatus(modelId: string, sliceName: string, status: SliceStatus): Promise<{
-    success: boolean;
-}>;
-export type ElementType = 'command' | 'event' | 'readModel' | 'screen' | 'processor';
-export interface FieldInput {
-    name: string;
-    fieldType: string;
-    isList?: boolean;
-    isOptional?: boolean;
-    isGenerated?: boolean;
-    isUserInput?: boolean;
-    subfields?: FieldInput[];
-}
-export declare function addField(modelId: string, elementType: ElementType, elementName: string, field: FieldInput): Promise<{
-    success: boolean;
-}>;
-export declare function removeField(modelId: string, elementType: ElementType, elementName: string, fieldName: string): Promise<{
-    success: boolean;
-}>;
-export interface FieldUpdates {
-    name?: string;
-    fieldType?: string;
-    isList?: boolean;
-    isOptional?: boolean;
-    isGenerated?: boolean;
-    isUserInput?: boolean;
-}
-export declare function updateField(modelId: string, elementType: ElementType, elementName: string, fieldName: string, updates: FieldUpdates): Promise<{
-    success: boolean;
-}>;
-export interface FieldMappingInput {
-    from: string;
-    to: string;
-}
-export declare function mapFields(modelId: string, sourceName: string, targetName: string, mappings: FieldMappingInput[]): Promise<{
-    success: boolean;
-}>;
-export interface ScenarioInput {
-    name: string;
-    description?: string;
-    given?: Array<{
-        event: string;
-        fieldValues?: Record<string, unknown>;
-    }>;
-    when?: {
-        command?: {
-            command: string;
-            fieldValues?: Record<string, unknown>;
-        };
-        events?: Array<{
-            event: string;
-            fieldValues?: Record<string, unknown>;
-        }>;
-    };
-    then: {
-        type: 'events' | 'error' | 'command' | 'readModelAssertion' | 'noCommand';
-        events?: Array<{
-            event: string;
-            fieldValues?: Record<string, unknown>;
-        }>;
-        errorMessage?: string;
-        errorType?: string;
-        command?: {
-            command: string;
-            fieldValues?: Record<string, unknown>;
-        };
-        readModelAssertion?: {
-            readModel: string;
-            givenEvents?: Array<{
-                event: string;
-                fieldValues?: Record<string, unknown>;
-            }>;
-            expectedFieldValues?: Record<string, unknown>;
-        };
-    };
-}
-export declare function createScenario(modelId: string, sliceName: string, scenario: ScenarioInput): Promise<{
-    success: boolean;
-    scenarioId: string;
-}>;
-export declare function removeScenario(modelId: string, scenarioName: string, sliceName?: string): Promise<{
-    success: boolean;
-}>;
-export declare function createFlow(modelId: string, fromName: string, toName: string): Promise<{
-    success: boolean;
-}>;
-export interface CompoundFieldInput {
-    name: string;
-    fieldType: string;
-    isList?: boolean;
-    isOptional?: boolean;
-    isGenerated?: boolean;
-    isUserInput?: boolean;
-    subfields?: CompoundFieldInput[];
-}
-export interface StateChangeSliceInput {
-    sliceName: string;
-    after?: string;
-    before?: string;
-    screen: {
-        name: string;
-        fields: CompoundFieldInput[];
-    };
-    command: {
-        name: string;
-        fields: CompoundFieldInput[];
-    };
-    event: {
-        name: string;
-        fields: CompoundFieldInput[];
-    };
-}
-export interface StateChangeSliceResult {
-    success: boolean;
-    sliceId: string;
-    screenId: string;
-    commandId: string;
-    eventId: string;
-    screenToCommandMappings: number;
-    commandToEventMappings: number;
-}
-export declare function createStateChangeSlice(modelId: string, input: StateChangeSliceInput): Promise<StateChangeSliceResult>;
-export interface AutomationSliceInput {
-    sliceName: string;
-    after?: string;
-    before?: string;
-    readModel: {
-        name: string;
-        fields: CompoundFieldInput[];
-    };
-    processor: {
-        name: string;
-    };
-    command: {
-        name: string;
-        fields: CompoundFieldInput[];
-    };
-    event: {
-        name: string;
-        fields: CompoundFieldInput[];
-    };
-}
-export interface AutomationSliceResult {
-    success: boolean;
-    sliceId: string;
-    readModelId: string;
-    processorId: string;
-    commandId: string;
-    eventId: string;
-    readModelToCommandMappings: number;
-    commandToEventMappings: number;
-}
-export declare function createAutomationSlice(modelId: string, input: AutomationSliceInput): Promise<AutomationSliceResult>;
-export interface StateViewSliceInput {
-    sliceName: string;
-    after?: string;
-    before?: string;
-    readModel: {
-        name: string;
-        fields: CompoundFieldInput[];
-    };
-}
-export interface StateViewSliceResult {
-    success: boolean;
-    sliceId: string;
-    readModelId: string;
-}
-export declare function createStateViewSlice(modelId: string, input: StateViewSliceInput): Promise<StateViewSliceResult>;
-export type OutputFormat = 'xml' | 'json';
-export declare function showSlice(modelId: string, sliceName: string, format?: OutputFormat): Promise<string>;
-export declare function showEvent(modelId: string, eventName: string, format?: OutputFormat): Promise<string>;
-export declare function showCommand(modelId: string, commandName: string, format?: OutputFormat): Promise<string>;
-export declare function showChapter(modelId: string, chapterName: string, format?: OutputFormat): Promise<string>;
-export declare function showActor(modelId: string, actorName: string, format?: OutputFormat): Promise<string>;
-export declare function exportJson(modelId: string): Promise<string>;
-export declare function codegenSlice(modelId: string, sliceName: string): Promise<string>;
-export interface CodegenChapterEventsField {
-    name: string;
-    type: string;
-    list?: boolean;
-    generated?: boolean;
-    optional?: boolean;
-    userInput?: boolean;
-    subfields?: CodegenChapterEventsField[];
-}
-export interface CodegenChapterEventsChapter {
-    id: string;
-    name: string;
-    parent?: CodegenChapterEventsChapter | null;
-}
-export interface CodegenChapterEventsSlice {
-    id: string;
-    name: string;
-    sliceType: string;
-}
-export interface CodegenChapterEventsEvent {
-    id: string;
-    name: string;
-    fields: CodegenChapterEventsField[];
-    aggregate?: string;
-    sourceSlices: string[];
-}
-export interface CodegenChapterEventsResponse {
-    chapter: CodegenChapterEventsChapter | null;
-    sliceCount: number;
-    eventCount: number;
-    slices: CodegenChapterEventsSlice[];
-    events: CodegenChapterEventsEvent[];
-}
-export declare function codegenEvents(modelId: string, chapterName?: string): Promise<CodegenChapterEventsResponse>;
-export declare function listAggregates(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function listReadModels(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function listScreens(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function listProcessors(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function showCompleteness(modelId: string, elementName: string, format?: OutputFormat): Promise<string>;
-export declare function showModelCompleteness(modelId: string, format?: OutputFormat): Promise<string>;
-export declare function showAggregateCompleteness(modelId: string, aggregateName: string, format?: OutputFormat): Promise<string>;
-export declare function showReadModel(modelId: string, name: string, format?: OutputFormat): Promise<string>;
-export declare function showScreen(modelId: string, name: string, format?: OutputFormat): Promise<string>;
-export declare function showProcessor(modelId: string, name: string, format?: OutputFormat): Promise<string>;
-export declare function showAggregate(modelId: string, name: string, format?: OutputFormat): Promise<string>;
-export declare function showScenario(modelId: string, name: string, format?: OutputFormat): Promise<string>;
-export declare function listScenarios(modelId: string, format?: OutputFormat): Promise<string>;

package/dist/cloud/slices/index.js

@@ -1,406 +0,0 @@
-// Cloud slice implementations - thin wrappers that call backend CLI endpoints
-// The backend does all the heavy lifting (name resolution, data denormalization)
-import { getBackendUrl } from '../../lib/config.js';
-import { getValidAccessToken } from '../../lib/auth.js';
-// =============================================================================
-// HTTP Client for CLI endpoints
-// =============================================================================
-/**
- * Handle HTTP error responses with user-friendly messages.
- * Tries to extract error detail from response body, falls back to status-based messages.
- */
-async function handleHttpError(response, path) {
-    const text = await response.text().catch(() => '');
-    const errorDetail = extractErrorDetail(text);
-    switch (response.status) {
-        case 401:
-            throw new Error(`Authentication required. Run 'eventmodeler login' to authenticate.` +
-                (errorDetail ? `\n\nOriginal error: ${errorDetail}` : ''));
-        case 403:
-            throw new Error(`Permission denied. You may not have access to this model, or you need editor permission for this action.` +
-                (errorDetail ? `\n\nOriginal error: ${errorDetail}` : ''));
-        case 404:
-            throw new Error(errorDetail || `Not found: ${path}`);
-        default:
-            throw new Error(errorDetail || `HTTP ${response.status}: ${response.statusText}`);
-    }
-}
-const GENERIC_ERROR_MESSAGES = new Set([
-    'internal server error',
-    'bad request',
-    'unauthorized',
-    'forbidden',
-    'not found',
-]);
-function isGenericErrorMessage(value) {
-    return GENERIC_ERROR_MESSAGES.has(value.trim().toLowerCase());
-}
-function toStringValue(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-function collectCandidateMessages(node, out) {
-    if (!node || typeof node !== 'object')
-        return;
-    const obj = node;
-    // Prefer richer fields before generic "error".
-    for (const key of ['message', 'detail', 'reason', 'description', 'title', 'error']) {
-        const value = toStringValue(obj[key]);
-        if (value)
-            out.push(value);
-    }
-    const errors = obj.errors;
-    if (Array.isArray(errors)) {
-        for (const entry of errors) {
-            if (typeof entry === 'string') {
-                const value = entry.trim();
-                if (value)
-                    out.push(value);
-            }
-            else if (entry && typeof entry === 'object') {
-                collectCandidateMessages(entry, out);
-            }
-        }
-    }
-    const cause = obj.cause;
-    if (cause && typeof cause === 'object') {
-        collectCandidateMessages(cause, out);
-    }
-}
-function extractErrorDetail(text) {
-    const body = text.trim();
-    if (!body)
-        return '';
-    try {
-        const parsed = JSON.parse(body);
-        if (typeof parsed === 'string') {
-            return parsed.trim();
-        }
-        const candidates = [];
-        collectCandidateMessages(parsed, candidates);
-        if (candidates.length > 0) {
-            const specific = candidates.find((value) => !isGenericErrorMessage(value));
-            return specific ?? candidates[0];
-        }
-    }
-    catch {
-        // Not JSON. Fall back to plain text below.
-    }
-    // Avoid dumping entire HTML pages from reverse proxies.
-    if (body.startsWith('<')) {
-        const title = body.match(/<title>([^<]+)<\/title>/i)?.[1]?.trim();
-        return title && !isGenericErrorMessage(title) ? title : '';
-    }
-    return body;
-}
-async function cliGet(path, params) {
-    const backendUrl = getBackendUrl();
-    const accessToken = await getValidAccessToken();
-    // Build query string manually using encodeURIComponent (uses %20 for spaces, not +)
-    const queryParts = Object.entries(params)
-        .filter(([_, value]) => value !== undefined)
-        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-    const queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
-    const fullUrl = `${backendUrl}${path}${queryString}`;
-    const response = await fetch(fullUrl, {
-        method: 'GET',
-        headers: {
-            Accept: 'application/json',
-            ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
-        },
-    });
-    if (!response.ok) {
-        await handleHttpError(response, path);
-    }
-    const text = await response.text();
-    if (!text.trim()) {
-        throw new Error(`Empty response from ${path}`);
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const snippet = text.slice(0, 200);
-        throw new Error(`Invalid JSON from ${path}: ${message}. Body: ${snippet}`);
-    }
-}
-async function cliPost(path, body) {
-    const backendUrl = getBackendUrl();
-    const accessToken = await getValidAccessToken();
-    const response = await fetch(`${backendUrl}${path}`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            Accept: 'application/json',
-            ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
-        },
-        body: JSON.stringify(body),
-    });
-    if (!response.ok) {
-        await handleHttpError(response, path);
-    }
-    const text = await response.text();
-    if (!text.trim()) {
-        throw new Error(`Empty response from ${path}`);
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const snippet = text.slice(0, 200);
-        throw new Error(`Invalid JSON from ${path}: ${message}. Body: ${snippet}`);
-    }
-}
-// =============================================================================
-// Query Functions (read-only, return denormalized data)
-// =============================================================================
-export async function listSlices(modelId, format = 'xml', chapterFilter) {
-    const params = { modelId };
-    if (chapterFilter)
-        params.chapter = chapterFilter;
-    return cliGetText('/cli/list-slices', params, format);
-}
-export async function listEvents(modelId, format = 'xml') {
-    return cliGetText('/cli/list-events', { modelId }, format);
-}
-export async function listCommands(modelId, format = 'xml') {
-    return cliGetText('/cli/list-commands', { modelId }, format);
-}
-export async function listChapters(modelId, format = 'xml') {
-    return cliGetText('/cli/list-chapters', { modelId }, format);
-}
-export async function listActors(modelId, format = 'xml') {
-    return cliGetText('/cli/list-actors', { modelId }, format);
-}
-export async function search(modelId, term) {
-    return cliGet('/cli/search', { modelId, term });
-}
-export async function getSummary(modelId) {
-    return cliGet('/cli/summary', { modelId });
-}
-export async function markSliceStatus(modelId, sliceName, status) {
-    return cliPost('/cli/mark-slice-status', { modelId, sliceName, status });
-}
-export async function addField(modelId, elementType, elementName, field) {
-    return cliPost('/cli/add-field', { modelId, elementType, elementName, field });
-}
-export async function removeField(modelId, elementType, elementName, fieldName) {
-    return cliPost('/cli/remove-field', { modelId, elementType, elementName, fieldName });
-}
-export async function updateField(modelId, elementType, elementName, fieldName, updates) {
-    return cliPost('/cli/update-field', { modelId, elementType, elementName, fieldName, updates });
-}
-export async function mapFields(modelId, sourceName, targetName, mappings) {
-    return cliPost('/cli/map-fields', { modelId, sourceName, targetName, mappings });
-}
-export async function createScenario(modelId, sliceName, scenario) {
-    return cliPost('/cli/create-scenario', { modelId, sliceName, scenario });
-}
-export async function removeScenario(modelId, scenarioName, sliceName) {
-    return cliPost('/cli/remove-scenario', { modelId, scenarioName, sliceName });
-}
-export async function createFlow(modelId, fromName, toName) {
-    return cliPost('/cli/create-flow', { modelId, fromName, toName });
-}
-export async function createStateChangeSlice(modelId, input) {
-    return cliPost('/cli/create-state-change-slice', { modelId, ...input });
-}
-export async function createAutomationSlice(modelId, input) {
-    return cliPost('/cli/create-automation-slice', { modelId, ...input });
-}
-export async function createStateViewSlice(modelId, input) {
-    return cliPost('/cli/create-state-view-slice', { modelId, ...input });
-}
-// =============================================================================
-// View Functions (read-only, return formatted XML/JSON strings)
-// =============================================================================
-// Maps format to Accept header media type for content negotiation with the backend
-function formatToMediaType(format) {
-    return format === 'xml' ? 'application/xml' : 'application/json';
-}
-// Helper for view queries that return text (XML or JSON string).
-// Uses Accept header for content negotiation instead of a format query param.
-async function cliGetText(path, params, format) {
-    const backendUrl = getBackendUrl();
-    const accessToken = await getValidAccessToken();
-    // Build query string manually using encodeURIComponent (uses %20 for spaces, not +)
-    // Some servers don't decode + as space in query parameters
-    const queryParts = Object.entries(params)
-        .filter(([_, value]) => value !== undefined)
-        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
-    const queryString = queryParts.length > 0 ? `?${queryParts.join('&')}` : '';
-    const fullUrl = `${backendUrl}${path}${queryString}`;
-    const response = await fetch(fullUrl, {
-        method: 'GET',
-        headers: {
-            Accept: formatToMediaType(format),
-            ...(accessToken ? { Authorization: `Bearer ${accessToken}` } : {}),
-        },
-    });
-    if (!response.ok) {
-        await handleHttpError(response, path);
-    }
-    const text = await response.text();
-    return text.trimEnd();
-}
-export async function showSlice(modelId, sliceName, format = 'xml') {
-    return cliGetText('/cli/show-slice', { modelId, name: sliceName }, format);
-}
-export async function showEvent(modelId, eventName, format = 'xml') {
-    return cliGetText('/cli/show-event', { modelId, name: eventName }, format);
-}
-export async function showCommand(modelId, commandName, format = 'xml') {
-    return cliGetText('/cli/show-command', { modelId, name: commandName }, format);
-}
-export async function showChapter(modelId, chapterName, format = 'xml') {
-    return cliGetText('/cli/show-chapter', { modelId, name: chapterName }, format);
-}
-export async function showActor(modelId, actorName, format = 'xml') {
-    return cliGetText('/cli/show-actor', { modelId, name: actorName }, format);
-}
-export async function exportJson(modelId) {
-    return cliGetText('/cli/export-json', { modelId });
-}
-export async function codegenSlice(modelId, sliceName) {
-    return cliGetText('/cli/codegen-slice', { modelId, name: sliceName });
-}
-function countFieldsDeep(fields) {
-    if (!fields || fields.length === 0) {
-        return 0;
-    }
-    return fields.reduce((count, field) => count + 1 + countFieldsDeep(field.subfields), 0);
-}
-function normalizeName(name) {
-    return (name ?? '').trim().toLowerCase();
-}
-export async function codegenEvents(modelId, chapterName) {
-    const slicesOutput = await listSlices(modelId, 'json', chapterName);
-    let slicesPayload;
-    try {
-        slicesPayload = JSON.parse(slicesOutput);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Invalid JSON from /cli/list-slices: ${message}`);
-    }
-    const slices = (slicesPayload.slices ?? [])
-        .filter((slice) => typeof slice.id === 'string' && typeof slice.name === 'string');
-    if (slices.length === 0) {
-        return {
-            chapter: null,
-            sliceCount: 0,
-            eventCount: 0,
-            slices: [],
-            events: [],
-        };
-    }
-    const codegenOutputs = await Promise.all(slices.map(async (slice) => {
-        const raw = await codegenSlice(modelId, slice.name);
-        try {
-            return JSON.parse(raw);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Invalid JSON from /cli/codegen-slice for "${slice.name}": ${message}`);
-        }
-    }));
-    const aggregatedSlices = [];
-    const eventsByName = new Map();
-    let chapter = null;
-    for (let i = 0; i < codegenOutputs.length; i++) {
-        const codegenOutput = codegenOutputs[i];
-        const fallbackSlice = slices[i];
-        const sliceName = codegenOutput.slice?.name ?? fallbackSlice.name;
-        aggregatedSlices.push({
-            id: codegenOutput.slice?.id ?? fallbackSlice.id,
-            name: sliceName,
-            sliceType: codegenOutput.sliceType ?? 'STATE_CHANGE',
-        });
-        if (chapterName && !chapter && codegenOutput.chapter) {
-            chapter = codegenOutput.chapter;
-        }
-        for (const event of codegenOutput.elements?.events ?? []) {
-            if (!event.name) {
-                continue;
-            }
-            const key = normalizeName(event.name);
-            if (!key) {
-                continue;
-            }
-            const existing = eventsByName.get(key);
-            if (!existing) {
-                eventsByName.set(key, {
-                    id: event.id ?? '',
-                    name: event.name,
-                    fields: event.fields ?? [],
-                    aggregate: event.aggregate,
-                    sourceSlices: [sliceName],
-                });
-                continue;
-            }
-            if (!existing.sourceSlices.includes(sliceName)) {
-                existing.sourceSlices.push(sliceName);
-            }
-            if (!existing.aggregate && event.aggregate) {
-                existing.aggregate = event.aggregate;
-            }
-            if (countFieldsDeep(event.fields) > countFieldsDeep(existing.fields)) {
-                existing.fields = event.fields ?? [];
-            }
-            if (!existing.id && event.id) {
-                existing.id = event.id;
-            }
-        }
-    }
-    const events = [...eventsByName.values()]
-        .map(event => ({ ...event, sourceSlices: [...event.sourceSlices].sort((a, b) => a.localeCompare(b)) }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-    const sortedSlices = [...aggregatedSlices].sort((a, b) => a.name.localeCompare(b.name));
-    return {
-        chapter,
-        sliceCount: sortedSlices.length,
-        eventCount: events.length,
-        slices: sortedSlices,
-        events,
-    };
-}
-export async function listAggregates(modelId, format = 'xml') {
-    return cliGetText('/cli/list-aggregates', { modelId }, format);
-}
-export async function listReadModels(modelId, format = 'xml') {
-    return cliGetText('/cli/list-readmodels', { modelId }, format);
-}
-export async function listScreens(modelId, format = 'xml') {
-    return cliGetText('/cli/list-screens', { modelId }, format);
-}
-export async function listProcessors(modelId, format = 'xml') {
-    return cliGetText('/cli/list-processors', { modelId }, format);
-}
-export async function showCompleteness(modelId, elementName, format = 'xml') {
-    return cliGetText('/cli/show-completeness', { modelId, name: elementName }, format);
-}
-export async function showModelCompleteness(modelId, format = 'xml') {
-    return cliGetText('/cli/show-model-completeness', { modelId }, format);
-}
-export async function showAggregateCompleteness(modelId, aggregateName, format = 'xml') {
-    return cliGetText('/cli/show-aggregate-completeness', { modelId, name: aggregateName }, format);
-}
-export async function showReadModel(modelId, name, format = 'xml') {
-    return cliGetText('/cli/show-readmodel', { modelId, name }, format);
-}
-export async function showScreen(modelId, name, format = 'xml') {
-    return cliGetText('/cli/show-screen', { modelId, name }, format);
-}
-export async function showProcessor(modelId, name, format = 'xml') {
-    return cliGetText('/cli/show-processor', { modelId, name }, format);
-}
-export async function showAggregate(modelId, name, format = 'xml') {
-    return cliGetText('/cli/show-aggregate', { modelId, name }, format);
-}
-export async function showScenario(modelId, name, format = 'xml') {
-    return cliGetText('/cli/show-scenario', { modelId, name }, format);
-}
-export async function listScenarios(modelId, format = 'xml') {
-    return cliGetText('/cli/list-scenarios', { modelId }, format);
-}