nesoi 3.0.0

package/lib/engine/transaction/nodes/machine.trx_node.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachineTrxNode = void 0;
+const trx_node_1 = require("../trx_node");
+class MachineTrxNode {
+    constructor(trx, machine) {
+        this.trx = trx;
+        this.machine = machine;
+    }
+    async run(message) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.machine.schema.module, 'machine', this.machine.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'run', message);
+        let response;
+        try {
+            response = await this.machine.consumeRaw(trx, message);
+        }
+        catch (e) {
+            await trx_node_1.TrxNode.error(trx, e);
+            throw e;
+        }
+        await trx_node_1.TrxNode.ok(trx, response);
+        return response;
+    }
+    async forward(message) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.machine.schema.module, 'machine', this.machine.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'forward', message);
+        let response;
+        try {
+            response = await this.machine.consume(trx, message);
+        }
+        catch (e) {
+            await trx_node_1.TrxNode.error(trx, e);
+            throw e;
+        }
+        await trx_node_1.TrxNode.ok(trx, response);
+        return response;
+    }
+}
+exports.MachineTrxNode = MachineTrxNode;

package/lib/engine/transaction/nodes/queue.trx_node.d.ts

@@ -0,0 +1,10 @@
+import { $Module, RawMessageInput } from "../../../schema";
+import { TrxNode } from '../trx_node';
+import { $Queue } from "../../../elements/blocks/queue/queue.schema";
+import { Queue } from "../../../elements/blocks/queue/queue";
+export declare class QueueTrxNode<M extends $Module, $ extends $Queue> {
+    private trx;
+    private queue;
+    constructor(trx: TrxNode<any, M, any>, queue: Queue<M, $>);
+    push(raw: RawMessageInput<M, keyof M['messages']>): Promise<void>;
+}

package/lib/engine/transaction/nodes/queue.trx_node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueTrxNode = void 0;
+const trx_node_1 = require("../trx_node");
+class QueueTrxNode {
+    constructor(trx, queue) {
+        this.trx = trx;
+        this.queue = queue;
+    }
+    async push(raw) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.queue.schema.module, 'queue', this.queue.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'push', { raw });
+        let response;
+        try {
+            // response = this.queue.push(trx, raw);
+        }
+        catch (e) {
+            await trx_node_1.TrxNode.error(trx, e);
+            throw e;
+        }
+        await trx_node_1.TrxNode.ok(trx, response);
+    }
+}
+exports.QueueTrxNode = QueueTrxNode;

package/lib/engine/transaction/nodes/resource.trx_node.d.ts

@@ -0,0 +1,24 @@
+import { $Module } from "../../../schema";
+import { TrxNode } from '../trx_node';
+import { Message } from "../../../elements/entities/message/message";
+import { $Resource } from "../../../elements/blocks/resource/resource.schema";
+import { Resource } from "../../../elements/blocks/resource/resource";
+type ViewRaw<$ extends $Resource> = $['#input.view']['#raw'];
+type QueryRaw<$ extends $Resource> = $['#input.query']['#raw'];
+type CreateRaw<$ extends $Resource> = $['#input.create']['#raw'];
+type UpdateRaw<$ extends $Resource> = $['#input.update']['#raw'];
+type DeleteRaw<$ extends $Resource> = $['#input.delete']['#raw'];
+export declare class ResourceTrxNode<M extends $Module, $ extends $Resource> {
+    private trx;
+    private resource;
+    constructor(trx: TrxNode<any, M, any>, resource: Resource<any, M, $>);
+    forward(message: Message<$['#input']>): Promise<$['#output']>;
+    run(raw: ViewRaw<$> | QueryRaw<$> | CreateRaw<$> | UpdateRaw<$> | DeleteRaw<$>): Promise<$['#output']>;
+    view<View extends keyof $['#bucket']['views'], Raw extends Omit<ViewRaw<$>, '$'>>(raw: Raw): Promise<$['#bucket']['views'][View]['#data']>;
+    query<View extends keyof $['#bucket']['views'], Raw extends Omit<QueryRaw<$>, '$'>>(raw: Raw): Promise<$['#bucket']['views'][View]['#data']>;
+    create(raw: Omit<CreateRaw<$>, '$'>): Promise<$['#bucket']['#data']>;
+    update(raw: Omit<UpdateRaw<$>, '$'>): Promise<$['#bucket']['#data']>;
+    delete(raw: Omit<DeleteRaw<$>, '$'>): Promise<void>;
+    private consumeRaw;
+}
+export {};

