@kapeta/local-cluster-service 0.43.3 → 0.45.0

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [0.45.0](https://github.com/kapetacom/local-cluster-service/compare/v0.44.0...v0.45.0) (2024-05-24)
+
+
+### Features
+
+* Introduces Storm API ([#147](https://github.com/kapetacom/local-cluster-service/issues/147)) ([5bdb075](https://github.com/kapetacom/local-cluster-service/commit/5bdb075f838c331e3a517778c55f83c32cc5b812))
+
+# [0.44.0](https://github.com/kapetacom/local-cluster-service/compare/v0.43.3...v0.44.0) (2024-05-08)
+
+
+### Bug Fixes
+
+* Remove wrong todo comment ([c300f3c](https://github.com/kapetacom/local-cluster-service/commit/c300f3c8bd2542517317aca0d54825332f6424bc))
+* Safeguard with optional chaining ([ff8af98](https://github.com/kapetacom/local-cluster-service/commit/ff8af98845d3cc6431a919a7d251c5a90e5b88ef))
+
+
+### Features
+
+* Mask sensitive data in req and res body ([39c0c46](https://github.com/kapetacom/local-cluster-service/commit/39c0c46a9f9c58938b70c4736d1fb8ec651d7d9c))
+
 ## [0.43.3](https://github.com/kapetacom/local-cluster-service/compare/v0.43.2...v0.43.3) (2024-05-08)
 
 

package/dist/cjs/index.js

@@ -50,6 +50,7 @@ const routes_9 = __importDefault(require("./src/attachments/routes"));
 const routes_10 = __importDefault(require("./src/tasks/routes"));
 const api_1 = __importDefault(require("./src/api"));
 const routes_11 = __importDefault(require("./src/ai/routes"));
+const routes_12 = __importDefault(require("./src/storm/routes"));
 const utils_1 = require("./src/utils/utils");
 const request_1 = __importDefault(require("request"));
 const repositoryManager_1 = require("./src/repositoryManager");
@@ -89,6 +90,7 @@ function createServer() {
     app.use('/tasks', routes_10.default);
     app.use('/api', api_1.default);
     app.use('/ai', routes_11.default);
+    app.use('/storm', routes_12.default);
     app.get('/status', async (req, res) => {
         res.send({
             ok: true,

package/dist/cjs/src/codeGeneratorManager.d.ts

@@ -4,6 +4,7 @@
  */
 import { Definition } from '@kapeta/local-cluster-config';
 declare class CodeGeneratorManager {
+    ensureTarget(targetKind: string): Promise<boolean>;
     private ensureLanguageTargetInRegistry;
     reload(): Promise<void>;
     initialize(): Promise<void>;

package/dist/cjs/src/codeGeneratorManager.js

@@ -17,6 +17,17 @@ const repositoryManager_1 = require("./repositoryManager");
 const TARGET_KIND = 'core/language-target';
 const BLOCK_TYPE_REGEX = /^core\/block-type.*/;
 class CodeGeneratorManager {
+    async ensureTarget(targetKind) {
+        const targetRef = (0, nodejs_utils_1.normalizeKapetaUri)(targetKind);
+        // Automatically downloads target if not available
+        const targetAsset = await assetManager_1.assetManager.getAsset(targetRef);
+        if (!targetAsset) {
+            console.error('Language target not found: %s', targetKind);
+            return false;
+        }
+        await this.ensureLanguageTargetInRegistry(targetAsset?.path, targetAsset?.version, targetAsset?.data);
+        return true;
+    }
     async ensureLanguageTargetInRegistry(path, version, definition) {
         const key = `${definition.metadata.name}:${version}`;
         try {
@@ -72,14 +83,9 @@ class CodeGeneratorManager {
             //Not all block types have targets
             return;
         }
-        const targetRef = (0, nodejs_utils_1.normalizeKapetaUri)(yamlContent.spec.target?.kind);
-        // Automatically downloads target if not available
-        const targetAsset = await assetManager_1.assetManager.getAsset(targetRef);
-        if (!targetAsset) {
-            console.error('Language target not found: %s', yamlContent.spec.target?.kind);
+        if (!(await this.ensureTarget(yamlContent.spec.target?.kind))) {
             return;
         }
-        await this.ensureLanguageTargetInRegistry(targetAsset?.path, targetAsset?.version, targetAsset?.data);
         const baseDir = path_1.default.dirname(yamlFile);
         console.log('Generating code for path: %s', baseDir);
         const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);

package/dist/cjs/src/middleware/cors.d.ts

@@ -2,5 +2,6 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+/// <reference types="cookie-parser" />
 import { NextFunction, Request, Response } from 'express';
 export declare function corsHandler(req: Request, res: Response, next: NextFunction): void;

package/dist/cjs/src/middleware/kapeta.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+/// <reference types="cookie-parser" />
 import { NextFunction, Request, Response } from 'express';
 import { EnvironmentType } from '../types';
 export interface KapetaRequest extends Request {

package/dist/cjs/src/middleware/stringBody.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+/// <reference types="cookie-parser" />
 import { NextFunction, Request, Response } from 'express';
 export type StringBodyRequest = Request<any> & {
     stringBody?: string;

package/dist/cjs/src/proxy/routes.js

@@ -49,19 +49,19 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             });
             return;
         }
-        const toBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
+        const consumerBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
             return blockInstance.id.toLowerCase() === connection.consumer.blockId.toLowerCase();
         });
-        if (!toBlockInstance) {
+        if (!consumerBlockInstance) {
             res.status(401).send({ error: `Block instance not found "${req.params.consumerInstanceId}` });
             return;
         }
-        const toBlockAsset = await assetManager_1.assetManager.getAsset(toBlockInstance.block.ref);
-        if (!toBlockAsset) {
-            res.status(401).send({ error: `Block asset not found "${toBlockInstance.block.ref}` });
+        const consumerBlockAsset = await assetManager_1.assetManager.getAsset(consumerBlockInstance.block.ref);
+        if (!consumerBlockAsset) {
+            res.status(401).send({ error: `Block asset not found "${consumerBlockInstance.block.ref}` });
             return;
         }
-        const consumerResource = getResource(toBlockAsset.data.spec.consumers, req.params.consumerResourceName);
+        const consumerResource = getResource(consumerBlockAsset.data.spec.consumers, req.params.consumerResourceName);
         if (!consumerResource) {
             res.status(401).send({
                 error: `Block resource not found "${req.params.consumerInstanceId}::${req.params.consumerResourceName}`,
@@ -69,19 +69,19 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
             return;
         }
         const basePath = clusterService_1.clusterService.getProxyPath(req.params.systemId, req.params.consumerInstanceId, req.params.consumerResourceName, req.params.type);
-        const fromBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
+        const providerBlockInstance = lodash_1.default.find(plan.spec.blocks, (blockInstance) => {
             return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
         });
-        if (!fromBlockInstance) {
+        if (!providerBlockInstance) {
             res.status(401).send({ error: `Block instance not found "${connection.provider.blockId}` });
             return;
         }
-        const fromBlockAsset = await assetManager_1.assetManager.getAsset(fromBlockInstance.block.ref);
-        if (!fromBlockAsset) {
-            res.status(401).send({ error: `Block asset not found "${fromBlockInstance.block.ref}` });
+        const providerBlockAsset = await assetManager_1.assetManager.getAsset(providerBlockInstance.block.ref);
+        if (!providerBlockAsset) {
+            res.status(401).send({ error: `Block asset not found "${providerBlockInstance.block.ref}` });
             return;
         }
-        const providerResource = getResource(fromBlockAsset.data.spec.providers, connection.provider.resourceName);
+        const providerResource = getResource(providerBlockAsset.data.spec.providers, connection.provider.resourceName);
         if (!providerResource) {
             res.status(401).send({
                 error: `Block resource not found "${connection.provider.blockId}::${connection.provider.resourceName}`,
@@ -93,18 +93,18 @@ router.all('/:systemId/:consumerInstanceId/:consumerResourceName/:type/*', async
         while (address.endsWith('/')) {
             address = address.substring(0, address.length - 1);
         }
-        /*
-     Get the path the consumer requested.
-     Note that this might not match the path the destination is expecting so we need to identify the method
-     that is being called and identify the destination path from the connection.
-     */
+        // Get the path the consumer requested. Note that this might not match the path the
+        // destination is expecting so we need to identify the method that is being called and
+        // identify the destination path from the connection.
         const consumerPath = req.originalUrl.substring(basePath.length - 1);
         typeHandler(req, res, {
-            consumerPath,
             address,
+            connection,
+            consumerPath,
             consumerResource,
+            consumerBlockAsset,
             providerResource,
-            connection,
+            providerBlockAsset,
         });
     }
     catch (err) {

package/dist/cjs/src/proxy/types/rest.d.ts

@@ -2,9 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { Response } from 'express';
-import { ProxyRequestInfo } from '../../types';
-import { StringBodyRequest } from '../../middleware/stringBody';
+import { ProxyRequestHandler } from '../../types';
 import { Resource } from '@kapeta/schemas';
 export declare function getRestMethodId(restResource: Resource, httpMethod: string, httpPath: string): string | undefined;
-export declare function proxyRestRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo): void;
+export declare const proxyRestRequest: ProxyRequestHandler;

package/dist/cjs/src/proxy/types/rest.js

@@ -16,6 +16,7 @@ const networkManager_1 = require("../../networkManager");
 const socketManager_1 = require("../../socketManager");
 const qs_1 = require("qs");
 const web_1 = require("./web");
+const kaplang_core_1 = require("@kapeta/kaplang-core");
 function getRestMethodId(restResource, httpMethod, httpPath) {
     return lodash_1.default.findKey(restResource.spec.methods, (method) => {
         let methodType = method.method ? method.method.toUpperCase() : 'GET';
@@ -63,12 +64,49 @@ function resolveMethods(req, opts) {
         providerMethod,
     };
 }
-function proxyRestRequest(req, res, opts) {
+function resolveEntitiesSource(blockAsset) {
+    return blockAsset.data.spec?.entities?.source?.value || '';
+}
+const MASK_STRING = '*******';
+function maskSimpleRequest(req, consumerMethod, entitiesSource) {
+    const maskedRequest = lodash_1.default.cloneDeep(req);
+    Object.entries(consumerMethod.arguments || {}).forEach(([key, value]) => {
+        if (value.transport === kaplang_core_1.HTTPTransport.BODY && typeof maskedRequest.body === 'string') {
+            try {
+                maskedRequest.body = (0, kaplang_core_1.maskSensitiveData)(maskedRequest.body, kaplang_core_1.DSLConverters.fromSchemaType(value), entitiesSource, MASK_STRING);
+            }
+            catch (error) {
+                // Ignore errors masking the request body
+            }
+        }
+        // TODO: Mask HEADER
+        // TODO: Mask QUERY
+    });
+    return maskedRequest;
+}
+function maskSimpleResponse(res, consumerMethod, entitiesSource) {
+    const maskedResponse = lodash_1.default.cloneDeep(res);
+    Object.entries(consumerMethod.arguments || {}).forEach(([key, value]) => {
+        // TODO: Mask HEADER
+    });
+    try {
+        if (typeof maskedResponse.body === 'string') {
+            maskedResponse.body = (0, kaplang_core_1.maskSensitiveData)(maskedResponse.body, kaplang_core_1.DSLConverters.fromSchemaType(consumerMethod.responseType), entitiesSource, MASK_STRING);
+        }
+    }
+    catch (error) {
+        // Ignore errors masking the response body
+    }
+    return maskedResponse;
+}
+const proxyRestRequest = (req, res, opts) => {
     if (lodash_1.default.isEmpty(opts.consumerResource.spec.methods) && lodash_1.default.isEmpty(opts.providerResource.spec.methods)) {
         // If there are no methods defined, we assume the user controls the path and we just proxy the raw request
         return (0, web_1.proxyHttpRequest)(req, res, opts);
     }
-    let { consumerMethod, providerMethod } = resolveMethods(req, opts);
+    const { consumerMethod, providerMethod } = resolveMethods(req, opts);
+    const consumerEntitiesSource = resolveEntitiesSource(opts.consumerBlockAsset);
+    const providerEntitiesSource = resolveEntitiesSource(opts.providerBlockAsset);
     const consumerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(consumerMethod.path);
     const providerPathTemplate = (0, pathTemplateParser_1.pathTemplateParser)(providerMethod.path);
     const pathVariables = consumerPathTemplate.parse(opts.consumerPath);
@@ -98,7 +136,7 @@ function proxyRestRequest(req, res, opts) {
         body: req.stringBody,
         headers: requestHeaders,
     };
-    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, reqOpts, consumerMethod.id, providerMethod.id);
+    const traffic = networkManager_1.networkManager.addRequest(req.params.systemId, opts.connection, maskSimpleRequest(reqOpts, consumerMethod, consumerEntitiesSource), consumerMethod.id, providerMethod.id);
     socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_start', traffic);
     (0, request_1.default)(reqOpts, function (err, response, responseBody) {
         if (err) {
@@ -113,16 +151,17 @@ function proxyRestRequest(req, res, opts) {
         delete responseHeaders['connection'];
         res.set(responseHeaders);
         res.status(response.statusCode);
-        traffic.withResponse({
+        const simpleResponse = {
             code: response.statusCode,
             headers: response.headers,
             body: responseBody,
-        });
+        };
+        traffic.withResponse(maskSimpleResponse(simpleResponse, consumerMethod, consumerEntitiesSource));
         socketManager_1.socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
         if (responseBody) {
             res.write(responseBody);
         }
         res.end();
     });
-}
+};
 exports.proxyRestRequest = proxyRestRequest;

package/dist/cjs/src/proxy/types/web.d.ts

@@ -2,7 +2,5 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { Response } from 'express';
-import { ProxyRequestInfo } from '../../types';
-import { StringBodyRequest } from '../../middleware/stringBody';
-export declare function proxyHttpRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo): void;
+import { ProxyRequestHandler } from '../../types';
+export declare const proxyHttpRequest: ProxyRequestHandler;

package/dist/cjs/src/proxy/types/web.js

@@ -13,7 +13,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const networkManager_1 = require("../../networkManager");
 const socketManager_1 = require("../../socketManager");
 const qs_1 = require("qs");
-function proxyHttpRequest(req, res, opts) {
+const proxyHttpRequest = (req, res, opts) => {
     const requestHeaders = lodash_1.default.clone(req.headers);
     delete requestHeaders['content-length'];
     delete requestHeaders['content-encoding'];
@@ -57,5 +57,5 @@ function proxyHttpRequest(req, res, opts) {
     });
     //We need to pipe the proxy response to the client response to handle sockets and event streams
     proxyReq.pipe(res);
-}
+};
 exports.proxyHttpRequest = proxyHttpRequest;

package/dist/cjs/src/storm/codegen.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { BlockDefinitionInfo } from './event-parser';
+import { StormStream } from './stream';
+export declare class StormCodegen {
+    private readonly userPrompt;
+    private readonly blocks;
+    private readonly out;
+    constructor(userPrompt: string, blocks: BlockDefinitionInfo[]);
+    process(): Promise<void>;
+    getStream(): StormStream;
+    private handleFileOutput;
+    /**
+     * Generates the code for a block and sends it to the AI
+     */
+    private processBlockCode;
+    /**
+     * Emits the text-based files to the stream
+     */
+    private emitFiles;
+    private emitFile;
+    /**
+     * Sends the template to the AI and processes the response
+     */
+    private processTemplates;
+    /**
+     * Converts the generated files to a format that can be sent to the AI
+     */
+    private toStormFiles;
+    /**
+     * Generates the code using codegen for a given block.
+     */
+    private generateBlock;
+}

package/dist/cjs/src/storm/codegen.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StormCodegen = void 0;
+const codegen_1 = require("@kapeta/codegen");
+const codeGeneratorManager_1 = require("../codeGeneratorManager");
+const stormClient_1 = require("./stormClient");
+const stream_1 = require("./stream");
+class StormCodegen {
+    userPrompt;
+    blocks;
+    out = new stream_1.StormStream();
+    constructor(userPrompt, blocks) {
+        this.userPrompt = userPrompt;
+        this.blocks = blocks;
+    }
+    async process() {
+        console.log('Processing blocks', this.blocks.length);
+        for (const block of this.blocks) {
+            await this.processBlockCode(block);
+        }
+        this.out.end();
+    }
+    getStream() {
+        return this.out;
+    }
+    handleFileOutput(blockUri, template, data) {
+        switch (data.type) {
+            case 'FILE':
+                template.filename = data.payload.filename;
+                template.content = data.payload.content;
+                this.emitFile(blockUri, data.payload.filename, data.payload.content, data.reason);
+                break;
+        }
+    }
+    /**
+     * Generates the code for a block and sends it to the AI
+     */
+    async processBlockCode(block) {
+        // Generate the code for the block using the standard codegen templates
+        const generatedResult = await this.generateBlock(block.content, block.screens);
+        if (!generatedResult) {
+            console.warn('No generated result for block', block.uri);
+            return;
+        }
+        const allFiles = this.toStormFiles(generatedResult);
+        // Send all the non-ai files to the stream
+        this.emitFiles(block.uri, allFiles);
+        const implementFiles = [codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN];
+        // Gather the context files. These will be all be passed to the AI
+        const contextFiles = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE && !implementFiles.includes(file.type));
+        // Send the service and UI templates to the AI. These will be send one-by-one in addition to the context files
+        const serviceFiles = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.SERVICE);
+        await this.processTemplates(block.uri, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
+        //const uiTemplates: StormFileInfo[] = allFiles.filter((file) => file.type === 'ui');
+        //await this.processTemplates(stormClient.createUIImplementation, uiTemplates, contextFiles);
+    }
+    /**
+     * Emits the text-based files to the stream
+     */
+    emitFiles(uri, files) {
+        files.forEach((file) => {
+            if (!file.content || typeof file.content !== 'string') {
+                return;
+            }
+            if (file.type === codegen_1.AIFileTypes.SERVICE) {
+                // Don't send the service files to the stream yet
+                // They will need to be implemented by the AI
+                return;
+            }
+            if (file.type === codegen_1.AIFileTypes.WEB_SCREEN) {
+                // Don't send the web screen files to the stream yet
+                // They will need to be implemented by the AI
+                return;
+            }
+            this.emitFile(uri, file.filename, file.content);
+        });
+    }
+    emitFile(uri, filename, content, reason = 'File generated') {
+        this.out.emit('data', {
+            type: 'FILE',
+            reason,
+            created: Date.now(),
+            payload: {
+                filename: filename,
+                content: content,
+                blockRef: uri.toNormalizedString(),
+            },
+        });
+    }
+    /**
+     * Sends the template to the AI and processes the response
+     */
+    processTemplates(blockUri, generator, templates, contextFiles) {
+        const promises = templates.map(async (templateFile) => {
+            const stream = await generator({
+                context: contextFiles,
+                template: templateFile,
+                prompt: this.userPrompt,
+            });
+            stream.on('data', (evt) => this.handleFileOutput(blockUri, templateFile, evt));
+            return stream.waitForDone();
+        });
+        return Promise.all(promises);
+    }
+    /**
+     * Converts the generated files to a format that can be sent to the AI
+     */
+    toStormFiles(generatedResult) {
+        const allFiles = generatedResult.files.map((file) => {
+            if (!file.content) {
+                return {
+                    ...file,
+                    type: codegen_1.AIFileTypes.IGNORE,
+                };
+            }
+            if (typeof file.content !== 'string') {
+                return {
+                    ...file,
+                    type: codegen_1.AIFileTypes.IGNORE,
+                };
+            }
+            const rx = /\/\/AI-TYPE:([a-z0-9- _]+)\n/gi;
+            const match = rx.exec(file.content);
+            if (!match) {
+                return {
+                    ...file,
+                    type: codegen_1.AIFileTypes.IGNORE,
+                };
+            }
+            const type = match[1].trim();
+            file.content = file.content.replace(rx, '');
+            return {
+                ...file,
+                type,
+            };
+        });
+        return allFiles;
+    }
+    /**
+     * Generates the code using codegen for a given block.
+     */
+    async generateBlock(yamlContent, screens) {
+        if (!yamlContent.spec.target?.kind) {
+            //Not all block types have targets
+            return;
+        }
+        if (!(await codeGeneratorManager_1.codeGeneratorManager.ensureTarget(yamlContent.spec.target?.kind))) {
+            return;
+        }
+        const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);
+        codeGenerator.withOption('AIContext', stormClient_1.STORM_ID);
+        codeGenerator.withOption('AIScreens', screens ?? []);
+        return codeGenerator.generate();
+    }
+}
+exports.StormCodegen = StormCodegen;

package/dist/cjs/src/storm/event-parser.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { ScreenTemplate, StormEvent } from './events';
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { KapetaURI } from '@kapeta/nodejs-utils';
+export interface BlockDefinitionInfo {
+    uri: KapetaURI;
+    content: BlockDefinition;
+    screens: ScreenTemplate[];
+}
+export interface ParsedResult {
+    plan: Plan;
+    blocks: BlockDefinitionInfo[];
+}
+export interface StormOptions {
+    databaseKind: string;
+    apiKind: string;
+    clientKind: string;
+    webPageKind: string;
+    webFragmentKind: string;
+    mqKind: string;
+    serviceKind: string;
+    serviceLanguage: string;
+    frontendKind: string;
+    frontendLanguage: string;
+    exchangeKind: string;
+    queueKind: string;
+    publisherKind: string;
+    subscriberKind: string;
+    jwtProviderKind: string;
+    jwtConsumerKind: string;
+    smtpKind: string;
+    externalApiKind: string;
+    cliKind: string;
+    cliLanguage: string;
+    desktopKind: string;
+    desktopLanguage: string;
+    gatewayKind: string;
+}
+export declare function resolveOptions(): Promise<StormOptions>;
+export declare class StormEventParser {
+    private events;
+    private planName;
+    private planDescription;
+    private blocks;
+    private connections;
+    private failed;
+    private error;
+    private options;
+    constructor(options: StormOptions);
+    private reset;
+    addEvent(evt: StormEvent): void;
+    getEvents(): StormEvent[];
+    isValid(): boolean;
+    getError(): string;
+    private applyLayoutToBlocks;
+    toResult(handle: string): ParsedResult;
+    private toSafeName;
+    private toRef;
+    toBlockDefinitions(handle: string): {
+        [key: string]: BlockDefinitionInfo;
+    };
+    private toResourceKind;
+    private toBlockKind;
+    private toPortType;
+    private toBlockTarget;
+    private toBlockTargetKind;
+}