nesoi 3.0.0

package/lib/elements/blocks/machine/machine.builder.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachineBuilder = void 0;
+const machine_schema_1 = require("./machine.schema");
+const machine_state_builder_1 = require("./machine_state.builder");
+const block_builder_1 = require("../block.builder");
+const job_builder_1 = require("../job/job.builder");
+const dependency_1 = require("../../../engine/dependency");
+const message_builder_1 = require("../../entities/message/message.builder");
+const machine_transition_builder_1 = require("./machine_transition.builder");
+class MachineBuilder extends block_builder_1.BlockBuilder {
+    constructor(module, name) {
+        super(module, 'machine', name);
+        this.$b = 'machine';
+        this._buckets = [];
+        this._states = {};
+    }
+    /* [Block] */
+    authn(...providers) {
+        return super.authn(...providers);
+    }
+    messages(def) {
+        return super.messages(def);
+    }
+    /* [Data] */
+    bucket(names) {
+        names = Array.isArray(names) ? names : [names];
+        this._buckets = names.map(name => new dependency_1.$Dependency(this.module, 'bucket', name));
+        return this;
+    }
+    stateField(key) {
+        this._stateField = key;
+        return this;
+    }
+    stateAliasField(key) {
+        this._stateAliasField = key;
+        return this;
+    }
+    /* The machine nodes */
+    state(name, $) {
+        const builder = new machine_state_builder_1.MachineStateBuilder(this, this.module, name, Object.values(this._states).length === 0);
+        if ($) {
+            $(builder);
+        }
+        this._states[name] = builder;
+        return this;
+        // return this as unknown as MachineBuilder<Space, Module, Name, $ & {
+        //     states: {
+        //         [K in Name]: TMachineState<{ path: Name }>
+        //     }
+        // }>;
+    }
+    logger($) {
+        this._logger = $;
+        return this;
+    }
+    /* Build */
+    static build(node, tree, module) {
+        const states = {};
+        const transitions = {
+            from: {},
+            to: {}
+        };
+        // Build substates
+        for (const key in node.builder._states) {
+            const childBuilder = node.builder._states[key];
+            const child = machine_state_builder_1.MachineStateBuilder.build(childBuilder);
+            Object.assign(states, child.states);
+            machine_transition_builder_1.MachineTransitionBuilder.merge(transitions, child.transitions);
+        }
+        // Asign unique inputs to states based on transitions to that state
+        Object.entries(transitions.to)
+            .forEach(([state, msgTransitions]) => {
+            Object.values(msgTransitions)
+                .flat(1)
+                .forEach(t => {
+                if (!states[state].input.some(dep => dep.tag === t.msg.tag)) {
+                    states[state].input.push(t.msg);
+                }
+            });
+        });
+        const input = Object.values(states)
+            .map(state => state.input)
+            .flat(1);
+        node.schema = new machine_schema_1.$Machine(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, input, node.builder._buckets, node.builder._stateField || 'state', states, transitions, node.builder._stateAliasField, node.builder._logger);
+        // Configure state jobs with proper input, based on transition targets
+        const inlineJobsConfig = {};
+        Object.values(states).forEach(state => {
+            const transFrom = transitions.from[state.name] || {};
+            const inputLeave = [];
+            Object.values(transFrom)
+                .flat(1)
+                .filter($t => !inputLeave.some(dep => dep.tag === $t.msg.tag))
+                .forEach($t => inputLeave.push($t.msg));
+            const transTo = transitions.to[state.name] || {};
+            const inputEnter = [];
+            Object.values(transTo)
+                .flat(1)
+                .filter($t => !inputEnter.some(dep => dep.tag === $t.msg.tag))
+                .forEach($t => inputEnter.push($t.msg));
+            state.inputEnter = inputEnter;
+            state.inputLeave = inputLeave;
+            if (state.jobs.beforeEnter) {
+                inlineJobsConfig[state.jobs.beforeEnter.name] = {
+                    MachineJob: { input: inputEnter }
+                };
+            }
+            if (state.jobs.afterEnter) {
+                inlineJobsConfig[state.jobs.afterEnter.name] = {
+                    MachineJob: { input: inputEnter }
+                };
+            }
+            if (state.jobs.beforeLeave) {
+                inlineJobsConfig[state.jobs.beforeLeave.name] = {
+                    MachineJob: { input: inputLeave }
+                };
+            }
+            if (state.jobs.afterLeave) {
+                inlineJobsConfig[state.jobs.afterLeave.name] = {
+                    MachineJob: { input: inputLeave }
+                };
+            }
+        });
+        const { inlineJobs, nestedInlineMessages } = job_builder_1.JobBuilder.buildInlines(node, tree, module, inlineJobsConfig);
+        return {
+            schema: node.schema,
+            inlineMessages: {
+                ...message_builder_1.MessageBuilder.buildInlines(node, tree, module),
+                ...nestedInlineMessages
+            },
+            inlineJobs
+        };
+    }
+}
+exports.MachineBuilder = MachineBuilder;

