nesoi 3.0.0

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockBuilder = void 0;
+const message_template_field_builder_1 = require("../entities/message/template/message_template_field.builder");
+const message_builder_1 = require("../entities/message/message.builder");
+const dependency_1 = require("../../engine/dependency");
+const name_helpers_1 = require("../../compiler/helpers/name_helpers");
+class BlockBuilder {
+    constructor(module, type, name) {
+        this.module = module;
+        this.type = type;
+        this.name = name;
+        this._authn = [];
+        // References to all inline nodes, set during builder declaration (before build)
+        this._inlineNodes = [];
+        this._inputMsgs = [];
+    }
+    /** Block "human" name */
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    // Inline Messages
+    /**
+     * Inline messages. These messages are exposed to the module,
+     * with a name prefixed by the block name.
+     * @param def Example: `$ => { msg1: { prop1: $.int, prop2: $.string }, msg2: { prop3: $.boolean } }`
+     * @returns
+     */
+    messages(def) {
+        const builder = new message_template_field_builder_1.MessageTemplateFieldFactory(this.module);
+        const schema = def(builder);
+        for (const key in schema) {
+            const name = `${this.name}${key.length ? ('.' + key) : ''}`;
+            const builder = new message_builder_1.MessageBuilder(this.module, name)
+                .template(() => schema[key]);
+            this._inlineNodes.push(new dependency_1.BuilderNode({
+                module: this.module,
+                type: 'message',
+                name,
+                builder,
+                isInline: true,
+                filepath: [], // This is added later by Treeshake.blockInlineNodes()
+                dependencies: [] // This is added later by Treeshake.*()
+            }));
+        }
+        return this;
+    }
+    // Authentication
+    authn(...providers) {
+        if (!Array.isArray(providers)) {
+            providers = [providers];
+        }
+        this._authn = providers;
+        return this;
+    }
+    // Input/Output
+    _input(...names) {
+        this._inputMsgs = names.map((name) => {
+            const fullName = name_helpers_1.NameHelpers.unabbrevName(name, this.name);
+            return new dependency_1.$Dependency(this.module, 'message', fullName);
+        });
+        return this;
+    }
+    outputRaw() {
+        return this;
+    }
+    outputMsg(...msgs) {
+        var _a;
+        this._output ?? (this._output = {});
+        (_a = this._output).msg ?? (_a.msg = []);
+        msgs.forEach(msg => {
+            this._output?.msg?.push(new dependency_1.$Dependency(this.module, 'message', msg, true));
+        });
+        return this;
+    }
+    outputObj(...objs) {
+        var _a;
+        this._output ?? (this._output = {});
+        (_a = this._output).obj ?? (_a.obj = []);
+        objs.forEach(obj => {
+            this._output?.obj?.push(new dependency_1.$Dependency(this.module, 'bucket', obj, true));
+        });
+        return this;
+    }
+}
+exports.BlockBuilder = BlockBuilder;

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

@@ -0,0 +1,15 @@
+import { $Module, $Space, MessageName, RawMessageInput } from "../../schema";
+import { $Block, $BlockType } from './block.schema';
+import { Message } from "../entities/message/message";
+import { Module } from "../../engine/module";
+import { TrxNode } from "../../engine/transaction/trx_node";
+export declare abstract class Block<S extends $Space, M extends $Module, $ extends $Block> {
+    type: $BlockType;
+    module: Module<S, M>;
+    schema: $;
+    constructor(type: $BlockType, module: Module<S, M>, schema: $);
+    consumeRaw(trx: TrxNode<S, M, $['#authn']>, raw: RawMessageInput<M, MessageName<M>>, ctx?: Record<string, any>): Promise<$['#output']>;
+    consume(trx: TrxNode<S, M, $['#authn']>, msg: Message<any>, ctx?: Record<string, any>): Promise<$['#output']>;
+    protected abstract run(trx: TrxNode<S, M, $['#authn']>, msg: Message<any>, ctx?: Record<string, any>): Promise<any>;
+}
+export type AnyBlock = Block<any, any, any>;

