nesoi 3.0.0

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachineStateBuilder = void 0;
+const machine_schema_1 = require("./machine.schema");
+const machine_transition_builder_1 = require("./machine_transition.builder");
+const dependency_1 = require("../../../engine/dependency");
+const block_builder_1 = require("../block.builder");
+const name_helpers_1 = require("../../../compiler/helpers/name_helpers");
+const machine_job_builder_1 = require("../job/internal/machine_job.builder");
+class MachineStateBuilder extends block_builder_1.BlockBuilder {
+    constructor(machine, module, name, _initial = false) {
+        super(module, 'machine', name);
+        this.machine = machine;
+        this._initial = _initial;
+        this._transitions = {};
+        this._states = {};
+        this._final = false;
+        this._jobs = {};
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    final() {
+        this._final = true;
+        return this;
+    }
+    beforeEnter(def) {
+        const machineName = this.machine.name;
+        const name = `${machineName}@${this.name}__before_enter`;
+        const builder = new machine_job_builder_1.MachineJobBuilder(this.module, name, `Before Enter ${this._alias || this.name}`, this._authn);
+        def(builder);
+        this._jobs.beforeEnter = new dependency_1.$Dependency(this.module, 'job', name);
+        // Inline nodes are registered on the machine builder,
+        // since a machine state is not a BuilderNode
+        const _inlineNodes = this.machine._inlineNodes;
+        _inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: builder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        return this;
+    }
+    afterEnter(def) {
+        const machineName = this.machine.name;
+        const name = `${machineName}@${this.name}__after_enter`;
+        const builder = new machine_job_builder_1.MachineJobBuilder(this.module, name, `On Enter ${this._alias || this.name}`, this._authn);
+        def(builder);
+        this._jobs.afterEnter = new dependency_1.$Dependency(this.module, 'job', name);
+        // Inline nodes are registered on the machine builder,
+        // since a machine state is not a BuilderNode
+        const _inlineNodes = this.machine._inlineNodes;
+        _inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: builder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        return this;
+    }
+    beforeLeave(def) {
+        const machineName = this.machine.name;
+        const name = `${machineName}@${this.name}__before_leave`;
+        const builder = new machine_job_builder_1.MachineJobBuilder(this.module, name, `Before leave ${this._alias || this.name}`, this._authn);
+        def(builder);
+        this._jobs.beforeLeave = new dependency_1.$Dependency(this.module, 'job', name);
+        // Inline nodes are registered on the machine builder,
+        // since a machine state is not a BuilderNode
+        const _inlineNodes = this.machine._inlineNodes;
+        _inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: builder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        return this;
+    }
+    afterLeave(def) {
+        const machineName = this.machine.name;
+        const name = `${machineName}@${this.name}__after_leave`;
+        const builder = new machine_job_builder_1.MachineJobBuilder(this.module, name, `On leave ${this._alias || this.name}`, this._authn);
+        def(builder);
+        this._jobs.afterLeave = new dependency_1.$Dependency(this.module, 'job', name);
+        // Inline nodes are registered on the machine builder,
+        // since a machine state is not a BuilderNode
+        const _inlineNodes = this.machine._inlineNodes;
+        _inlineNodes.push(new dependency_1.BuilderNode({
+            module: this.module,
+            type: 'job',
+            name: name,
+            builder: builder,
+            isInline: true,
+            filepath: [], // This is added later by Treeshake.blockInlineNodes()
+            dependencies: [] // This is added later by Treeshake.*()
+        }));
+        return this;
+    }
+    transition(msg, $) {
+        const machineName = this.machine.name;
+        const msgName = name_helpers_1.NameHelpers.unabbrevName(msg, machineName);
+        const msgDep = new dependency_1.$Dependency(this.module, 'message', msgName);
+        const builder = new machine_transition_builder_1.MachineTransitionBuilder(this.machine, this.module, this.name, msgDep);
+        $(builder);
+        if (!(msgName in this._transitions)) {
+            this._transitions[msgName] = [];
+        }
+        this._transitions[msgName].push(builder);
+        return this;
+    }
+    state(name, $) {
+        const builder = new MachineStateBuilder(this.machine, this.module, `${this.name}.${name}`, Object.values(this._states).length === 0);
+        if ($) {
+            $(builder);
+        }
+        this._states[name] = builder;
+        return this;
+    }
+    /** Build */
+    static build(builder) {
+        const input = [];
+        // Build all transitions from this state
+        const transitions = {
+            from: {
+                [builder.name]: {}
+            },
+            to: {}
+        };
+        // For each state+message, there's a list of transitions
+        Object.entries(builder._transitions)
+            .forEach(([msgName, msgTransitions]) => {
+            // Here we build each transition of the list
+            const $transitions = msgTransitions
+                .map(trans => machine_transition_builder_1.MachineTransitionBuilder.build(trans))
+                .flat(1);
+            // This list represents all transitions from this state for a given message
+            transitions.from[builder.name][msgName] = $transitions;
+            // Now, for each transition, we find it's target and store the transition to it
+            $transitions.forEach($trans => {
+                if (!($trans.to in transitions.to)) {
+                    transitions.to[$trans.to] = {};
+                }
+                if (!($trans.msg.refName in transitions.to[$trans.to])) {
+                    transitions.to[$trans.to][$trans.msg.refName] = [];
+                }
+                transitions.to[$trans.to][$trans.msg.refName].push($trans);
+                // We also take note of unique transition input messages
+                if (!input.some(dep => dep.tag === $trans.msg.tag)) {
+                    input.push($trans.msg);
+                }
+            });
+        });
+        // Build this state
+        const states = {};
+        states[builder.name] = new machine_schema_1.$MachineState(builder.module, builder.name, builder._alias || builder.name, builder._authn, builder._initial, builder._final, [], // This is filled by the machine (after all transitions are built)
+        [], // This is filled by the machine (after all transitions are built)
+        builder._jobs);
+        // Build substates
+        for (const key in builder._states) {
+            const childBuilder = builder._states[key];
+            const child = MachineStateBuilder.build(childBuilder);
+            // Merge states, transitions, input and inlineNodes
+            Object.assign(states, child.states);
+            machine_transition_builder_1.MachineTransitionBuilder.merge(transitions, child.transitions);
+            Object.values(child.states).forEach(state => {
+                state.input.forEach(msg => {
+                    if (!input.some(dep => dep.tag === msg.tag)) {
+                        input.push(msg);
+                    }
+                });
+            });
+        }
+        // (Inline nodes are registered on the Machine (a state is not a BuilderNode))
+        return { states, transitions };
+    }
+}
+exports.MachineStateBuilder = MachineStateBuilder;

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

@@ -0,0 +1,48 @@
+import { $Module, $Space } from "../../../schema";
+import { $Machine, $MachineTransition, $MachineTransitions } from './machine.schema';
+import { $Job, $JobAssert, $JobMethod } from "../job/job.schema";
+import { TrxNode } from "../../../engine/transaction/trx_node";
+import { $Dependency } from "../../../engine/dependency";
+import { BlockBuilder } from '../block.builder';
+import { $Message } from "../../entities/message/message.schema";
+import { Overlay } from "../../../engine/util/type";
+import { AnyMachineBuilder } from './machine.builder';
+import { MachineJobDef } from '../job/internal/machine_job.builder';
+type JobWithMatchingInput<M extends $Module, Input extends $Message> = {
+    [J in keyof M['jobs']]: Input extends M['jobs'][J]['#input'] ? J : never;
+}[keyof M['jobs']];
+export declare class MachineTransitionBuilder<S extends $Space, M extends $Module, $M extends $Machine, $ extends $MachineTransition = $MachineTransition> extends BlockBuilder<S, M, 'machine'> {
+    private machine;
+    private _from;
+    private _msg;
+    private index;
+    private _condition?;
+    private _else?;
+    private _to?;
+    private _jobs;
+    constructor(machine: AnyMachineBuilder, module: string, _from: string, _msg: $Dependency, index?: number);
+    as(alias: string): this;
+    if<Assert extends $JobAssert<TrxNode<S, M, $M['#authn']>, $['#input']['#parsed'], never, {
+        obj: $M['#data'];
+    }>, Condition extends $JobMethod<TrxNode<S, M, $M['#authn']>, $['#input']['#parsed'], boolean, never, {
+        obj: $M['#data'];
+    }>>(condition: Assert | Condition): this;
+    else<Def extends MachineTransitionDef<S, M, $M, $>>($: Def): this;
+    goTo<To extends keyof $M['states'] | '.'>(target: To): MachineTransitionBuilder<S, M, $M, Overlay<$, {
+        to: To & string;
+    }>>;
+    runJob<Def extends MachineJobDef<S, M, $['name'], Overlay<$Job, {
+        '#input': $['#input'];
+    }>, {
+        obj: $M['#data'];
+        from: $['from'];
+        to: $['to'];
+    }>, Name extends JobWithMatchingInput<M, $['#input']>>(def: Name | Def): this;
+    /** Util */
+    static merge(a: $MachineTransitions, b: $MachineTransitions): void;
+    /** Build */
+    static build(builder: AnyMachineTransitionBuilder): $MachineTransition[];
+}
+export type MachineTransitionDef<S extends $Space, M extends $Module, $M extends $Machine, $ extends $MachineTransition = $MachineTransition> = ($: MachineTransitionBuilder<S, M, $M, $>) => any;
+export type AnyMachineTransitionBuilder = MachineTransitionBuilder<any, any, any, any>;
+export {};

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MachineTransitionBuilder = void 0;
+const machine_schema_1 = require("./machine.schema");
+const dependency_1 = require("../../../engine/dependency");
+const block_builder_1 = require("../block.builder");
+const machine_job_builder_1 = require("../job/internal/machine_job.builder");
+class MachineTransitionBuilder extends block_builder_1.BlockBuilder {
+    constructor(machine, module, _from, _msg, index = 0) {
+        super(module, 'machine', `${_from}~${_msg.refName}`);
+        this.machine = machine;
+        this._from = _from;
+        this._msg = _msg;
+        this.index = index;
+        this._jobs = [];
+    }
+    as(alias) {
+        this._alias = alias;
+        return this;
+    }
+    if(condition) {
+        this._condition = condition;
+        return this;
+    }
+    else($) {
+        const builder = new MachineTransitionBuilder(this.machine, this.module, this._from, this._msg, this.index + 1);
+        $(builder);
+        this._else = builder;
+        return this;
+    }
+    goTo(target) {
+        this._to = target;
+        return this;
+    }
+    runJob(def) {
+        if (typeof def === 'string') {
+            this._jobs.push(new dependency_1.$Dependency(this.module, 'job', def));
+        }
+        else {
+            const machineName = this.machine.name;
+            const name = `${machineName}@${this.name}#${this.index}`;
+            const builder = new machine_job_builder_1.MachineJobBuilder(this.module, name, this._alias || name, this._authn, [this._msg]);
+            def(builder);
+            this._jobs.push(new dependency_1.$Dependency(this.module, 'job', name));
+            // Inline nodes are registered on the machine builder,
+            // since a machine transition is not a BuilderNode
+            const _inlineNodes = this.machine._inlineNodes;
+            _inlineNodes.push(new dependency_1.BuilderNode({
+                module: this.module,
+                type: 'job',
+                name: name,
+                builder: builder,
+                isInline: true,
+                filepath: [], // This is added later by Treeshake.blockInlineNodes()
+                dependencies: [] // This is added later by Treeshake.*()
+            }));
+        }
+        return this;
+    }
+    /** Util */
+    static merge(a, b) {
+        Object.entries(b.from).forEach(([state, group]) => {
+            Object.entries(group).forEach(([msg, transx]) => {
+                if (!(state in a.from)) {
+                    a.from[state] = {};
+                }
+                if (!(msg in a.from[state])) {
+                    a.from[state][msg] = [];
+                }
+                a.from[state][msg].push(...transx);
+            });
+        });
+        Object.entries(b.to).forEach(([state, group]) => {
+            Object.entries(group).forEach(([msg, transx]) => {
+                if (!(state in a.to)) {
+                    a.to[state] = {};
+                }
+                if (!(msg in a.to[state])) {
+                    a.to[state][msg] = [];
+                }
+                a.to[state][msg].push(...transx);
+            });
+        });
+    }
+    /** Build */
+    static build(builder) {
+        const transitions = [];
+        const self = new machine_schema_1.$MachineTransition(builder.module, builder.name, builder._alias || builder.name, builder._authn, builder._msg, builder._from, builder._to || builder._from, builder._condition, builder._jobs);
+        transitions.push(self);
+        if (builder._else) {
+            const others = MachineTransitionBuilder.build(builder._else);
+            transitions.push(...others);
+        }
+        // (Inline nodes are registered on the Machine (a transition is not a BuilderNode))
+        return transitions;
+    }
+}
+exports.MachineTransitionBuilder = MachineTransitionBuilder;

package/lib/elements/blocks/queue/adapters/bucket.queue_adapter.d.ts

@@ -0,0 +1,10 @@
+import { $Module } from "../../../../schema";
+import { QueueAdapter } from './queue_adapter';
+import { AnyMessage } from "../../../entities/message/message";
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+export declare class BucketQueueAdapter<M extends $Module> extends QueueAdapter {
+    protected bucket: keyof M['buckets'];
+    constructor(bucket: keyof M['buckets']);
+    push(trx: AnyTrxNode, message: AnyMessage): Promise<void>;
+    pop(trx: AnyTrxNode): Promise<AnyMessage | undefined>;
+}

package/lib/elements/blocks/queue/adapters/bucket.queue_adapter.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BucketQueueAdapter = void 0;
+const queue_adapter_1 = require("./queue_adapter");
+class BucketQueueAdapter extends queue_adapter_1.QueueAdapter {
+    constructor(bucket) {
+        super();
+        this.bucket = bucket;
+    }
+    async push(trx, message) {
+        return;
+    }
+    async pop(trx) {
+        return undefined;
+    }
+}
+exports.BucketQueueAdapter = BucketQueueAdapter;

package/lib/elements/blocks/queue/adapters/queue_adapter.d.ts

@@ -0,0 +1,6 @@
+import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+import { AnyMessage } from "../../../entities/message/message";
+export declare abstract class QueueAdapter {
+    abstract push(trx: AnyTrxNode, message: AnyMessage): Promise<void>;
+    abstract pop(trx: AnyTrxNode): Promise<AnyMessage | undefined>;
+}

package/lib/elements/blocks/queue/adapters/queue_adapter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueAdapter = void 0;
+class QueueAdapter {
+}
+exports.QueueAdapter = QueueAdapter;

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

@@ -0,0 +1,40 @@
+import { $Module, $Space, ScopedMessage, ScopedMessageName } from "../../../schema";
+import { $Queue } from './queue.schema';
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { BlockBuilder } from '../block.builder';
+import { Overlay } from "../../../engine/util/type";
+import { MultiMessageTemplateDef } from "../../entities/message/template/message_template.builder";
+import { $MessageInfer } from "../../entities/message/message.infer";
+import { ModuleTree } from "../../../engine/tree";
+export declare class QueueBuilder<Space extends $Space, M extends $Module, $ extends $Queue> extends BlockBuilder<Space, M, 'queue'> {
+    $b: "queue";
+    constructor(module: string, name: string);
+    authn<U extends keyof Space['authnUsers']>(...providers: U[]): QueueBuilder<Space, M, $ & {
+        "#authn": U extends any[] ? U[number] : U;
+    }>;
+    messages<Def extends MultiMessageTemplateDef<Space, M>>(def: Def): QueueBuilder<Space, Overlay<M, {
+        messages: Overlay<M["messages"], { [K in keyof ReturnType<Def> as `${string}${K extends "" ? "" : "."}${K & string}`]: $MessageInfer<`${string}${K extends "" ? "" : "."}${K & string}`, ($: any) => ReturnType<Def>[K], ReturnType<Def>[K], import("../../entities/message/message.infer").$MessageInputInfer<ReturnType<Def>[K], ReturnType<Def>[K] extends infer T ? { [K_1 in keyof T]: ReturnType<Def>[K][K_1] extends import("../../entities/message/template/message_template_field.builder").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], ReturnType<Def>[K] extends infer T_1 ? { [K_2 in keyof T_1]: ReturnType<Def>[K][K_2] extends import("../../entities/message/template/message_template_field.builder").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>>; }>;
+    }>, $>;
+    input<MsgName extends ScopedMessageName<M, $['name']>, Msg extends ScopedMessage<M, $['name'], MsgName>>(...def: MsgName[]): QueueBuilder<Space, M, Overlay<$, {
+        "#input": Msg;
+    }>>;
+    static build(node: QueueBuilderNode, tree: ModuleTree, module: $Module): {
+        schema: $Queue;
+        inlineMessages: Record<string, import("../..").$Message>;
+    };
+}
+export type AnyQueueBuilder = QueueBuilder<any, any, any>;
+export type QueueBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
+    builder: AnyQueueBuilder;
+    schema?: $Queue;
+};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueBuilder = void 0;
+const queue_schema_1 = require("./queue.schema");
+const block_builder_1 = require("../block.builder");
+const message_builder_1 = require("../../entities/message/message.builder");
+class QueueBuilder extends block_builder_1.BlockBuilder {
+    constructor(module, name) {
+        super(module, 'queue', name);
+        this.$b = 'queue';
+    }
+    /* [Block] */
+    authn(...providers) {
+        return super.authn(...providers);
+    }
+    messages(def) {
+        return super.messages(def);
+    }
+    input(...def) {
+        return super._input(...def);
+    }
+    // Build
+    static build(node, tree, module) {
+        node.schema = new queue_schema_1.$Queue(node.builder.module, node.builder.name, node.builder._alias || node.builder.name, node.builder._authn, node.builder._inputMsgs);
+        return {
+            schema: node.schema,
+            inlineMessages: message_builder_1.MessageBuilder.buildInlines(node, tree, module)
+        };
+    }
+}
+exports.QueueBuilder = QueueBuilder;

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

@@ -0,0 +1,9 @@
+import { $Module } from "../../../schema";
+import { $Queue } from './queue.schema';
+import { Module } from "../../../engine/module";
+export declare class Queue<M extends $Module, $ extends $Queue> {
+    module: Module<any, M>;
+    schema: $;
+    constructor(module: Module<any, M>, schema: $);
+}
+export type AnyQueue = Queue<any, any>;

package/lib/elements/blocks/queue/queue.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue {
+    // private adapter: QueueAdapter
+    constructor(module, schema) {
+        this.module = module;
+        this.schema = schema;
+    }
+}
+exports.Queue = Queue;

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

@@ -0,0 +1,12 @@
+import { $Dependency } from "../../../engine/dependency";
+import { $Block } from '../block.schema';
+export declare class $Queue extends $Block {
+    module: string;
+    name: string;
+    alias: string;
+    authn: string[];
+    msgs: $Dependency[];
+    $t: "queue";
+    dependencies: $Dependency[];
+    constructor(module: string, name: string, alias: string, authn: string[], msgs: $Dependency[]);
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$Queue = void 0;
+const block_schema_1 = require("../block.schema");
+class $Queue extends block_schema_1.$Block {
+    constructor(module, name, alias, authn, msgs) {
+        super(module, name, alias, authn, msgs, {});
+        this.module = module;
+        this.name = name;
+        this.alias = alias;
+        this.authn = authn;
+        this.msgs = msgs;
+        this.$t = 'queue';
+        this.dependencies = [];
+    }
+}
+exports.$Queue = $Queue;

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

@@ -0,0 +1,60 @@
+import { $Module, $Space } from "../../../schema";
+import { $Resource } from './resource.schema';
+import { ResourceJobDef } from '../job/internal/resource_job.builder';
+import { NesoiObj } from "../../../engine/data/obj";
+import { $Message } from "../../entities/message/message.schema";
+import { BlockBuilder } from '../block.builder';
+import { ModuleTree } from "../../../engine/tree";
+import { $Job } from '../job/job.schema';
+import { ResolvedBuilderNode } from "../../../engine/dependency";
+import { $Bucket } from "../../entities/bucket/bucket.schema";
+import { CreateObj, PatchResourceObj } from "../../entities/bucket/bucket.types";
+import { Overlay } from "../../../engine/util/type";
+import { $MessageInferFromData } from "../../entities/message/message.infer";
+export declare class ResourceBuilder<Space extends $Space, Module extends $Module, Resource extends $Resource> extends BlockBuilder<Space, Module, 'resource'> {
+    $b: "resource";
+    private _jobs;
+    private _bucket;
+    constructor(module: string, name: Resource['name']);
+    authn<U extends keyof Space['authnUsers']>(...providers: U[]): ResourceBuilder<Space, Module, Overlay<Resource, {
+        "#authn": { [K in U]: Space["authnUsers"][U]; };
+    }>>;
+    bucket<B extends keyof Module['buckets']>(name: B): ResourceBuilder<Space, Module, Overlay<Resource, {
+        "#bucket": Module["buckets"][B];
+    }>>;
+    view<ViewName extends keyof Resource['#bucket']['views'] & string>(...views: ViewName[]): this;
+    query<ViewName extends keyof Resource['#bucket']['views'] & string>(...views: ViewName[]): this;
+    create<MsgName extends string = `${Resource['name']}.create`, Bucket extends $Bucket = Resource['#bucket'], DefaultTrigger extends $Message = $MessageInferFromData<MsgName, Omit<Bucket['#data'], 'id'>>, Prepared = CreateObj<Bucket>>($: ResourceJobDef<Space, Module, `${Resource['name']}.create`, Prepared, Resource['#authn'], Bucket, DefaultTrigger, {}, {}, {
+        obj: Bucket['#data'];
+    }>): this;
+    update<MsgName extends string = `${Resource['name']}.update`, Bucket extends $Bucket = Resource['#bucket'], DefaultTrigger extends $Message = $MessageInferFromData<MsgName, Bucket['#data']>, Prepared extends Record<string, any> = Omit<PatchResourceObj<Bucket>, 'id'>>($: ResourceJobDef<Space, Module, MsgName, Prepared, Resource['#authn'], Bucket, DefaultTrigger, {
+        id: Bucket['#data']['id'];
+    }, {
+        obj: Bucket['#data'];
+    }, {
+        obj: Bucket['#data'];
+    }>): this;
+    delete<MsgName extends string = `${Resource['name']}.delete`, Data extends NesoiObj = Resource['#bucket']['#data'], DefaultTrigger extends $Message = $MessageInferFromData<MsgName, {
+        id: Data['id'];
+    }>>($: ResourceJobDef<Space, Module, `${Resource['name']}.delete`, boolean, Resource['#authn'], Resource['#bucket'], DefaultTrigger, {
+        id: Data['id'];
+    }, {
+        obj: Data;
+    }, {
+        obj: Data;
+    }>): this;
+    static build(node: ResourceBuilderNode, tree: ModuleTree, module: $Module): {
+        schema: $Resource;
+        inlineMessages: {
+            [x: string]: $Message;
+        };
+        inlineJobs: {
+            [x: string]: $Job;
+        };
+    };
+}
+export type AnyResourceBuilder = ResourceBuilder<any, any, any>;
+export type ResourceBuilderNode = Omit<ResolvedBuilderNode, 'builder'> & {
+    builder: AnyResourceBuilder;
+    schema?: $Resource;
+};