package/lib/elements/blocks/machine/machine.d.ts

@@ -0,0 +1,86 @@
+import { $Module, $Space } from "../../../schema";
+import { $Machine } from './machine.schema';
+import { Module } from "../../../engine/module";
+import { Block } from '../block';
+import { TrxNode } from "../../../engine/transaction/trx_node";
+import { AnyMessage } from "../../entities/message/message";
+import { NesoiObjId } from "../../../engine/data/obj";
+export declare const MachineOutputCode: {
+    info: {
+        msg_received: string;
+        state_changed: string;
+        state_not_changed: string;
+        job_returned_message: string;
+        job_unmet_condition: string;
+        job_from_transition: string;
+    };
+    warn: {
+        no_transition_found: string;
+        no_transition_run: string;
+    };
+};
+export declare class MachineOutputEntry<Type = string, Code = string, Text = string, Data = any> {
+    type: Type;
+    code: Code;
+    text: Text;
+    data: Data;
+    constructor(type: Type, code: Code, text: Text, data: Data);
+    static info_msg_received(msg: AnyMessage, state: string, obj: Record<string, any>): MachineOutputEntry<"info", "msg_received", `Message '${string}' received at state '${string}'`, {
+        msg: AnyMessage;
+        state: string;
+        obj: Record<string, any>;
+    }>;
+    static info_state_changed(from: string, to: string): MachineOutputEntry<"info", "state_changed", `State changed from '${string}' to '${string}'`, {
+        from: string;
+        to: string;
+    }>;
+    static info_state_not_changed(from: string): MachineOutputEntry<"info", "state_not_changed", `State didn't change, remains at '${string}'`, {
+        from: string;
+    }>;
+    static info_job_returned_message(job: string, msg: AnyMessage): MachineOutputEntry<"info", "job_returned_message", `Job '${string}' returned a message '${string}', which was added to the machine queue`, {
+        job: string;
+        msg: AnyMessage;
+    }>;
+    static info_job_from_state(job: string, state: string): MachineOutputEntry<"info", "job_from_state", `Job '${string}' ran for state '${string}'`, {
+        job: string;
+        state: string;
+    }>;
+    static info_unmet_condition(transition: string, error: string): MachineOutputEntry<"info", "unmet_condition", `Transition '${string}' condition failed: '${string}'`, {
+        transition: string;
+        error: string;
+    }>;
+    static info_job_from_transition(job: string, transition: string): MachineOutputEntry<"info", "job_from_transition", `Job '${string}' ran from transition '${string}'`, {
+        job: string;
+        transition: string;
+    }>;
+    static warn_no_transition_found(state: string, msg: string): MachineOutputEntry<"warn", "no_transition_found", `No transition found for state '${string}' and message '${string}'`, {
+        state: string;
+        msg: string;
+    }>;
+    static warn_no_transition_run(state: string): MachineOutputEntry<"warn", "no_transition_run", `No transition from state '${string}' passes the assertions`, {
+        state: string;
+    }>;
+}
+export declare class MachineOutput {
+    entries: MachineOutputEntry[];
+    constructor(entries?: MachineOutputEntry[]);
+    static add(output: MachineOutput, ...entries: MachineOutputEntry[]): void;
+    summary(): string;
+    jobs(): MachineOutputEntry<string, string, string, any>[];
+}
+export declare class Machine<S extends $Space, M extends $Module, $ extends $Machine> extends Block<S, M, $> {
+    module: Module<S, M>;
+    schema: $;
+    constructor(module: Module<S, M>, schema: $);
+    protected run(trx: TrxNode<S, M, $['#authn']>, msg: AnyMessage & {
+        id: NesoiObjId;
+    }): Promise<MachineOutput>;
+    protected _run(trx: TrxNode<S, M, $['#authn']>, _msg: AnyMessage & {
+        id: NesoiObjId;
+    }): Promise<{
+        obj: Record<string, any>;
+        output: MachineOutput;
+    }>;
+    private runStateJob;
+}
+export type AnyMachine = Machine<any, any, any>;

