@hahnpro/flow-sdk 2025.2.0-beta.1 → 2025.2.0-beta.3

package/src/lib/FlowApplication.js

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowApplication = void 0;
+const tslib_1 = require("tslib");
+require("reflect-metadata");
+const perf_hooks_1 = require("perf_hooks");
+const hpc_api_1 = require("@hahnpro/hpc-api");
+const jetstream_1 = require("@nats-io/jetstream");
+const cloudevents_1 = require("cloudevents");
+const lodash_1 = require("lodash");
+const object_sizeof_1 = tslib_1.__importDefault(require("object-sizeof"));
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const amqp_1 = require("./amqp");
+const ContextManager_1 = require("./ContextManager");
+const flow_interface_1 = require("./flow.interface");
+const FlowLogger_1 = require("./FlowLogger");
+const nats_1 = require("./nats");
+const RpcClient_1 = require("./RpcClient");
+const utils_1 = require("./utils");
+const MAX_EVENT_SIZE_BYTES = +process.env.MAX_EVENT_SIZE_BYTES || 512 * 1024; // 512kb
+const WARN_EVENT_PROCESSING_SEC = +process.env.WARN_EVENT_PROCESSING_SEC || 60;
+const WARN_EVENT_QUEUE_SIZE = +process.env.WARN_EVENT_QUEUE_SIZE || 100;
+class FlowApplication {
+    constructor(modules, flow, baseLoggerOrConfig, amqpConnection, natsConnection, skipApi, explicitInit, mockApi) {
+        this.modules = modules;
+        this.flow = flow;
+        this.declarations = {};
+        this.elements = {};
+        this.initialized = false;
+        this.outputStreamMap = new Map();
+        this.outputQueueMetrics = new Map();
+        this.performanceMap = new Map();
+        this.publishLifecycleEvent = async (element, flowEventId, eventType, data = {}) => {
+            try {
+                const { flowId, deploymentId, id: elementId, functionFqn, inputStreamId } = element.getMetadata();
+                const natsEvent = {
+                    source: `flows/${flowId}/deployments/${deploymentId}/elements/${elementId}`,
+                    type: eventType,
+                    data: {
+                        flowEventId,
+                        functionFqn,
+                        inputStreamId,
+                        ...data,
+                    },
+                };
+                await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent, `${nats_1.natsFlowsPrefixFlowDeployment}.flowlifecycle.${deploymentId}`);
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        };
+        this.setQueueMetrics = (id) => {
+            const metrics = this.outputQueueMetrics.get(id) || { size: 0, lastAdd: 0, lastRemove: Date.now(), warnings: 0 };
+            const secsProcessing = Math.round((metrics.lastAdd - metrics.lastRemove) / 1000);
+            metrics.size++;
+            metrics.lastAdd = Date.now();
+            if (secsProcessing >= WARN_EVENT_PROCESSING_SEC * (metrics.warnings + 1)) {
+                this.logger.warn(`Input stream "${id}" has ${metrics.size} queued events and the last event has been processing for ${secsProcessing}s`);
+                metrics.warnings++;
+            }
+            else if (metrics.size % WARN_EVENT_QUEUE_SIZE === 0) {
+                this.logger.warn(`Input stream "${id}" has ${metrics.size} queued events`);
+            }
+            this.outputQueueMetrics.set(id, metrics);
+        };
+        this.updateMetrics = (id) => {
+            const metrics = this.outputQueueMetrics.get(id);
+            if (metrics) {
+                metrics.size = metrics.size > 0 ? metrics.size - 1 : 0;
+                metrics.lastRemove = Date.now();
+                metrics.warnings = 0;
+                this.outputQueueMetrics.set(id, metrics);
+            }
+        };
+        this.subscribe = (streamId, observer) => this.getOutputStream(streamId).subscribe(observer);
+        this.emit = (event) => {
+            if (event) {
+                try {
+                    this.publishNatsEventFlowlogs(event);
+                    if (this.outputStreamMap.has(event.getStreamId())) {
+                        this.getOutputStream(event.getStreamId()).next(event);
+                    }
+                }
+                catch (err) {
+                    this.logger.error(err);
+                }
+            }
+        };
+        this.emitPartial = (completeEvent, partialEvent) => {
+            // send complete event, log only partial event
+            try {
+                if (completeEvent && this.outputStreamMap.has(completeEvent.getStreamId())) {
+                    this.getOutputStream(completeEvent.getStreamId()).next(completeEvent);
+                }
+                if (partialEvent) {
+                    this.publishNatsEventFlowlogs(partialEvent);
+                }
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+        };
+        this.onMessage = async (cloudEvent) => {
+            if (cloudEvent.subject.endsWith('.update')) {
+                try {
+                    const flow = cloudEvent.data;
+                    if (!flow) {
+                        return;
+                    }
+                    let context = {};
+                    if (flow.context) {
+                        this.context = { ...this.context, ...flow.context };
+                        context = this.context;
+                    }
+                    if (flow.properties) {
+                        this.contextManager.updateFlowProperties(flow.properties);
+                        for (const element of Object.values(this.elements)) {
+                            element.replacePlaceholderAndSetProperties();
+                            element.onFlowPropertiesChanged?.(flow.properties);
+                        }
+                    }
+                    if (Object.keys(context).length > 0) {
+                        for (const element of flow.elements || []) {
+                            context = { ...context, name: element.name };
+                            this.elements?.[element.id]?.onContextChanged(context);
+                        }
+                    }
+                    for (const element of flow.elements || []) {
+                        this.elements?.[element.id]?.setPropertiesWithPlaceholders((0, lodash_1.cloneDeep)(element.properties));
+                        this.elements?.[element.id]?.onPropertiesChanged(this.contextManager.replaceAllPlaceholderProperties(this.elements[element.id].getPropertiesWithPlaceholders()));
+                    }
+                    const natsEvent = {
+                        source: `hpc/flow-application`,
+                        type: `${nats_1.natsFlowsPrefixFlowDeployment}.health`,
+                        subject: `${this.context.deploymentId}`,
+                        data: {
+                            deploymentId: this.context.deploymentId,
+                            status: 'updated',
+                        },
+                    };
+                    await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
+                }
+                catch (err) {
+                    this.logger.error(err);
+                    const natsEvent = {
+                        source: `hpc/flow-application`,
+                        type: `${nats_1.natsFlowsPrefixFlowDeployment}.health`,
+                        subject: `${this.context.deploymentId}`,
+                        data: {
+                            deploymentId: this.context.deploymentId,
+                            status: 'updating failed',
+                        },
+                    };
+                    await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
+                }
+            }
+            else if (cloudEvent.subject.endsWith('.message')) {
+                const data = cloudEvent.data;
+                const elementId = data?.elementId;
+                if (elementId) {
+                    this.elements?.[elementId]?.onMessage?.(data);
+                }
+                else {
+                    for (const element of Object.values(this.elements)) {
+                        element?.onMessage?.(data);
+                    }
+                }
+            }
+            else if (cloudEvent.subject.endsWith('.destroy')) {
+                // TODO war com.flowstudio.deployment.destroy in RabbitMq: wo wird das jetzt wieder gesendet?
+                this.destroy();
+            }
+        };
+        /**
+         * Publish a flow event to the amqp flowlogs exchange.
+         * If the event size exceeds the limit it will be truncated
+         *
+         * TODO warum darf hier nicht false zurückgegeben werden? -> erzeugt loop
+         */
+        this.publishNatsEventFlowlogs = async (event) => {
+            if (!this._natsConnection || this._natsConnection.isClosed()) {
+                return true;
+            }
+            try {
+                const formatedEvent = event.format();
+                if ((0, object_sizeof_1.default)(formatedEvent) > MAX_EVENT_SIZE_BYTES) {
+                    formatedEvent.data = (0, utils_1.truncate)(formatedEvent.data);
+                }
+                const natsEvent = {
+                    source: `hpc/flow-application`,
+                    type: `${nats_1.natsFlowsPrefixFlowDeployment}.flowlogs`,
+                    subject: `${this.context.deploymentId}`,
+                    data: formatedEvent,
+                };
+                await (0, nats_1.publishNatsEvent)(this.logger, this._natsConnection, natsEvent);
+                return true;
+            }
+            catch (err) {
+                this.logger.error(err);
+                return false;
+            }
+        };
+        if (baseLoggerOrConfig && !baseLoggerOrConfig.log) {
+            const config = baseLoggerOrConfig;
+            this.baseLogger = config.logger;
+            this.amqpConnection = config.amqpConnection || (0, amqp_1.createAmqpConnection)(config.amqpConfig);
+            this.natsConnectionConfig = config.natsConfig;
+            this._natsConnection = config.natsConnection;
+            this.skipApi = config.skipApi || false;
+            explicitInit = config.explicitInit || false;
+            this._api = config.mockApi || null;
+            this.apiClient = config.apiClient;
+        }
+        else {
+            this.baseLogger = baseLoggerOrConfig;
+            this.amqpConnection = amqpConnection?.managedConnection;
+            this._natsConnection = natsConnection;
+            this.skipApi = skipApi || false;
+            explicitInit = explicitInit || false;
+            this._api = mockApi || null;
+        }
+        this.logger = new FlowLogger_1.FlowLogger({ id: 'none', functionFqn: 'FlowApplication', ...flow?.context }, this.baseLogger || undefined, this.publishNatsEventFlowlogs);
+        this.contextManager = new ContextManager_1.ContextManager(this.logger, this.flow?.properties);
+        process.once('uncaughtException', (err) => {
+            this.logger.error('Uncaught exception!');
+            this.logger.error(err);
+            this.destroy(1);
+        });
+        process.on('unhandledRejection', (reason) => {
+            this.logger.error('Unhandled promise rejection!');
+            this.logger.error(reason);
+        });
+        process.on('SIGTERM', () => {
+            this.logger.log('Flow Deployment is terminating');
+            this.destroy(0);
+        });
+        if (explicitInit !== true) {
+            this.init();
+        }
+    }
+    get rpcClient() {
+        if (!this._rpcClient && this.amqpConnection) {
+            this._rpcClient = new RpcClient_1.RpcClient(this.amqpConnection, this.logger);
+        }
+        return this._rpcClient;
+    }
+    get api() {
+        return this._api;
+    }
+    get natsConnection() {
+        return this._natsConnection;
+    }
+    getContextManager() {
+        return this.contextManager;
+    }
+    getProperties() {
+        return this.contextManager.getProperties();
+    }
+    async consumeNatsMessagesOfConsumer(consumer, consumeOptions) {
+        if (this.natsMessageIterator) {
+            await this.natsMessageIterator.close();
+        }
+        this.natsMessageIterator = await consumer.consume(consumeOptions);
+        for await (const msg of this.natsMessageIterator) {
+            try {
+                let event;
+                try {
+                    event = new cloudevents_1.CloudEvent(msg.json());
+                    event.validate();
+                }
+                catch (error) {
+                    this.logger.error('Message is not a valid CloudEvent and will be discarded');
+                    msg.ack(); // Acknowledge the message to remove it from the queue
+                    continue;
+                }
+                await this.onMessage(event);
+                msg.ack();
+            }
+            catch (error) {
+                this.logger.error('Error processing message');
+                this.logger.error(error);
+                msg.nak(1000);
+            }
+        }
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.context = { ...this.flow.context };
+        this.contextManager.overwriteAllProperties(this.flow.properties ?? {});
+        try {
+            if (!this.skipApi && !(this._api instanceof hpc_api_1.MockAPI)) {
+                const { owner } = this.context;
+                // only create real API if it should not be skipped and is not already a mock
+                this._api = new hpc_api_1.API(this.apiClient, { activeOrg: owner?.id });
+            }
+        }
+        catch (err) {
+            this.logger.error(err?.message || err);
+        }
+        const logErrorAndExit = async (err) => {
+            this.logger.error(new Error(err));
+            await this.destroy(1);
+        };
+        if (!this._natsConnection && this.natsConnectionConfig) {
+            try {
+                this._natsConnection = await (0, nats_1.createNatsConnection)(this.natsConnectionConfig);
+            }
+            catch (err) {
+                await logErrorAndExit(`Could not connect to the NATS-Servers: ${err}`);
+            }
+        }
+        if (this._natsConnection && !this._natsConnection.isClosed() && this.context?.deploymentId !== undefined) {
+            try {
+                const consumerOptions = {
+                    ...nats_1.defaultConsumerConfig,
+                    name: `flow-deployment-${this.context.deploymentId}`,
+                    filter_subject: `${nats_1.natsFlowsPrefixFlowDeployment}.${this.context.deploymentId}.*`,
+                    inactive_threshold: 10 * 60 * 1000000000, //  10 mins
+                    deliver_policy: jetstream_1.DeliverPolicy.New,
+                };
+                const consumer = await (0, nats_1.getOrCreateConsumer)(this.logger, this._natsConnection, nats_1.FLOWS_STREAM_NAME, consumerOptions.name, consumerOptions);
+                // Recreate consumers on reconnects: NO AWAIT, listen asynchronously
+                const handleNatsStatus = async () => {
+                    try {
+                        this.logger.debug('ConsumerService: Reconnected to Nats and re-creating non-durable consumers');
+                        await (0, nats_1.getOrCreateConsumer)(this.logger, this._natsConnection, nats_1.FLOWS_STREAM_NAME, consumerOptions.name, consumerOptions);
+                        this.consumeNatsMessagesOfConsumer(consumer, { expires: 10 * 1000000000 /* 10 seconds */ });
+                    }
+                    catch (e) {
+                        this.logger.error('NATS Status-AsyncIterator is not available, cannot listen. Due to error:');
+                        this.logger.error(e);
+                        (0, nats_1.natsEventListener)(this._natsConnection, this.logger, handleNatsStatus);
+                    }
+                };
+                (0, nats_1.natsEventListener)(this._natsConnection, this.logger, handleNatsStatus);
+                // NO AWAIT, listen for messages of the consumer asynchronously
+                this.consumeNatsMessagesOfConsumer(consumer, { expires: 10 * 1000000000 /* 10 seconds */ });
+            }
+            catch (e) {
+                await logErrorAndExit(`Could not set up consumer for deployment messages exchanges: ${e}`);
+            }
+        }
+        this.amqpChannel = this.amqpConnection?.createChannel({
+            json: true,
+            setup: async (channel) => {
+                try {
+                    await channel.assertExchange('flow', 'direct', { durable: true }); // TODO wieso weshalb warum: wo wird das gebraucht?
+                }
+                catch (e) {
+                    await logErrorAndExit(`Could not assert exchanges: ${e}`);
+                }
+            },
+        });
+        if (this.amqpChannel) {
+            await this.amqpChannel.waitForConnect();
+        }
+        for (const module of this.modules) {
+            const moduleName = Reflect.getMetadata('module:name', module);
+            const moduleDeclarations = Reflect.getMetadata('module:declarations', module);
+            if (!moduleName || !moduleDeclarations || !Array.isArray(moduleDeclarations)) {
+                await logErrorAndExit(`FlowModule (${module.name}) metadata is missing or invalid`);
+                return;
+            }
+            for (const declaration of moduleDeclarations) {
+                const functionFqn = Reflect.getMetadata('element:functionFqn', declaration);
+                if (!functionFqn) {
+                    await logErrorAndExit(`FlowFunction (${declaration.name}) metadata is missing or invalid`);
+                    return;
+                }
+                this.declarations[`${moduleName}.${functionFqn}`] = declaration;
+            }
+        }
+        for (const element of this.flow.elements) {
+            const { id, name, properties, module, functionFqn } = element;
+            try {
+                const context = { ...this.context, id, name, logger: this.baseLogger, app: this };
+                this.elements[id] = new this.declarations[`${module}.${functionFqn}`](context, 
+                // run recursively through all properties and interpolate them / replace them with their explicit value
+                this.contextManager.replaceAllPlaceholderProperties(properties));
+                this.elements[id].setPropertiesWithPlaceholders((0, lodash_1.cloneDeep)(properties));
+            }
+            catch (err) {
+                await logErrorAndExit(`Could not create FlowElement for ${module}.${functionFqn}`);
+                return;
+            }
+        }
+        for (const connection of this.flow.connections) {
+            const { source, target, sourceStream = 'default', targetStream = 'default' } = connection;
+            if (!source || !target) {
+                continue;
+            }
+            const sourceStreamId = `${source}.${sourceStream}`;
+            const targetStreamId = `${target}.${targetStream}`;
+            const element = this.elements[target];
+            if (!element || !element.constructor) {
+                await logErrorAndExit(`${target} has not been initialized`);
+                return;
+            }
+            const streamHandler = Reflect.getMetadata(`stream:${targetStream}`, element.constructor);
+            if (!streamHandler || !element[streamHandler]) {
+                await logErrorAndExit(`${target} does not implement a handler for ${targetStream}`);
+                return;
+            }
+            const streamOptions = Reflect.getMetadata(`stream:options:${targetStream}`, element.constructor) || {};
+            const concurrent = streamOptions.concurrent || 1;
+            const outputStream = this.getOutputStream(sourceStreamId);
+            outputStream
+                .pipe((0, operators_1.tap)(() => this.setQueueMetrics(targetStreamId)), (0, operators_1.mergeMap)(async (event) => {
+                const eventId = event.getId();
+                this.publishLifecycleEvent(element, eventId, flow_interface_1.LifecycleEvent.ACTIVATED);
+                this.performanceMap.set(eventId, perf_hooks_1.performance.eventLoopUtilization());
+                const start = perf_hooks_1.performance.now();
+                try {
+                    await element[streamHandler](event);
+                    const duration = Math.ceil(perf_hooks_1.performance.now() - start);
+                    this.publishLifecycleEvent(element, eventId, flow_interface_1.LifecycleEvent.COMPLETED, { duration });
+                }
+                catch (err) {
+                    const duration = Math.ceil(perf_hooks_1.performance.now() - start);
+                    this.publishLifecycleEvent(element, eventId, flow_interface_1.LifecycleEvent.TERMINATED, { duration });
+                    try {
+                        element.handleApiError(err);
+                    }
+                    catch (e) {
+                        this.logger.error(err);
+                    }
+                }
+                return event;
+            }, concurrent), (0, operators_1.tap)((event) => {
+                this.updateMetrics(targetStreamId);
+                let elu = this.performanceMap.get(event.getId());
+                if (elu) {
+                    this.performanceMap.delete(event.getId());
+                    elu = perf_hooks_1.performance.eventLoopUtilization(elu);
+                    if (elu.utilization > 0.75 && elu.active > 2000) {
+                        this.logger.warn(`High event loop utilization detected for ${targetStreamId} with event ${event.getId()}! Handler was active for ${Number(elu.active).toFixed(2)}ms with a utilization of ${Number(elu.utilization * 100).toFixed(2)}%. Consider refactoring or move tasks to a worker thread.`);
+                    }
+                }
+            }))
+                .subscribe();
+        }
+        this.initialized = true;
+        this.logger.log('Flow Deployment is running');
+    }
+    /**
+     * Calls onDestroy lifecycle method on all flow elements,
+     * closes amqp connection after allowing logs to be processed and published
+     * then exits process
+     */
+    async destroy(exitCode = 0) {
+        try {
+            try {
+                for (const element of Object.values(this.elements)) {
+                    element?.onDestroy?.();
+                }
+                if (this._rpcClient) {
+                    await this._rpcClient.close();
+                }
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+            // allow time for logs to be processed
+            await (0, utils_1.delay)(250);
+            if (this.amqpConnection) {
+                await this.amqpConnection.close();
+            }
+            // Close all output streams
+            for (const [id, stream] of this.outputStreamMap.entries()) {
+                try {
+                    stream?.complete();
+                }
+                catch (err) {
+                    this.logger.error(`Error completing output stream ${id}: ${err.message}`);
+                }
+            }
+            // Nats: Delete consumer for flow deployment, stop message listening and close connection
+            try {
+                await this.natsMessageIterator?.close();
+                await this._natsConnection?.drain();
+                await this._natsConnection?.close();
+                if (this._natsConnection && !this._natsConnection.isClosed()) {
+                    await (0, jetstream_1.jetstreamManager)(this._natsConnection).then((jsm) => {
+                        jsm.consumers
+                            .delete(nats_1.FLOWS_STREAM_NAME, `flow-deployment-${this.context?.deploymentId}`)
+                            .then(() => {
+                            this.logger.debug(`Deleted consumer for flow deployment ${this.context?.deploymentId}`);
+                        })
+                            .catch((err) => {
+                            this.logger.error(`Could not delete consumer for flow deployment ${this.context?.deploymentId}: ${err.message}`);
+                        });
+                    });
+                }
+            }
+            catch (err) {
+                this.logger.error(err);
+            }
+            // remove process listeners
+            process.removeAllListeners('SIGTERM');
+            process.removeAllListeners('uncaughtException');
+            process.removeAllListeners('unhandledRejection');
+        }
+        catch (err) {
+            /* eslint-disable-next-line no-console */
+            console.error(err);
+        }
+        finally {
+            if (process.env.NODE_ENV !== 'test') {
+                process.exit(exitCode);
+            }
+        }
+    }
+    /**
+     * Returns rxjs subject for the specified stream id.
+     * A new subject will be created if one doesn't exist yet.
+     */
+    getOutputStream(id) {
+        const stream = this.outputStreamMap.get(id);
+        if (!stream) {
+            this.outputStreamMap.set(id, new rxjs_1.Subject());
+            return this.outputStreamMap.get(id);
+        }
+        return stream;
+    }
+}
+exports.FlowApplication = FlowApplication;

package/src/lib/FlowElement.d.ts

@@ -0,0 +1,67 @@
+import { API } from '@hahnpro/hpc-api';
+import { PythonShell } from 'python-shell';
+import { ClassType, DeploymentMessage, FlowContext, FlowElementContext } from './flow.interface';
+import { Context } from './FlowApplication';
+import { FlowEvent } from './FlowEvent';
+import { FlowLogger } from './FlowLogger';
+export declare abstract class FlowElement<T = any> {
+    private readonly propertiesClassType?;
+    private readonly whitelist;
+    readonly functionFqn: string;
+    protected readonly api?: API;
+    protected readonly logger: FlowLogger;
+    protected metadata: FlowElementContext;
+    protected properties: T;
+    private propertiesWithPlaceholders;
+    private readonly app?;
+    private readonly rpcRoutingKey;
+    private stopPropagateStream;
+    constructor({ app, logger, ...metadata }: Context, properties?: unknown, propertiesClassType?: ClassType<T>, whitelist?: boolean);
+    /**
+     * Sets the placeholder properties for this flow element
+     * @param propertiesWithPlaceholders
+     */
+    setPropertiesWithPlaceholders(propertiesWithPlaceholders: T): void;
+    /**
+     * Returns the placeholder properties for this flow element
+     */
+    getPropertiesWithPlaceholders(): T;
+    get flowProperties(): Record<string, any>;
+    get natsConnection(): import("@nats-io/nats-core").NatsConnection;
+    onDestroy?: () => void;
+    onMessage?: (message: DeploymentMessage) => void;
+    /**
+     * Replace all placeholder properties with their explicit updated value and set them as the properties of the element
+     */
+    replacePlaceholderAndSetProperties(): void;
+    onFlowPropertiesChanged?: (properties: Record<string, any>) => void;
+    onContextChanged: (context: Partial<FlowContext>) => void;
+    onPropertiesChanged: (properties: T) => void;
+    getMetadata: () => FlowElementContext;
+    protected setProperties: (properties: T) => void;
+    handleApiError: (error: any) => void;
+    /**
+     * @deprecated since version 4.8.0, will be removed in 5.0.0, use emitEvent(...) instead
+     */
+    protected emitOutput(data?: any, outputId?: string, time?: Date): FlowEvent;
+    protected emitEvent(data: Record<string, any>, inputEvent: FlowEvent, outputId?: string, time?: Date): FlowEvent;
+    protected validateProperties<P>(classType: ClassType<P>, properties?: any, whitelist?: boolean): P;
+    protected logValidationErrors(error: any, parent?: string): void;
+    protected validateEventData<E>(classType: ClassType<E>, event: FlowEvent, whitelist?: boolean): E;
+    protected interpolate: (value: any, ...templateVariables: any) => any;
+    protected callRpcFunction(functionName: string, ...args: any[]): Promise<unknown>;
+    protected runPyRpcScript(scriptPath: string, ...args: (string | boolean | number)[]): PythonShell;
+}
+export declare function InputStream(id?: string, options?: {
+    concurrent?: number;
+    stopPropagation?: boolean;
+}): MethodDecorator;
+export declare function FlowFunction(fqn: string): ClassDecorator;
+export declare abstract class FlowResource<T = any> extends FlowElement<T> {
+}
+export declare abstract class FlowTask<T = any> extends FlowElement<T> {
+}
+export declare abstract class FlowTrigger<T = any> extends FlowElement<T> {
+}
+export declare abstract class FlowDashboard<T = any> extends FlowResource<T> {
+}