package/lib/elements/blocks/block.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = void 0;
+const log_1 = require("../../engine/util/log");
+const error_1 = require("../../engine/data/error");
+class Block {
+    constructor(type, module, schema) {
+        this.type = type;
+        this.module = module;
+        this.schema = schema;
+        if (schema.$t !== type) {
+            throw error_1.NesoiError.Block.InvalidSchema({ name: schema.name, type: schema.$t, expectedType: type });
+        }
+    }
+    async consumeRaw(trx, raw, ctx) {
+        log_1.Log.debug('trx', trx.globalId, `${(0, log_1.scopeTag)(this.type, this.schema.name)} Consume Raw`, raw);
+        if (!raw.$) {
+            throw error_1.NesoiError.Message.NoType({ raw });
+        }
+        if (typeof raw.$ !== 'string') {
+            throw error_1.NesoiError.Message.InvalidType({ type: raw.$ });
+        }
+        if (!this.schema.input.some(dep => dep.tag === `${this.module.name}::message:${raw.$}`)) {
+            throw error_1.NesoiError.Block.MessageNotSupported({ block: this.schema.name, message: raw.$ });
+        }
+        const msg = (await trx.message(raw));
+        return this.run(trx, msg, ctx);
+    }
+    async consume(trx, msg, ctx) {
+        log_1.Log.debug('trx', trx.globalId, `${(0, log_1.scopeTag)(this.type, this.schema.name)} Consume`, msg);
+        if (!this.schema.input.some(dep => dep.module === this.module.name && dep.name === msg.$)) {
+            throw error_1.NesoiError.Block.MessageNotSupported({ block: this.schema.name, message: msg.$ });
+        }
+        return this.run(trx, msg, ctx);
+    }
+}
+exports.Block = Block;

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

@@ -0,0 +1,23 @@
+import { TypeAsObj } from "../../compiler/elements/element";
+import { $Message } from "../entities/message/message.schema";
+import { AnyUsers } from "../../engine/auth/authn";
+import { $Dependency } from "../../engine/dependency";
+export type $BlockType = 'job' | 'resource' | 'machine' | 'queue';
+export type $BlockOutput = {
+    raw?: TypeAsObj;
+    msg?: $Dependency[];
+    obj?: $Dependency[];
+};
+export declare class $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    input: $Dependency[];
+    output?: $BlockOutput | undefined;
+    $t: $BlockType;
+    '#authn': AnyUsers;
+    '#input': $Message;
+    '#output': unknown;
+    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], output?: $BlockOutput | undefined);
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Block = void 0;
+class $Block {
+    constructor(module, name, alias, authn, input, output) {
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.input = input;
+        this.output = output;
+        this.$t = 'block';
+    }
+}
+exports.$Block = $Block;

package/lib/elements/blocks/externals/externals.builder.d.ts