package/lib/elements/blocks/machine/machine.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Machine = exports.MachineOutput = exports.MachineOutputEntry = exports.MachineOutputCode = void 0;
+const block_1 = require("../block");
+const trx_node_1 = require("../../../engine/transaction/trx_node");
+const message_1 = require("../../entities/message/message");
+const error_1 = require("../../../engine/data/error");
+const string_1 = require("../../../engine/util/string");
+const log_1 = require("../../../engine/util/log");
+exports.MachineOutputCode = {
+    'info': {
+        'msg_received': 'Message received',
+        'state_changed': 'State changed',
+        'state_not_changed': 'State didn\'t change',
+        'job_returned_message': 'Job returned a message, which will be sent back to the machine',
+        'job_unmet_condition': 'A condition of the job was not met',
+        'job_from_transition': 'A job was run for the transition',
+    },
+    'warn': {
+        'no_transition_found': 'No matching transition was found',
+        'no_transition_run': 'No transition matched the required conditions to run',
+    }
+};
+class MachineOutputEntry {
+    constructor(type, code, text, data) {
+        this.type = type;
+        this.code = code;
+        this.text = text;
+        this.data = data;
+    }
+    static info_msg_received(msg, state, obj) {
+        return new MachineOutputEntry('info', 'msg_received', `Message '${msg.$}' received at state '${state}'`, { msg, state, obj });
+    }
+    static info_state_changed(from, to) {
+        return new MachineOutputEntry('info', 'state_changed', `State changed from '${from}' to '${to}'`, { from, to });
+    }
+    static info_state_not_changed(from) {
+        return new MachineOutputEntry('info', 'state_not_changed', `State didn't change, remains at '${from}'`, { from });
+    }
+    static info_job_returned_message(job, msg) {
+        return new MachineOutputEntry('info', 'job_returned_message', `Job '${job}' returned a message '${msg.$}', which was added to the machine queue`, { job, msg });
+    }
+    static info_job_from_state(job, state) {
+        return new MachineOutputEntry('info', 'job_from_state', `Job '${job}' ran for state '${state}'`, { job, state });
+    }
+    static info_unmet_condition(transition, error) {
+        return new MachineOutputEntry('info', 'unmet_condition', `Transition '${transition}' condition failed: '${error}'`, { transition, error });
+    }
+    static info_job_from_transition(job, transition) {
+        return new MachineOutputEntry('info', 'job_from_transition', `Job '${job}' ran from transition '${transition}'`, { job, transition });
+    }
+    static warn_no_transition_found(state, msg) {
+        return new MachineOutputEntry('warn', 'no_transition_found', `No transition found for state '${state}' and message '${msg}'`, { state, msg });
+    }
+    static warn_no_transition_run(state) {
+        return new MachineOutputEntry('warn', 'no_transition_run', `No transition from state '${state}' passes the assertions`, { state });
+    }
+}
+exports.MachineOutputEntry = MachineOutputEntry;
+class MachineOutput {
+    constructor(entries = []) {
+        this.entries = entries;
+    }
+    static add(output, ...entries) {
+        output.entries.push(...entries);
+    }
+    summary() {
+        let str = '\n';
+        this.entries.forEach(entry => {
+            const pad = ' '.repeat(Math.max(5 - entry.type.length, 0));
+            const color = {
+                'info': 'lightpurple',
+                'warn': 'yellow',
+                'job': 'lightblue',
+                'state': 'lightgreen'
+            }[entry.type] || 'lightred';
+            const type = entry.type ? (0, string_1.colored)(`[${entry.type}]`, color) : 'unknown';
+            str += `- ${type}${pad} ${(0, string_1.colored)(entry.code, color)}\n`;
+            str += `    ${(0, string_1.colored)(entry.text, 'lightgray')}\n`;
+        });
+        return str;
+    }
+    jobs() {
+        return this.entries.filter(entry => entry.type === 'job');
+    }
+}
+exports.MachineOutput = MachineOutput;
+class Machine extends block_1.Block {
+    constructor(module, schema) {
+        super('machine', module, schema);
+        this.module = module;
+        this.schema = schema;
+    }
+    async run(trx, msg) {
+        const { obj, output } = await this._run(trx, msg);
+        if (this.schema.logger) {
+            try {
+                await this.schema.logger({
+                    trx,
+                    schema: this.schema,
+                    obj,
+                    output
+                });
+            }
+            catch (e) {
+                log_1.Log.error('machine', this.schema.name, 'Logger failed.', {
+                    error: e.toString(),
+                    stack: e.stack
+                });
+            }
+        }
+        return output;
+    }
+    async _run(trx, _msg) {
+        const output = new MachineOutput();
+        const msg = message_1.Message.clone(_msg);
+        const ctx = { trx, msg };
+        if (!msg.id) {
+            throw error_1.NesoiError.Machine.MessageHasNoId(this.schema.alias);
+        }
+        // Read data from bucket
+        let bucketUsed;
+        let obj;
+        for (const bucket of this.schema.buckets) {
+            obj = await trx.bucket(bucket.refName).readOne(msg.id);
+            if (obj) {
+                bucketUsed = bucket;
+                break;
+            }
+        }
+        if (!obj) {
+            throw error_1.NesoiError.Machine.ObjNotFound(this.schema.alias, msg.id);
+        }
+        // Get current state
+        const stateName = obj[this.schema.stateField];
+        if (!stateName) {
+            throw error_1.NesoiError.Machine.StateNotFound(this.schema.alias, msg.id);
+        }
+        const state = this.schema.states[stateName];
+        if (!state) {
+            throw error_1.NesoiError.Machine.StateNotFound(this.schema.alias, msg.id);
+        }
+        MachineOutput.add(output, MachineOutputEntry.info_msg_received(msg, state.name, obj));
+        // Find list of transitions for given state and message
+        const transitions = this.schema.transitions.from[stateName]?.[msg.$];
+        if (!transitions?.length) {
+            MachineOutput.add(output, MachineOutputEntry.warn_no_transition_found(state.name, msg.$));
+            return { obj, output };
+        }
+        const queue = [];
+        // Run "beforeLeave" job of current state
+        await this.runStateJob(trx, output, queue, state.jobs.beforeLeave, msg, obj, state.name, undefined, 'before_leave', `Ran job '${state.jobs.beforeLeave?.name}' before leaving '${state.name}'`);
+        // Try each transition until one works
+        let nextState;
+        let nextMsg;
+        for (const transition of transitions) {
+            // Transition condition [ .if() ]
+            if (transition.condition) {
+                const conditionResult = await transition.condition(ctx);
+                // Condition not met, save message as info and try next transition
+                if (conditionResult !== true) {
+                    MachineOutput.add(output, MachineOutputEntry.info_unmet_condition(transition.name, conditionResult));
+                    continue;
+                }
+            }
+            // Condition passed, run this transition
+            // Get next state
+            const nextStateName = transition.to;
+            nextState = this.schema.states[nextStateName];
+            if (!state) {
+                throw error_1.NesoiError.Machine.StateNotFound(this.schema.alias, msg.id);
+            }
+            // Run all transition jobs
+            for (const job of transition.jobs) {
+                await trx_node_1.TrxNode.jobWithCustomCtx(trx, job.refName, {
+                    obj,
+                    from: state.name,
+                    to: nextState.name
+                }).forward(msg);
+                MachineOutput.add(output, MachineOutputEntry.info_job_from_transition(job.tag, transition.name));
+            }
+            // Run "beforeEnter" job of next state
+            await this.runStateJob(trx, output, queue, nextState.jobs.beforeEnter, msg, obj, state.name, nextState.name, 'before_enter', `Ran job '${nextState.jobs.beforeEnter?.name}' before entering '${nextState.name}'`);
+            // Change object state to new state and save
+            // TODO: log object changes
+            obj[this.schema.stateField] = nextState.name;
+            if (this.schema.stateAliasField) {
+                obj[this.schema.stateAliasField] = nextState.alias;
+            }
+            obj = await trx.bucket(bucketUsed.refName).put(obj);
+            if (nextStateName !== stateName) {
+                MachineOutput.add(output, MachineOutputEntry.info_state_changed(state.name, nextState.name));
+            }
+            else {
+                MachineOutput.add(output, MachineOutputEntry.info_state_not_changed(state.name));
+            }
+            // Run "afterLeave" job of previous state (which was the current until now)
+            await this.runStateJob(trx, output, queue, state.jobs.afterLeave, msg, obj, state.name, state.name, 'after_leave', `Ran job '${state.jobs.afterLeave?.name}' after leaving '${state.name}'`);
+            // Run "afterEnter" job of current state (which was the next until now)
+            await this.runStateJob(trx, output, queue, nextState.jobs.afterEnter, msg, obj, state.name, nextState.name, 'after_enter', `Ran job '${nextState.jobs.afterEnter?.name}' after entering '${nextState.name}'`);
+        }
+        // No transition run, 
+        if (!nextState) {
+            MachineOutput.add(output, MachineOutputEntry.warn_no_transition_run(state.name));
+        }
+        // TODO: queue nextMsg
+        if (nextMsg) {
+            // ...
+        }
+        return { obj, output };
+    }
+    async runStateJob(trx, output, queue, job, msg, obj, from, to, code, text) {
+        if (!job) {
+            return;
+        }
+        const result = await trx_node_1.TrxNode.jobWithCustomCtx(trx, job.refName, {
+            obj,
+            from,
+            to
+        }).forward(msg);
+        MachineOutput.add(output, MachineOutputEntry.info_job_from_state(job.tag, from));
+        if (result instanceof message_1.Message) {
+            queue.push(result);
+            MachineOutput.add(output, MachineOutputEntry.info_job_returned_message(job.tag, result));
+        }
+    }
+}
+exports.Machine = Machine;