package/lib/engine/transaction/nodes/resource.trx_node.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceTrxNode = void 0;
+const trx_node_1 = require("../trx_node");
+class ResourceTrxNode {
+    constructor(trx, resource) {
+        this.trx = trx;
+        this.resource = resource;
+    }
+    async forward(message) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'forward', message);
+        let response;
+        try {
+            response = await this.resource.consume(trx, message);
+        }
+        catch (e) {
+            await trx_node_1.TrxNode.error(trx, e);
+            throw e;
+        }
+        await trx_node_1.TrxNode.ok(trx, response);
+        return response;
+    }
+    async run(raw) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'run', raw);
+        return this.consumeRaw(trx, raw);
+    }
+    async view(raw) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'view', raw);
+        const inRaw = Object.assign({}, raw);
+        inRaw.$ = `${this.resource.schema.name}.view`;
+        return this.consumeRaw(trx, inRaw);
+    }
+    async query(raw) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'query', raw);
+        const inRaw = Object.assign({}, raw);
+        inRaw.$ = `${this.resource.schema.name}.query`;
+        return this.consumeRaw(trx, inRaw);
+    }
+    async create(raw) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'create', raw);
+        const inRaw = Object.assign({}, raw);
+        inRaw.$ = `${this.resource.schema.name}.create`;
+        return this.consumeRaw(trx, inRaw);
+    }
+    async update(raw) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'update', raw);
+        const inRaw = Object.assign({}, raw);
+        inRaw.$ = `${this.resource.schema.name}.update`;
+        return this.consumeRaw(trx, inRaw);
+    }
+    async delete(raw) {
+        const trx = trx_node_1.TrxNode.makeChildNode(this.trx, this.resource.schema.module, 'resource', this.resource.schema.name);
+        await trx_node_1.TrxNode.open(trx, 'delete', raw);
+        const inRaw = Object.assign({}, raw);
+        inRaw.$ = `${this.resource.schema.name}.delete`;
+        await this.consumeRaw(trx, inRaw);
+    }
+    async consumeRaw(trx, message) {
+        let response;
+        try {
+            response = await this.resource.consumeRaw(trx, message);
+        }
+        catch (e) {
+            await trx_node_1.TrxNode.error(trx, e);
+            throw e;
+        }
+        await trx_node_1.TrxNode.ok(trx, response);
+        return response;
+    }
+}
+exports.ResourceTrxNode = ResourceTrxNode;

package/lib/engine/transaction/trx.d.ts