@@ -0,0 +1,30 @@
+import { $Space } from "../../../schema";
+import { $Externals } from './externals.schema';
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { MergeUnion } from "../../../engine/util/type";
+type MergeAllBuckets<Space extends $Space, Module extends keyof Space['modules'], Modules extends $Space['modules'] = Space['modules']> = MergeUnion<{
+    [M in keyof Modules]: {
+        [B in keyof Modules[M]['buckets'] as `${M & string}::${B & string}`]: Modules[M]['buckets'][B];
+    };
+}[keyof Modules]>;
+type ExternalBucketRefName<Space extends $Space, M extends keyof Space['modules'], AllBuckets = MergeAllBuckets<Space, M>> = Exclude<keyof AllBuckets, `${M & string}::${string}` | `${string}::${string}::${string}`>;
+export declare class ExternalsBuilder<Space extends $Space, ModuleName extends keyof Space['modules']> {
+    private module;
+    $b: "externals";
+    name: string;
+    private buckets;
+    private jobs;
+    private machines;
+    constructor(module: string);
+    bucket<M extends keyof Space['modules'], B extends ExternalBucketRefName<Space, ModuleName>>(ref: B): this;
+    job<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['jobs']>(ref: `${M & string}::${B & string}`): this;
+    machine<M extends Exclude<keyof Space['modules'], ModuleName>, B extends keyof Space['modules'][M]['machines']>(ref: `${M & string}::${B & string}`): this;
+    static merge(to: AnyExternalsBuilder, from: AnyExternalsBuilder): void;
+    static build(node: ExternalsBuilderNode): $Externals;
+}
+export type AnyExternalsBuilder = ExternalsBuilder<any, any>;
+export type ExternalsBuilderNode = ResolvedBuilderNode & {
+    builder: AnyExternalsBuilder;
+    schema?: $Externals;
+};
+export {};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExternalsBuilder = void 0;
+const externals_schema_1 = require("./externals.schema");
+const dependency_1 = require("../../../engine/dependency");
+class ExternalsBuilder {
+    constructor(module) {
+        this.module = module;
+        this.$b = 'externals';
+        this.name = '*';
+        this.buckets = {};
+        this.jobs = {};
+        this.machines = {};
+    }
+    bucket(ref) {
+        this.buckets[ref] = new dependency_1.$Dependency(this.module, 'bucket', ref);
+        return this;
+    }
+    job(ref) {
+        this.jobs[ref] = new dependency_1.$Dependency(this.module, 'job', ref);
+        return this;
+    }
+    machine(ref) {
+        this.machines[ref] = new dependency_1.$Dependency(this.module, 'machine', ref);
+        return this;
+    }
+    static merge(to, from) {
+        Object.assign(to.buckets, from.buckets);
+        Object.assign(to.jobs, from.jobs);
+    }
+    // Build
+    static build(node) {
+        node.schema = new externals_schema_1.$Externals(node.module, node.builder.buckets, node.builder.jobs, node.builder.machines);
+        return node.schema;
+    }
+}
+exports.ExternalsBuilder = ExternalsBuilder;

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