package/lib/elements/blocks/machine/machine.schema.d.ts

@@ -0,0 +1,85 @@
+import { $Block } from "../block.schema";
+import { $JobAssert } from "../job/job.schema";
+import { $Dependency } from "../../../engine/dependency";
+import { AnyTrxNode } from "../../../engine/transaction/trx_node";
+import { MachineOutput } from './machine';
+export declare class $MachineTransition extends $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    msg: $Dependency;
+    from: string;
+    to: string;
+    condition?: $JobAssert<any, any, never, any> | undefined;
+    jobs: $Dependency[];
+    $t: any;
+    constructor(module: string, name: string, alias: string, authn: string[], msg: $Dependency, from: string, to: string, condition?: $JobAssert<any, any, never, any> | undefined, jobs?: $Dependency[]);
+}
+export type $MachineTransitions = {
+    from: {
+        [state: string]: {
+            [msg: string]: $MachineTransition[];
+        };
+    };
+    to: {
+        [state: string]: {
+            [msg: string]: $MachineTransition[];
+        };
+    };
+};
+export declare class $MachineState extends $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    initial: boolean;
+    final: boolean;
+    inputEnter: $Dependency[];
+    inputLeave: $Dependency[];
+    jobs: {
+        beforeEnter?: $Dependency;
+        afterEnter?: $Dependency;
+        beforeLeave?: $Dependency;
+        afterLeave?: $Dependency;
+    };
+    $t: any;
+    '#input.enter': any;
+    '#input.leave': any;
+    constructor(module: string, name: string, alias: string, authn: string[], initial: boolean, final: boolean, inputEnter: $Dependency[], inputLeave: $Dependency[], jobs: {
+        beforeEnter?: $Dependency;
+        afterEnter?: $Dependency;
+        beforeLeave?: $Dependency;
+        afterLeave?: $Dependency;
+    });
+}
+export type $MachineStates = {
+    [x: string]: $MachineState;
+};
+export declare class $Machine extends $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    input: $Dependency[];
+    buckets: $Dependency[];
+    stateField: string;
+    states: $MachineStates;
+    transitions: $MachineTransitions;
+    stateAliasField?: string | undefined;
+    logger?: $MachineLogFn<any> | undefined;
+    $t: "machine";
+    '#data': unknown;
+    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], buckets: $Dependency[], stateField: string, states: $MachineStates, transitions: $MachineTransitions, stateAliasField?: string | undefined, logger?: $MachineLogFn<any> | undefined);
+}
+export declare class $MachineJobScope {
+    module: string;
+    machine: string;
+    constructor(module: string, machine: string);
+}
+export type $MachineLogFn<M extends $Machine = $Machine> = (ctx: {
+    trx: AnyTrxNode;
+    schema: M;
+    obj: M['#data'];
+    output: MachineOutput;
+}) => any | Promise<any>;