@@ -0,0 +1,50 @@
+import { $Module, $Space } from "../../schema";
+import { Module } from '../module';
+import { AnyTrxNode, TrxNode, TrxNodeStatus } from './trx_node';
+import { TrxEngineOrigin } from './trx_engine';
+import { AnyUsers } from '../auth/authn';
+import { NesoiDatetime } from '../data/datetime';
+type TrxOrigin = TrxEngineOrigin | `trx:${string}`;
+type TrxState = 'open' | 'ok' | 'error';
+export declare class TrxStatus<Output> {
+    id: string;
+    origin: TrxOrigin;
+    start: NesoiDatetime;
+    end?: NesoiDatetime | undefined;
+    state?: TrxState | undefined;
+    output?: Output | undefined;
+    error?: string | undefined;
+    nodes: TrxNodeStatus[];
+    constructor(id: string, origin: TrxOrigin, start: NesoiDatetime, end?: NesoiDatetime | undefined, state?: TrxState | undefined, output?: Output | undefined, error?: string | undefined, nodes?: TrxNodeStatus[]);
+    summary(): string;
+}
+export declare class Trx<S extends $Space, M extends $Module, Authn extends AnyUsers> {
+    private module;
+    id: string;
+    private origin;
+    root: TrxNode<S, M, Authn>;
+    nodes: Record<string, TrxNode<S, M, Authn>>;
+    start: NesoiDatetime;
+    end?: NesoiDatetime;
+    ctx: Record<string, any>;
+    constructor(module: Module<S, M>, origin: TrxOrigin, users?: Authn, id?: string, root?: TrxNode<S, M, Authn>, nodes?: Record<string, TrxNode<S, M, Authn>>);
+    addNode(node: TrxNode<S, M, Authn>): void;
+    status(): TrxStatus<any>;
+    /**
+     * Context Manipulation
+     *
+     * This should only be used by custom adapters to inject/read custom things
+     * to the transaction. Elements should not modify the transaction.
+     */
+    static get<T>(node: AnyTrxNode, key: string): T;
+    /**
+     * Context Manipulation
+     *
+     * This should only be used by custom adapters to inject/read custom things
+     * to the transaction. Elements should not modify the transaction.
+     */
+    static set(node: AnyTrxNode, key: string, value: any): AnyTrx;
+    static onFinish(trx: AnyTrx): void;
+}
+export type AnyTrx = Trx<any, any, any>;
+export {};

package/lib/engine/transaction/trx.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trx = exports.TrxStatus = void 0;
+const trx_node_1 = require("./trx_node");
+const string_1 = require("../util/string");
+const log_1 = require("../util/log");
+const datetime_1 = require("../data/datetime");
+/*
+    Transaction Status
+*/
+class TrxStatus {
+    constructor(id, origin, start, end, state, output, error, nodes = []) {
+        this.id = id;
+        this.origin = origin;
+        this.start = start;
+        this.end = end;
+        this.state = state;
+        this.output = output;
+        this.error = error;
+        this.nodes = nodes;
+    }
+    summary() {
+        const state = this.state ? (0, string_1.colored)(`[${this.state}]`, {
+            'open': 'lightblue',
+            'ok': 'lightgreen',
+            'error': 'lightred'
+        }[this.state]) : 'unknown';
+        let str = `${state} ${this.id} ${(0, log_1.anyScopeTag)(this.origin)} `;
+        str += (0, string_1.colored)(`[${this.end ? (this.end.epoch - this.start.epoch) : -1}ms]\n`, 'brown');
+        function print(nodes, l = 1) {
+            let str = '';
+            nodes.forEach(node => {
+                const state = node.state ? (0, string_1.colored)(`[${node.state}]`, {
+                    'open': 'lightblue',
+                    'ok': 'lightgreen',
+                    'error': 'lightred'
+                }[node.state] || 'lightred') : 'unknown';
+                str += `${'-'.repeat(l)}${state} ${node.id} ${(0, log_1.anyScopeTag)(node.scope)} ${node.action}`;
+                str += (0, string_1.colored)(` [${node.app}ms]\n`, 'brown');
+                str += print(node.nodes, l + 1);
+            });
+            return str;
+        }
+        return str + print(this.nodes);
+    }
+}
+exports.TrxStatus = TrxStatus;
+class Trx {
+    constructor(module, origin, users, id, root, nodes) {
+        this.start = datetime_1.NesoiDatetime.now();
+        this.ctx = {};
+        this.module = module;
+        this.id = id || (Math.random() + 1).toString(36).substring(7);
+        this.origin = origin;
+        this.root = root || new trx_node_1.TrxNode('root', this, undefined, module, users, id);
+        this.nodes = nodes || {};
+    }
+    addNode(node) {
+        const nodeId = node.id;
+        this.nodes[nodeId] = node;
+    }
+    status() {
+        const state = this.root.state;
+        const output = this.root.output;
+        const error = this.root.error;
+        return new TrxStatus(this.id, this.origin, this.start, this.end, state, output, error, this.root.status().nodes);
+    }
+    /**
+     * Context Manipulation
+     *
+     * This should only be used by custom adapters to inject/read custom things
+     * to the transaction. Elements should not modify the transaction.
+     */
+    static get(node, key) {
+        const trx = node.trx;
+        return trx.ctx[key];
+    }
+    /**
+     * Context Manipulation
+     *
+     * This should only be used by custom adapters to inject/read custom things
+     * to the transaction. Elements should not modify the transaction.
+     */
+    static set(node, key, value) {
+        const trx = node.trx;
+        trx.ctx[key] = value;
+        return trx;
+    }
+    //
+    static onFinish(trx) {
+        trx.end = datetime_1.NesoiDatetime.now();
+    }
+}
+exports.Trx = Trx;