@@ -0,0 +1,11 @@
+import { $Dependency } from "../../../engine/dependency";
+export declare class $Externals {
+    name: string;
+    buckets: Record<string, $Dependency>;
+    jobs: Record<string, $Dependency>;
+    machines: Record<string, $Dependency>;
+    $t: "externals";
+    module: string;
+    constructor(name: string, buckets?: Record<string, $Dependency>, jobs?: Record<string, $Dependency>, machines?: Record<string, $Dependency>);
+    static merge(to: $Externals, from: $Externals): void;
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Externals = void 0;
+class $Externals {
+    constructor(name, buckets = {}, jobs = {}, machines = {}) {
+        this.name = name;
+        this.buckets = buckets;
+        this.jobs = jobs;
+        this.machines = machines;
+        this.$t = 'externals';
+        this.module = this.name;
+    }
+    static merge(to, from) {
+        Object.assign(to.buckets, from.buckets);
+        Object.assign(to.jobs, from.jobs);
+        Object.assign(to.machines, from.machines);
+    }
+}
+exports.$Externals = $Externals;

package/lib/elements/blocks/job/internal/machine_job.builder.d.ts

@@ -0,0 +1,52 @@
+import { $Module, $Space } from "../../../../schema";
+import { $Job, $JobAssert, $JobMethod } from '../job.schema';
+import { TrxNode } from "../../../../engine/transaction/trx_node";
+import { BlockBuilder } from '../../block.builder';
+import { $Dependency, ResolvedBuilderNode } from "../../../../engine/dependency";
+import { Overlay } from "../../../../engine/util/type";
+export declare class MachineJobBuilder<Space extends $Space, Module extends $Module, Name extends string, Job extends $Job = $Job, Ctx = {}> extends BlockBuilder<Space, Module, 'job'> {
+    protected module: string;
+    protected name: Name;
+    private alias;
+    protected _authn: string[];
+    protected _inputMsgs: $Dependency[];
+    $b: "job";
+    $j: "MachineJob";
+    private _extrasAndAsserts;
+    private _method?;
+    private machine;
+    constructor(module: string, name: Name, alias: string, _authn?: string[], _inputMsgs?: $Dependency[]);
+    /**
+     * A function that will build new fields on the input message to be
+     * consumed by the job.
+     *
+     * @param $ A function which returns an object to be assigned to the input.
+     */
+    extra<Extra extends {
+        [_: string]: any;
+    }, Trx = NoInfer<TrxNode<Space, Module, Job['#authn']>>, Msg = NoInfer<Job['#input']['#parsed']>, PreviousExtras = NoInfer<Job['#extra']>, C = NoInfer<Ctx>>($: $JobMethod<Trx, Msg, Extra, PreviousExtras, C>): MachineJobBuilder<Space, Module, Name, Overlay<Job, {
+        "#extra": Job["#extra"] & Extra;
+    }>, Ctx>;
+    /**
+     * A function that checks a given condition over the input and throws an exception;
+     * This assertion runs before the job method.
+     *
+     * @param { cond } A function which returns true or false
+     * @param { error } An error message or a function that makes one
+     */
+    assert<Trx = NoInfer<TrxNode<Space, Module, Job['#authn']>>, Msg = NoInfer<Job['#input']['#parsed']>, Extras = NoInfer<Job['#extra']>, C = NoInfer<Ctx>>(condition: $JobAssert<Trx, Msg, Extras, Ctx>): this;
+    /**
+     * The function called when the job is run.
+     *
+     * @param action A function which returns one of the output messages or the response message
+     */
+    method<Trx = NoInfer<TrxNode<Space, Module, Job['#authn']>>, Msg = NoInfer<Job['#input']['#parsed']>, Extras = NoInfer<Job['#extra']>, C = NoInfer<Ctx>>(action: $JobMethod<Trx, Msg, any, Extras, C>): this;
+    /** Build */
+    static build(node: MachineJobBuilderNode, input: $Dependency[]): $Job;
+}
+export type AnyMachineJobBuilder = MachineJobBuilder<any, any, any, any, any>;
+export type MachineJobDef<S extends $Space, M extends $Module, Name extends string, Job extends $Job, Ctx = {}> = ($: MachineJobBuilder<S, M, Name, Job, Ctx>) => void;
+export type MachineJobBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
+    builder: AnyMachineJobBuilder;
+    schema?: $Job;
+};

package/lib/elements/blocks/job/internal/machine_job.builder.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachineJobBuilder = void 0;
+const job_schema_1 = require("../job.schema");
+const block_builder_1 = require("../../block.builder");
+const error_1 = require("../../../../engine/data/error");
+/*
+    Job created inside a machine definition
+*/
+class MachineJobBuilder extends block_builder_1.BlockBuilder {
+    constructor(module, name, alias, _authn = [], _inputMsgs = []) {
+        super(module, 'job', name);
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this._authn = _authn;
+        this._inputMsgs = _inputMsgs;
+        this.$b = 'job';
+        this.$j = 'MachineJob';
+        this._extrasAndAsserts = [];
+        this.machine = name.split('@')[0];
+    }
+    /*
+        Extra
+    */
+    /**
+     * A function that will build new fields on the input message to be
+     * consumed by the job.
+     *
+     * @param $ A function which returns an object to be assigned to the input.
+     */
+    extra($) {
+        this._extrasAndAsserts.push({ extra: $ });
+        return this;
+    }
+    /*
+        Assert
+    */
+    /**
+     * A function that checks a given condition over the input and throws an exception;
+     * This assertion runs before the job method.
+     *
+     * @param { cond } A function which returns true or false
+     * @param { error } An error message or a function that makes one
+     */
+    assert(condition) {
+        this._extrasAndAsserts.push({ assert: condition });
+        return this;
+    }
+    /*
+        Action
+    */
+    /**
+     * The function called when the job is run.
+     *
+     * @param action A function which returns one of the output messages or the response message
+     */
+    method(action) {
+        this._method = action;
+        return this;
+    }
+    /** Build */
+    static build(node, input) {
+        if (!node.builder._method) {
+            throw error_1.NesoiError.Builder.Job.NoMethod({ job: node.builder.name });
+        }
+        node.schema = new job_schema_1.$Job(node.builder.module, node.builder.name, node.builder.alias || node.builder.name, node.builder._authn, [...node.builder._inputMsgs, ...input], {}, node.builder._extrasAndAsserts, node.builder._method, {
+            module: node.builder.module,
+            machine: node.builder.machine
+        });
+        return node.schema;
+    }
+}
+exports.MachineJobBuilder = MachineJobBuilder;