package/lib/elements/blocks/machine/machine.schema.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$MachineJobScope = exports.$Machine = exports.$MachineState = exports.$MachineTransition = void 0;
+const block_schema_1 = require("../block.schema");
+// Transition
+class $MachineTransition extends block_schema_1.$Block {
+    constructor(module, name, alias, authn, msg, from, to, condition, jobs = []) {
+        super(module, name, alias, authn, [msg], {});
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.msg = msg;
+        this.from = from;
+        this.to = to;
+        this.condition = condition;
+        this.jobs = jobs;
+        this.$t = 'machine.transition';
+    }
+}
+exports.$MachineTransition = $MachineTransition;
+// State
+class $MachineState extends block_schema_1.$Block {
+    constructor(module, name, alias, authn, initial, final, inputEnter, inputLeave, jobs) {
+        super(module, name, alias, authn, [...inputEnter, ...inputLeave], {});
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.initial = initial;
+        this.final = final;
+        this.inputEnter = inputEnter;
+        this.inputLeave = inputLeave;
+        this.jobs = jobs;
+        this.$t = 'machine.state';
+    }
+}
+exports.$MachineState = $MachineState;
+// Machine
+class $Machine extends block_schema_1.$Block {
+    constructor(module, name, alias, authn, input, buckets, stateField, states, transitions, stateAliasField, logger) {
+        super(module, name, alias, authn, input, {});
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.input = input;
+        this.buckets = buckets;
+        this.stateField = stateField;
+        this.states = states;
+        this.transitions = transitions;
+        this.stateAliasField = stateAliasField;
+        this.logger = logger;
+        this.$t = 'machine';
+    }
+}
+exports.$Machine = $Machine;
+class $MachineJobScope {
+    constructor(module, machine) {
+        this.module = module;
+        this.machine = machine;
+    }
+}
+exports.$MachineJobScope = $MachineJobScope;

