nesoi 3.0.0

package/lib/compiler/typescript/bridge/extract.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSBridgeExtract = void 0;
+const ts = __importStar(require("typescript"));
+const log_1 = require("../../../engine/util/log");
+class TSBridgeExtract {
+    static imports(compiler, node) {
+        const { tsCompiler } = compiler;
+        if (Array.isArray(node.filepath)) {
+            if (!['constants', 'externals'].includes(node.builder.$b)) {
+                log_1.Log.warn('compiler', 'bridge.extract', 'It\'s currently not possible to transfer ts code from multiple builder files to a single schema. Skipping this node.', { tag: node.tag, filepath: node.filepath });
+            }
+            return;
+        }
+        const imports = tsCompiler.extractImports(node.filepath, {
+            ignore: [] // TODO: ignore space file
+        });
+        if (imports.length) {
+            log_1.Log.debug('compiler', 'bridge.extract', `Extracted TS imports from ${node.filepath}`, imports);
+        }
+        return imports;
+    }
+    static types(compiler, node) {
+        const { tsCompiler } = compiler;
+        if (Array.isArray(node.filepath)) {
+            if (!['constants', 'externals'].includes(node.builder.$b)) {
+                log_1.Log.warn('compiler', 'bridge.extract', 'It\'s currently not possible to transfer ts code from multiple builder files to a single schema. Skipping this node.', { tag: node.tag, filepath: node.filepath });
+            }
+            return;
+        }
+        const types = [];
+        if (node.builder.$b === 'job') {
+            const rawOutputs = tsCompiler.query(node.filepath, {
+                query: 'job.*.output.raw',
+                expectedKinds: [ts.SyntaxKind.CallExpression]
+            });
+            rawOutputs.forEach(raw => {
+                const sig = tsCompiler.checker.getResolvedSignature(raw.node);
+                if (!sig)
+                    return;
+                const args = tsCompiler.checker.getTypeArgumentsForResolvedSignature(sig);
+                if (!args)
+                    return;
+                const type = tsCompiler.checker.typeToString(args[0], undefined, ts.TypeFormatFlags.NoTruncation);
+                types.push({
+                    path: raw.path,
+                    type
+                });
+            });
+        }
+        if (types.length) {
+            log_1.Log.debug('compiler', 'bridge.extract', `Extracted TS type from ${node.filepath}`, types.map(f => f.path));
+        }
+        return types;
+    }
+    static functions(compiler, node) {
+        const { tsCompiler } = compiler;
+        if (Array.isArray(node.filepath)) {
+            if (!['constants', 'externals'].includes(node.builder.$b)) {
+                log_1.Log.warn('compiler', 'bridge.extract', 'It\'s currently not possible to transfer ts code from multiple builder files to a single schema. Skipping this node.', { tag: node.tag, filepath: node.filepath });
+            }
+            return;
+        }
+        const functions = [];
+        if (node.builder.$b === 'bucket') {
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'bucket.*.view.1.return.**.computed.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+        }
+        if (node.builder.$b === 'message') {
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'message.*.template.0.return.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+        }
+        if (node.builder.$b === 'job') {
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'job.*.messages.0.return.*.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'job.*.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'job.*.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'job.*.method.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+        }
+        if (node.builder.$b === 'resource') {
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.create.0.return.input.0.return.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.create.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.create.0.return.prepare.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.create.0.return.after.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.update.0.return.input.0.return.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.update.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.update.0.return.prepare.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.update.0.return.after.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.delete.0.return.input.0.return.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.delete.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.delete.0.return.prepare.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'resource.*.delete.0.return.after.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+        }
+        if (node.builder.$b === 'machine') {
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.messages.0.return.*.**.rule.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.beforeEnter.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.beforeEnter.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.beforeEnter.0.return.method.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.afterEnter.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.afterEnter.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.afterEnter.0.return.method.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.beforeLeave.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.beforeLeave.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.beforeLeave.0.return.method.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.afterLeave.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.afterLeave.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.afterLeave.0.return.method.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.if.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.if.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.runJob.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.runJob.0.return.extra.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.runJob.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.runJob.0.return.assert.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.runJob.0.return.method.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+            functions.push(...tsCompiler.query(node.filepath, {
+                query: 'machine.*.{state.1.return}.transition.1.return.{else.0.return}.runJob.0.return.method.0',
+                expectedKinds: [ts.SyntaxKind.FunctionExpression, ts.SyntaxKind.ArrowFunction, ts.SyntaxKind.Identifier, ts.SyntaxKind.CallExpression]
+            }));
+        }
+        if (functions.length) {
+            log_1.Log.debug('compiler', 'bridge.extract', `Extracted TS code from ${node.filepath}`, functions.map(f => f.path));
+        }
+        return functions;
+    }
+}
+exports.TSBridgeExtract = TSBridgeExtract;

package/lib/compiler/typescript/bridge/inject.d.ts

@@ -0,0 +1,10 @@
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { Compiler } from "../../compiler";
+export declare class TSBridgeInject {
+    static inject(compiler: Compiler, nodes: ResolvedBuilderNode[]): void;
+    private static bucket;
+    private static message;
+    private static job;
+    private static machine;
+    private static machineTransitions;
+}

package/lib/compiler/typescript/bridge/inject.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSBridgeInject = void 0;
+const log_1 = require("../../../engine/util/log");
+const name_helpers_1 = require("../../helpers/name_helpers");
+class TSBridgeInject {
+    static inject(compiler, nodes) {
+        const { tsCompiler } = compiler;
+        nodes.forEach(node => {
+            log_1.Log.debug('compiler', 'bridge.inject', `Injecting TS code on ${node.tag}`);
+            const schema = node.schema;
+            if (schema.$t === 'bucket') {
+                const extract = node.bridge?.extract;
+                if (!extract)
+                    return;
+                this.bucket(compiler, extract, node);
+            }
+            if (schema.$t === 'message') {
+                const extract = node.bridge?.extract;
+                if (!extract)
+                    return;
+                this.message(compiler, extract, node);
+            }
+            if (schema.$t === 'job') {
+                const extract = node.bridge?.extract;
+                if (!extract)
+                    return;
+                this.job(compiler, extract, node);
+            }
+            if (schema.$t === 'machine') {
+                const extract = node.bridge?.extract;
+                if (!extract)
+                    return;
+                this.machine(compiler, extract, node);
+            }
+        });
+    }
+    static bucket(compiler, extract, node) {
+        const { tsCompiler } = compiler;
+        const schema = node.schema;
+        const typeName = name_helpers_1.NameHelpers.names(schema).type;
+        Object.entries(extract.views).forEach(([name, view]) => {
+            Object.entries(view?.computed || {}).forEach(([prop, node]) => {
+                let f = { children: schema.views[name].fields };
+                prop.split('.').forEach(p => {
+                    f = f.children[p];
+                });
+                f.value.computed = { fn: {
+                        __fn: tsCompiler.getFnText(node),
+                        __fn_type: '(...args: any[]) => any', // TODO: evaluate
+                    } };
+                f['#data'] = tsCompiler.getReturnType(node);
+            });
+        });
+    }
+    static message(compiler, extract, node) {
+        const { tsCompiler } = compiler;
+        const schema = node.schema;
+        const typeName = name_helpers_1.NameHelpers.names(schema).type;
+        Object.entries(extract.rules).forEach(([prop, node]) => {
+            let f = { children: schema.template.fields };
+            let addr = '';
+            prop.split('.').forEach(p => {
+                f = f.children[p];
+                addr += `['${p}${f.type === 'id' ? '_id' : ''}']`;
+            });
+            const type = `$MessageTemplateRule<${typeName}['#raw']${addr}, ${typeName}['#raw']>`;
+            f.rules = node.map(fn => ({
+                __fn: tsCompiler.getFnText(fn),
+                __fn_type: '(...args: any[]) => any', // TODO: evaluate
+            }));
+        });
+    }
+    static job(compiler, extract, node) {
+        const { tsCompiler } = compiler;
+        const schema = node.schema;
+        if (extract.extrasAndAsserts) {
+            schema.extrasAndAsserts = extract.extrasAndAsserts.map(e => {
+                const t = Object.keys(e)[0];
+                return {
+                    [t]: {
+                        __fn: tsCompiler.getFnText(e[t]),
+                        __fn_type: '(...args: any[]) => any', // TODO: evaluate
+                    }
+                };
+            });
+        }
+        if (extract.method) {
+            schema.method = {
+                __fn: tsCompiler.getFnText(extract.method),
+                __fn_type: '(...args: any[]) => any', // TODO: evaluate
+            };
+            // No output specified, infer from function
+            if (!schema.output) {
+                schema['#output'] = tsCompiler.getReturnType(extract.method);
+            }
+        }
+        if (extract.prepare) {
+            const scope = schema.scope;
+            scope.prepareMethod = {
+                __fn: tsCompiler.getFnText(extract.prepare),
+                __fn_type: '(...args: any[]) => any', // TODO: evaluate
+            };
+        }
+        if (extract.after) {
+            const scope = schema.scope;
+            scope.afterMethod = {
+                __fn: tsCompiler.getFnText(extract.after),
+                __fn_type: '(...args: any[]) => any', // TODO: evaluate
+            };
+        }
+        if (extract.outputRaw) {
+            schema.output ?? (schema.output = {});
+            schema.output.raw = extract.outputRaw;
+            schema['#output'] = undefined; // Will be recalculated by element based on output
+        }
+    }
+    static machine(compiler, extract, node) {
+        const { tsCompiler } = compiler;
+        const schema = node.schema;
+        Object.entries(extract.states).forEach(([sname, state]) => {
+            Object.entries(state.transitions || {}).forEach(([tname, trst]) => {
+                const transitions = schema.transitions.from[sname][tname];
+                TSBridgeInject.machineTransitions(compiler, trst, transitions);
+            });
+        });
+    }
+    static machineTransitions(compiler, extract, transitions) {
+        const { tsCompiler } = compiler;
+        extract.forEach((fn, i) => {
+            if (fn.if) {
+                transitions[i].condition = {
+                    __fn: tsCompiler.getFnText(fn.if),
+                    __fn_type: '(...args: any[]) => any', // TODO: evaluate
+                };
+            }
+        });
+    }
+}
+exports.TSBridgeInject = TSBridgeInject;

package/lib/compiler/typescript/bridge/organize.d.ts

@@ -0,0 +1,61 @@
+import * as ts from 'typescript';
+import { tsFnQueryResult } from '../typescript_compiler';
+export type tsFn = ts.FunctionExpression | ts.ArrowFunction;
+export type tsImport = ts.ImportDeclaration;
+export type BucketFnExtract = {
+    views: {
+        [name: string]: {
+            computed: Record<string, tsFn>;
+        };
+    };
+};
+export type MessageFnExtract = {
+    rules: Record<string, tsFn[]>;
+};
+export type JobFnExtract = {
+    extrasAndAsserts?: ({
+        extra: tsFn;
+    } | {
+        assert: tsFn;
+    })[];
+    method?: tsFn;
+    prepare?: tsFn;
+    after?: tsFn;
+    outputRaw?: string;
+};
+export type MachineFnExtract = {
+    states: {
+        [name: string]: MachineStateFnExtract;
+    };
+};
+export type MachineStateFnExtract = {
+    transitions?: {
+        [msg: string]: MachineTransitionFnExtract[];
+    };
+};
+export type MachineTransitionFnExtract = {
+    if?: tsFn;
+};
+export type OrganizedExtract = {
+    buckets: Record<string, BucketFnExtract>;
+    messages: Record<string, MessageFnExtract>;
+    jobs: Record<string, JobFnExtract>;
+    machines: Record<string, MachineFnExtract>;
+};
+export declare class TSBridgeOrganize {
+    static functions(types?: {
+        path: string;
+        type: string;
+    }[], functions?: tsFnQueryResult[]): OrganizedExtract;
+    private static bucket;
+    private static message;
+    private static inlineMessage;
+    private static inputMessage;
+    private static job;
+    private static type_job;
+    private static resourceJob;
+    private static resource;
+    private static machine;
+    private static machineState;
+    private static machineTransition;
+}