package/lib/elements/blocks/job/internal/machine_job.schema.d.ts

@@ -0,0 +1,5 @@
+export declare class $MachineJobScope {
+    module: string;
+    machine: string;
+    constructor(module: string, machine: string);
+}

package/lib/elements/blocks/job/internal/machine_job.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$MachineJobScope = void 0;
+class $MachineJobScope {
+    constructor(module, machine) {
+        this.module = module;
+        this.machine = machine;
+    }
+}
+exports.$MachineJobScope = $MachineJobScope;

package/lib/elements/blocks/job/internal/resource_job.builder.d.ts

@@ -0,0 +1,109 @@
+import { $Module, $Space } from "../../../../schema";
+import { AnyUsers } from "../../../../engine/auth/authn";
+import { $Job, $JobAssert, $JobMethod } from '../job.schema';
+import { MessageTemplateFieldBuilder } from "../../../entities/message/template/message_template_field.builder";
+import { $MessageInfer } from "../../../entities/message/message.infer";
+import { $Message } from "../../../entities/message/message.schema";
+import { MessageTemplateDef } from "../../../entities/message/template/message_template.builder";
+import { TrxNode } from "../../../../engine/transaction/trx_node";
+import { ModuleTree } from "../../../../engine/tree";
+import { BlockBuilder } from '../../block.builder';
+import { ResolvedBuilderNode } from "../../../../engine/dependency";
+import { AnyQuery } from "../../../entities/bucket/query/nql.schema";
+import { $Bucket } from "../../../entities/bucket/bucket.schema";
+import { $BlockOutput } from '../../block.schema';
+export type ResourceAssertions<Bucket extends $Bucket> = {
+    'query is empty': AnyQuery<any, any>;
+    'has no link': keyof Bucket['graph']['links'];
+};
+export type ResourceAssertionDef<Bucket extends $Bucket> = <T extends keyof ResourceAssertions<Bucket>>(type: T, arg: ResourceAssertions<Bucket>[T]) => boolean;
+export declare class ResourceJobBuilder<Space extends $Space, Module extends $Module, Name extends string, Prepared, Authn extends AnyUsers = {}, Bucket extends $Bucket = never, ImplicitInput = {}, Trigger extends $Message = never, MsgExtras = {}, Ctx = {}, CtxAfter = {}> extends BlockBuilder<Space, Module, 'job'> {
+    protected module: string;
+    protected name: Name;
+    protected bucket: string;
+    protected method: 'view' | 'query' | 'create' | 'update' | 'delete';
+    private alias;
+    private execMethod?;
+    protected _authn: string[];
+    private implicitFields;
+    $b: "job";
+    $j: "ResourceJob";
+    private resource;
+    private _msg;
+    private _customInput;
+    private _extrasAndAsserts;
+    private _prepareMethod;
+    private _afterMethod?;
+    constructor(module: string, name: Name, bucket: string, method: 'view' | 'query' | 'create' | 'update' | 'delete', alias: string, execMethod?: $JobMethod<any, any, any, any> | undefined, _authn?: string[], implicitFields?: Record<string, [string, any]>);
+    /**
+     * The input message accepted by the job.
+     *
+     * @param def A `$ => ({})` definition for a custom trigger message
+     */
+    input<Def extends MessageTemplateDef<Space, Module, Name>>(def: Def): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, ImplicitInput, $MessageInfer<Name, any, ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': ImplicitInput[K];
+    }, any, [never, never], [never, never]>; }, import("../../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': ImplicitInput[K];
+    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': ImplicitInput[K];
+    }, any, [never, never], [never, never]>; } extends infer T ? { [K_1 in keyof T]: (ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': ImplicitInput[K];
+    }, any, [never, never], [never, never]>; })[K_1] extends MessageTemplateFieldBuilder<any, any, infer I, any, any, infer Opt extends [undefined, undefined], infer Nul extends [null, null]> ? {
+        path: `${K_1 & string}${keyof I & string}`;
+        data: I[keyof I];
+        opt: Opt[0];
+        nul: Nul[0];
+    } : never; } : never>, import("../../../entities/message/message.infer").$MessageOutputInfer<ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': ImplicitInput[K];
+    }, any, [never, never], [never, never]>; }, ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': ImplicitInput[K];
+    }, any, [never, never], [never, never]>; } extends infer T_1 ? { [K_2 in keyof T_1]: (ReturnType<Def> & { [K in keyof ImplicitInput]: MessageTemplateFieldBuilder<any, any, any, {
+        '': ImplicitInput[K];
+    }, any, [never, never], [never, never]>; })[K_2] extends MessageTemplateFieldBuilder<any, any, any, infer O, any, infer Opt_1 extends [undefined, undefined], infer Nul_1 extends [null, null]> ? {
+        path: `${K_2 & string}${keyof O & string}`;
+        data: O[keyof O];
+        opt: Opt_1[1];
+        nul: Nul_1[1];
+    } : never; } : never>>, MsgExtras, Ctx, CtxAfter>;
+    /**
+     * A function that will build new fields on the input message to be
+     * consumed by the job.
+     *
+     * @param $ A function which returns an object to be assigned to the input.
+     */
+    extra<Extra extends {
+        [_: string]: any;
+    }, Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, PreviousExtras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>($: $JobMethod<Trx, Msg, Extra, PreviousExtras, C>): ResourceJobBuilder<Space, Module, Name, Prepared, Authn, Bucket, ImplicitInput, Trigger, MsgExtras & Extra, Ctx, CtxAfter>;
+    /**
+     * A function that checks a given condition over the input and throws an exception;
+     * This assertion runs before the job method.
+     *
+     * @param { cond } A function which returns true or false
+     * @param { error } An error message or a function that makes one
+     */
+    assert<Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<Ctx & {
+        that: ResourceAssertionDef<Bucket>;
+    }>>(condition: $JobAssert<Trx, Msg, Extras, C>): this;
+    /**
+     * The function called to prepare the input for the job.
+     *
+     * @param method A function which returns the required output.
+     */
+    prepare<Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<Ctx>>(method: $JobMethod<Trx, Msg, Prepared, Extras, C>): this;
+    /**
+     * The function called after the input has been processed.
+     *
+     * @param method A function which returns void.
+     */
+    after<Trx = NoInfer<TrxNode<Space, Module, Authn>>, Msg = NoInfer<Trigger['#parsed']>, Extras = NoInfer<MsgExtras>, C = NoInfer<CtxAfter>>(method: $JobMethod<Trx, Msg, void, Extras, C>): this;
+    static build(node: ResourceJobBuilderNode, tree: ModuleTree, module: $Module, output: $BlockOutput, defaultTrigger: $Message, idType?: 'string' | 'int' | null): {
+        schema: $Job;
+        inlineMessages: Record<string, $Message>;
+    };
+}
+export type AnyResourceJobBuilder = ResourceJobBuilder<any, any, any, any, any, any>;
+export type ResourceJobDef<S extends $Space, M extends $Module, Name extends string, Prepared, Authn extends AnyUsers, Bucket extends $Bucket, DefaultTrigger extends $Message = never, ImplicitInput = {}, Ctx = {}, CtxAfter = {}> = ($: ResourceJobBuilder<S, M, Name, Prepared, Authn, Bucket, ImplicitInput, DefaultTrigger, {}, Ctx, CtxAfter>) => any;
+export type ResourceJobBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
+    builder: AnyResourceJobBuilder;
+    schema?: $Job;
+};