package/lib/elements/blocks/machine/machine_state.builder.d.ts

@@ -0,0 +1,58 @@
+import { $Module, $Space, ScopedMessageNameWithId } from "../../../schema";
+import { $Machine, $MachineState, $MachineStates, $MachineTransition, $MachineTransitions } from './machine.schema';
+import { MachineTransitionDef } from './machine_transition.builder';
+import { Overlay } from "../../../engine/util/type";
+import { BlockBuilder } from '../block.builder';
+import { $Job } from '../job/job.schema';
+import { AnyMachineBuilder } from './machine.builder';
+import { MachineJobDef } from '../job/internal/machine_job.builder';
+export declare class MachineStateBuilder<S extends $Space, M extends $Module, $M extends $Machine, $ extends $MachineState = $MachineState> extends BlockBuilder<S, M, 'machine'> {
+    private machine;
+    private _initial;
+    private _transitions;
+    private _states;
+    private _final;
+    constructor(machine: AnyMachineBuilder, module: string, name: string, _initial?: boolean);
+    private _jobs;
+    as(alias: string): this;
+    final(): this;
+    beforeEnter<Def extends MachineJobDef<S, M, `${$['name']}__before_enter`, Overlay<$Job, {
+        '#input': $['#input.enter'];
+    }>, {
+        obj: $M['#data'];
+        from: $M['transitions']['to'][$['name']][keyof $M['transitions']['to'][$['name']]][number]['from'];
+        to: $M['transitions']['to'][$['name']][keyof $M['transitions']['from'][$['name']]][number]['to'];
+    }>>(def: Def): this;
+    afterEnter<Def extends MachineJobDef<S, M, `${$['name']}__after_enter`, Overlay<$Job, {
+        '#input': $['#input.enter'];
+    }>, {
+        obj: $M['#data'];
+        from: $M['transitions']['to'][$['name']][keyof $M['transitions']['to'][$['name']]][number]['from'];
+        to: $M['transitions']['from'][$['name']][keyof $M['transitions']['from'][$['name']]][number]['to'];
+    }>>(def: Def): this;
+    beforeLeave<Def extends MachineJobDef<S, M, `${$['name']}__before_leave`, Overlay<$Job, {
+        '#input': $['#input.leave'];
+    }>, {
+        obj: $M['#data'];
+        from: $M['transitions']['to'][$['name']][keyof $M['transitions']['to'][$['name']]][number]['from'];
+        to: $M['transitions']['from'][$['name']][keyof $M['transitions']['from'][$['name']]][number]['to'];
+    }>>(def: Def): this;
+    afterLeave<Def extends MachineJobDef<S, M, `${$['name']}__after_leave`, Overlay<$Job, {
+        '#input': $['#input.leave'];
+    }>, {
+        obj: $M['#data'];
+        from: $M['transitions']['to'][$['name']][keyof $M['transitions']['to'][$['name']]][number]['from'];
+        to: $M['transitions']['from'][$['name']][keyof $M['transitions']['from'][$['name']]][number]['to'];
+    }>>(def: Def): this;
+    transition<MsgName extends ScopedMessageNameWithId<M, $M['name'], $M['#data']['id' & keyof $M['#data']]>, Def extends MachineTransitionDef<S, M, $M, Overlay<$MachineTransition, {
+        '#input': M['messages'][MsgName extends `@.${infer X}` ? `${$M['name']}.${X}` : MsgName];
+        from: $['name'];
+    }>>>(msg: MsgName, $: Def): this;
+    state<Name extends string, Def extends MachineStateDef<S, M, $M, $M['states'][`${$['name']}.${Name}`]>>(name: Name, $?: Def): this;
+    /** Build */
+    static build(builder: MachineStateBuilder<any, any, any>): {
+        states: $MachineStates;
+        transitions: $MachineTransitions;
+    };
+}
+export type MachineStateDef<S extends $Space, M extends $Module, $M extends $Machine, State extends $MachineState> = ($: MachineStateBuilder<S, M, $M, State>) => any;