package/lib/engine/transaction/trx_engine.config.d.ts

@@ -0,0 +1,15 @@
+import { $Module, $Space } from "../../elements";
+import { BucketAdapter } from "../../elements/entities/bucket/adapters/bucket_adapter";
+import { AnyTrx, Trx } from './trx';
+import { AnyUsers } from '../auth/authn';
+import { TrxNode, TrxNodeStatus } from './trx_node';
+export type TrxEngineWrapFn<S extends $Space, M extends $Module> = (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>;
+export type TrxEngineConfig<S extends $Space, M extends $Module, Authn extends AnyUsers, Providers extends Record<string, any>> = {
+    /**
+     * Adapter used to store transactions of this module.
+     */
+    adapter?: (schema: M) => BucketAdapter<AnyTrx>;
+    trx?: {
+        wrap?: <T extends Trx<S, M, Authn>>(trx: T, fn: TrxEngineWrapFn<S, M>, providers: Providers) => Promise<any>;
+    };
+};

package/lib/engine/transaction/trx_engine.config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/engine/transaction/trx_engine.d.ts

@@ -0,0 +1,27 @@
+import { $Module, $Space } from "../../schema";
+import { Module } from '../module';
+import { Trx } from './trx';
+import { TrxNode, TrxNodeStatus } from './trx_node';
+import { AnyAuthnProviders, AnyUsers, AuthnRequest } from '../auth/authn';
+import { TrxEngineConfig } from './trx_engine.config';
+export type TrxEngineOrigin = `app:${string}`;
+export declare class TrxEngine<S extends $Space, M extends $Module, Authn extends AnyAuthnProviders> {
+    private origin;
+    private module;
+    private authnProviders?;
+    private config?;
+    private providers;
+    /**
+     * Transaction used to read/write transactions on the adapter
+     */
+    private innerTrx;
+    private adapter;
+    constructor(origin: TrxEngineOrigin, module: Module<S, M>, authnProviders?: Authn | undefined, config?: TrxEngineConfig<S, M, any, any> | undefined, providers?: Record<string, any>);
+    getModule(): Module<S, M>;
+    get(id?: string, users?: AnyUsers): Promise<Trx<S, M, any>>;
+    trx(fn: (trx: TrxNode<S, M, any>) => Promise<TrxNodeStatus>, authn?: AuthnRequest<keyof Authn>): Promise<import("./trx").TrxStatus<any>>;
+    private authenticate;
+    private commit;
+    private rollback;
+}
+export type AnyTrxEngine = TrxEngine<any, any, any>;

package/lib/engine/transaction/trx_engine.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrxEngine = void 0;
+const log_1 = require("../util/log");
+const trx_1 = require("./trx");
+const trx_node_1 = require("./trx_node");
+const error_1 = require("../data/error");
+const memory_bucket_adapter_1 = require("../../elements/entities/bucket/adapters/memory.bucket_adapter");
+/*
+    Transaction Engine
+*/
+class TrxEngine {
+    constructor(origin, module, authnProviders, config, providers = {}) {
+        this.origin = origin;
+        this.module = module;
+        this.authnProviders = authnProviders;
+        this.config = config;
+        this.providers = providers;
+        this.innerTrx = new trx_1.Trx(this.module, `trx:${origin}`);
+        this.adapter = config?.adapter?.(module.schema) || new memory_bucket_adapter_1.MemoryBucketAdapter({}, {});
+    }
+    getModule() {
+        return this.module;
+    }
+    async get(id, users) {
+        let trx = undefined;
+        if (!id) {
+            trx = new trx_1.Trx(this.module, this.origin, users);
+            log_1.Log.info('module', this.module.name, `Begin ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+            return this.adapter.put(this.innerTrx.root, trx);
+        }
+        else {
+            trx = await this.adapter.get(this.innerTrx.root, id);
+            if (trx) {
+                log_1.Log.info('module', this.module.name, `Continue ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+            }
+            else {
+                log_1.Log.info('module', this.module.name, `Chain ${(0, log_1.scopeTag)('trx', id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+                trx = new trx_1.Trx(this.module, this.origin, users, id);
+                return this.adapter.put(this.innerTrx.root, trx);
+            }
+        }
+        return trx;
+    }
+    async trx(fn, authn) {
+        const users = authn ? await this.authenticate(authn) : undefined;
+        const trx = await this.get(undefined, users);
+        try {
+            let output;
+            if (this.config?.trx?.wrap) {
+                output = await this.config?.trx?.wrap(trx, fn, this.providers);
+            }
+            else {
+                output = await fn(trx.root);
+            }
+            await this.commit(trx, output);
+        }
+        catch (e) {
+            await this.rollback(trx, e);
+        }
+        return trx.status();
+    }
+    // authentication
+    async authenticate(request) {
+        if (!this.authnProviders) {
+            throw error_1.NesoiError.Authn.NoProvidersRegisteredForModule(this.module.name);
+        }
+        const users = {};
+        for (const provider in request) {
+            const token = request[provider];
+            if (!(provider in this.authnProviders)) {
+                throw error_1.NesoiError.Authn.NoProviderRegisteredForModule(this.module.name, provider);
+            }
+            users[provider] = await this.authnProviders[provider].authenticate(token);
+        }
+        return users;
+    }
+    //
+    async commit(trx, output) {
+        log_1.Log.info('module', this.module.name, `Commit ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+        await trx_node_1.TrxNode.ok(trx.root, output);
+        trx_1.Trx.onFinish(trx);
+        await this.adapter.put(this.innerTrx.root, trx);
+        return trx;
+    }
+    async rollback(trx, error) {
+        log_1.Log.error('module', this.module.name, `[${error.status}] ${error.toString()}`, error.stack);
+        log_1.Log.warn('module', this.module.name, `Rollback ${(0, log_1.scopeTag)('trx', trx.id)} @ ${(0, log_1.anyScopeTag)(this.origin)}`);
+        await trx_node_1.TrxNode.error(trx.root, error);
+        trx_1.Trx.onFinish(trx);
+        await this.adapter.put(this.innerTrx.root, trx);
+        return trx;
+    }
+}
+exports.TrxEngine = TrxEngine;

package/lib/engine/transaction/trx_node.d.ts

@@ -0,0 +1,61 @@
+import { $Module, $Space } from "../../schema";
+import { AnyModule, VirtualModuleDef } from '../module';
+import { AnyTrx } from './trx';
+import { BucketTrxNode } from './nodes/bucket.trx_node';
+import { JobTrxNode } from './nodes/job.trx_node';
+import { QueueTrxNode } from './nodes/queue.trx_node';
+import { ResourceTrxNode } from './nodes/resource.trx_node';
+import { $Message } from "../../elements/entities/message/message.schema";
+import { MachineTrxNode } from './nodes/machine.trx_node';
+import { AnyUsers } from '../auth/authn';
+import { Enum } from "../../elements/entities/constants/constants";
+import { KeysOfUnion } from '../util/type';
+type TrxNodeBlock = 'bucket' | 'message' | 'job' | 'resource' | 'machine' | 'queue' | 'controller';
+export type TrxNodeStatus = {
+    id: string;
+    scope: 'root' | `${string}::${TrxNodeBlock}:${string}` | `${string}::virtual`;
+    state?: string;
+    action?: string;
+    input?: Record<string, any>;
+    output?: Record<string, any>;
+    error?: string;
+    nodes: TrxNodeStatus[];
+    app: number;
+};
+export declare class TrxNode<Space extends $Space, M extends $Module, Authn extends AnyUsers> {
+    private scope;
+    private trx;
+    private parent;
+    private module;
+    private users?;
+    id: string;
+    globalId: string;
+    private children;
+    private state?;
+    private action?;
+    private input?;
+    private output?;
+    private error?;
+    private time;
+    constructor(scope: 'root' | `${string}::${TrxNodeBlock}:${string}` | `${string}::virtual`, trx: AnyTrx, parent: AnyTrxNode | undefined, module: AnyModule, users?: Authn | undefined, id?: string);
+    static open(node: AnyTrxNode, action: string, input: Record<string, any>): Promise<void>;
+    static ok(node: AnyTrxNode, output?: Record<string, any>): Promise<void>;
+    static error(node: AnyTrxNode, error: any): Promise<void>;
+    message<Raw extends M['#input']['#raw'], Msg extends $Message = M['messages'][Raw['$'] & keyof M['messages']]>(raw: Raw): Promise<M['#input']['#parsed']>;
+    value<K extends keyof M['constants']['values']>(key: K): M["constants"]["values"][K]["value"];
+    enum<EnumName extends KeysOfUnion<Space['modules'][keyof Space['modules']]['constants']['enums']>>(name: EnumName): Enum<M['constants']['enums'][EnumName]>;
+    bucket<Name extends keyof M['buckets'], Bucket extends M['buckets'][Name]>(name: Name): BucketTrxNode<M, Bucket>;
+    job<Name extends keyof M['jobs'], Job extends M['jobs'][Name]>(name: Name): JobTrxNode<M, Job>;
+    static jobWithCustomCtx<M extends $Module, JobName extends keyof M['jobs'], Job extends M['jobs'][JobName]>(node: AnyTrxNode, name: string, ctx?: Record<string, any>): JobTrxNode<M, Job>;
+    resource<Name extends keyof M['resources'], Resource extends M['resources'][Name]>(name: Name): ResourceTrxNode<M, Resource>;
+    machine<Name extends keyof M['machines'], Machine extends M['machines'][Name]>(name: Name): MachineTrxNode<M, Machine>;
+    queue<Name extends keyof M['queues'], Queue extends M['queues'][Name]>(name: Name): QueueTrxNode<M, Queue>;
+    user<U extends keyof Authn & keyof M['#authn']>(provider: U): M['#authn'][U];
+    virtual<T>(def: VirtualModuleDef, fn: ($: AnyTrxNode) => T | Promise<T>): Promise<T>;
+    status(): TrxNodeStatus;
+    static makeChildNode<Space extends $Space, M extends $Module, Authn extends AnyUsers>(node: TrxNode<Space, M, Authn>, module: string, block: TrxNodeBlock, name: string): TrxNode<Space, M, Authn>;
+    static makeVirtualChildNode<Space extends $Space, M extends $Module, Authn extends AnyUsers>(node: TrxNode<Space, M, Authn>, module: AnyModule): TrxNode<Space, M, Authn>;
+    static getModule(node: TrxNode<any, any, any>): AnyModule;
+}
+export type AnyTrxNode = TrxNode<any, any, any>;
+export {};