nesoi 3.0.0

package/lib/engine/dependency.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuilderNode = exports.$Dependency = exports.$Tag = void 0;
+const name_helpers_1 = require("../compiler/helpers/name_helpers");
+class $Tag {
+    static parse(tag) {
+        const match = tag.match(/(.\w*?::)?(\w*?:)?(.*)/);
+        const module = match?.[1]?.slice(0, -2);
+        const type = match?.[2]?.slice(0, -1);
+        const name = match?.[3];
+        if (!match
+            || (module && module.includes(':'))
+            || (type && type.includes(':'))
+            || !name
+            || name.includes(':')) {
+            return;
+        }
+        return { module, type, name };
+    }
+    static parseOrFail(tag) {
+        const match = tag.match(/(.\w*?::)?(\w*?:)?(.*)/);
+        if (!match) {
+            throw new Error(`Internal error: Invalid tag ${tag}`);
+        }
+        const module = match[1]?.slice(0, -2);
+        if (module && module.includes(':')) {
+            throw new Error(`Internal error: Invalid tag ${tag}, module ${module} includes invalid characters`);
+        }
+        const type = match[2]?.slice(0, -1);
+        if (type && type.includes(':')) {
+            throw new Error(`Internal error: Invalid tag ${tag}, type ${type} includes invalid characters`);
+        }
+        const name = match[3];
+        if (!name) {
+            throw new Error(`Internal error: Invalid tag ${tag}, no name specified`);
+        }
+        if (name.includes(':')) {
+            throw new Error(`Internal error: Invalid tag ${tag}, name ${name} includes invalid characters`);
+        }
+        return { module, type, name };
+    }
+}
+exports.$Tag = $Tag;
+class $Dependency {
+    constructor(fromModule, type, name, soft = false) {
+        this.type = type;
+        this.soft = soft;
+        const parsed = $Tag.parseOrFail(name);
+        this.name = parsed.name;
+        if (parsed.module) {
+            this.module = parsed.module;
+        }
+        else {
+            this.module = fromModule;
+        }
+        this.tag = `${this.module}::${this.type}:${this.name}`;
+        if (this.module === fromModule) {
+            this.refName = this.name;
+        }
+        else {
+            this.refName = `${this.module}::${this.name}`;
+        }
+    }
+    static typeName(dep, fromModule) {
+        if (dep.module !== fromModule) {
+            const moduleHigh = name_helpers_1.NameHelpers.nameLowToHigh(dep.module);
+            // WARN: this might break non-regular plural block names in the future
+            const el_t = dep.type + 's';
+            return `${moduleHigh}Module['${el_t}']['${dep.name}']`;
+        }
+        else {
+            return name_helpers_1.NameHelpers
+                .names({ $t: dep.type, name: dep.name })
+                .type;
+        }
+    }
+}
+exports.$Dependency = $Dependency;
+class BuilderNode {
+    constructor($) {
+        this.module = $.module;
+        this.type = $.type;
+        this.name = $.name;
+        this.tag = `${this.module}::${this.type}:${this.name}`;
+        this.isInline = $.isInline;
+        this.filepath = $.filepath;
+        this.dependencies = $.dependencies;
+        this.builder = $.builder;
+    }
+}
+exports.BuilderNode = BuilderNode;

package/lib/engine/module.d.ts

@@ -0,0 +1,97 @@
+import { $Module, $Space } from "../schema";
+import { Machine } from "../elements/blocks/machine/machine";
+import { AnyMessageBuilder } from "../elements/entities/message/message.builder";
+import { AnyBucketBuilder } from "../elements/entities/bucket/bucket.builder";
+import { AnyResourceBuilder } from "../elements/blocks/resource/resource.builder";
+import { AnyMachineBuilder } from "../elements/blocks/machine/machine.builder";
+import { Job } from "../elements/blocks/job/job";
+import { AnyJobBuilder } from "../elements/blocks/job/job.builder";
+import { MessageParser } from "../elements/entities/message/message_parser";
+import { $Message } from "../elements/entities/message/message.schema";
+import { Resource } from "../elements/blocks/resource/resource";
+import { Queue } from "../elements/blocks/queue/queue";
+import { Controller } from "../elements/edge/controller/controller";
+import { Bucket } from "../elements/entities/bucket/bucket";
+import { $Constants } from "../elements/entities/constants/constants.schema";
+import { ConstantsBuilder } from "../elements/entities/constants/constants.builder";
+import { AnyControllerBuilder } from "../elements/edge/controller/controller.builder";
+import { AnyExternalsBuilder } from "../elements/blocks/externals/externals.builder";
+import { $Externals } from "../elements/blocks/externals/externals.schema";
+import { $Dependency, ResolvedBuilderNode } from './dependency';
+import { $Bucket } from "../elements/entities/bucket/bucket.schema";
+import { $Resource } from "../elements/blocks/resource/resource.schema";
+import { $Machine } from "../elements/blocks/machine/machine.schema";
+import { $Controller } from "../elements/edge/controller/controller.schema";
+import { $Job } from "../elements/blocks/job/job.schema";
+import { ModuleTree } from './tree';
+import { AnyResourceJobBuilder } from "../elements/blocks/job/internal/resource_job.builder";
+import { AnyApp } from './apps/app';
+import { AnyMachineJobBuilder } from "../elements/blocks/job/internal/machine_job.builder";
+import { AnyQueueBuilder } from "../elements/blocks/queue/queue.builder";
+import { $Queue } from "../elements/blocks/queue/queue.schema";
+import { NQL_Engine } from "../elements/entities/bucket/query/nql_engine";
+import { AnyDaemon } from './daemon';
+export type AnyBuilder = AnyExternalsBuilder | ConstantsBuilder | AnyMessageBuilder | AnyBucketBuilder | AnyJobBuilder | AnyResourceJobBuilder | AnyMachineJobBuilder | AnyResourceBuilder | AnyMachineBuilder | AnyControllerBuilder | AnyQueueBuilder;
+export type AnyElementSchema = $Externals | $Constants | $Message | $Bucket | $Job | $Resource | $Machine | $Controller | $Queue;
+export type AnyInlineElementSchema = $Message | $Job;
+export type VirtualModuleDef = {
+    name: string;
+    schemas?: {
+        messages?: $Message[];
+        machines?: $Machine[];
+    };
+    externals?: {
+        buckets?: $Dependency[];
+        jobs?: $Dependency[];
+    };
+};
+export declare class Module<S extends $Space, $ extends $Module> {
+    name: string;
+    schema: $;
+    buckets: { [B in keyof $["buckets"]]: Bucket<$, $["buckets"][B]>; };
+    messages: { [B in keyof $["messages"]]: MessageParser<$["messages"][B]>; };
+    jobs: { [B in keyof $["jobs"]]: Job<S, $, $["jobs"][B]>; };
+    resources: { [B in keyof $["resources"]]: Resource<S, $, $["resources"][B]>; };
+    machines: { [B in keyof $["machines"]]: Machine<S, $, $["machines"][B]>; };
+    queues: { [B in keyof $["queues"]]: Queue<$, $["queues"][B]>; };
+    controllers: { [B in keyof $["controllers"]]: Controller<S, $, $["controllers"][B]>; };
+    daemon?: AnyDaemon;
+    nql: NQL_Engine;
+    boot?: {
+        path: string;
+    } | {
+        builders: AnyBuilder[];
+    };
+    constructor(name: string, boot?: {
+        path: string;
+    } | {
+        builders: AnyBuilder[];
+    });
+    info(): void;
+    inject(schemas: {
+        constants?: $Constants;
+        externals?: $Externals;
+        buckets?: $Bucket[];
+        messages?: $Message[];
+        jobs?: $Job[];
+        resources?: $Resource[];
+        machines?: $Machine[];
+        queues?: $Queue[];
+        controllers?: $Controller[];
+    }): this;
+    injectDependencies(daemon: AnyDaemon, dependencies: {
+        buckets?: $Dependency[];
+        jobs?: $Dependency[];
+        messages?: $Dependency[];
+        machines?: $Dependency[];
+    }): this;
+    scanFiles(dir: string, exclude?: string[]): string[];
+    buildNode(node: ResolvedBuilderNode, tree: ModuleTree): Promise<void>;
+    private mergeInlineMessages;
+    private mergeInlineJobs;
+    start(app: AnyApp, providers: Record<string, any>): void;
+    destroy(): void;
+    private destroyBlock;
+    static virtual(module: AnyModule, def: VirtualModuleDef): Promise<Module<$Space, $Module>>;
+}
+export type AnyModule = Module<any, any>;

package/lib/engine/module.js

@@ -0,0 +1,335 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const log_1 = require("./util/log");
+const machine_1 = require("../elements/blocks/machine/machine");
+const message_builder_1 = require("../elements/entities/message/message.builder");
+const bucket_builder_1 = require("../elements/entities/bucket/bucket.builder");
+const resource_builder_1 = require("../elements/blocks/resource/resource.builder");
+const machine_builder_1 = require("../elements/blocks/machine/machine.builder");
+const job_1 = require("../elements/blocks/job/job");
+const job_builder_1 = require("../elements/blocks/job/job.builder");
+const message_parser_1 = require("../elements/entities/message/message_parser");
+const resource_1 = require("../elements/blocks/resource/resource");
+const queue_1 = require("../elements/blocks/queue/queue");
+const controller_1 = require("../elements/edge/controller/controller");
+const bucket_1 = require("../elements/entities/bucket/bucket");
+const constants_schema_1 = require("../elements/entities/constants/constants.schema");
+const constants_builder_1 = require("../elements/entities/constants/constants.builder");
+const controller_builder_1 = require("../elements/edge/controller/controller.builder");
+const externals_builder_1 = require("../elements/blocks/externals/externals.builder");
+const error_1 = require("./data/error");
+const externals_schema_1 = require("../elements/blocks/externals/externals.schema");
+const app_1 = require("./apps/app");
+const queue_builder_1 = require("../elements/blocks/queue/queue.builder");
+const nql_engine_1 = require("../elements/entities/bucket/query/nql_engine");
+const daemon_1 = require("./daemon");
+class Module {
+    constructor(name, boot) {
+        this.name = name;
+        // Schemas built by this module
+        this.schema = {
+            constants: new constants_schema_1.$Constants(this.name),
+            externals: new externals_schema_1.$Externals(this.name),
+            buckets: {},
+            messages: {},
+            jobs: {},
+            resources: {},
+            machines: {},
+            controllers: {},
+            queues: {},
+        };
+        /* Entities */
+        this.buckets = {};
+        this.messages = {};
+        /* Blocks */
+        this.jobs = {};
+        this.resources = {};
+        this.machines = {};
+        this.queues = {};
+        /* Edge */
+        this.controllers = {};
+        this.schema.name = name;
+        this.boot = boot;
+    }
+    info() {
+        log_1.Log.info('module', this.name, 'Loaded', {
+            values: Object.keys(this.schema.constants.values),
+            enums: Object.keys(this.schema.constants.enums),
+            messages: Object.keys(this.messages),
+            buckets: Object.keys(this.buckets),
+            jobs: Object.keys(this.jobs),
+            resources: Object.keys(this.resources),
+            machines: Object.keys(this.machines),
+            controllers: Object.keys(this.controllers),
+            queues: Object.keys(this.queues),
+        });
+    }
+    // Manual injection
+    inject(schemas) {
+        if (schemas.constants) {
+            constants_schema_1.$Constants.merge(this.schema.constants, schemas.constants);
+        }
+        if (schemas.externals) {
+            externals_schema_1.$Externals.merge(this.schema.externals, schemas.externals);
+        }
+        schemas.buckets?.forEach(schema => {
+            this.schema.buckets[schema.name] = schema;
+        });
+        schemas.messages?.forEach(schema => {
+            this.schema.messages[schema.name] = schema;
+        });
+        schemas.jobs?.forEach(schema => {
+            this.schema.jobs[schema.name] = schema;
+        });
+        schemas.resources?.forEach(schema => {
+            this.schema.resources[schema.name] = schema;
+        });
+        schemas.machines?.forEach(schema => {
+            this.schema.machines[schema.name] = schema;
+        });
+        schemas.queues?.forEach(schema => {
+            this.schema.queues[schema.name] = schema;
+        });
+        schemas.controllers?.forEach(schema => {
+            this.schema.controllers[schema.name] = schema;
+        });
+        return this;
+    }
+    injectDependencies(daemon, dependencies) {
+        dependencies.buckets?.forEach(dep => {
+            const bucketModule = daemon_1.Daemon.getModule(daemon, dep.module);
+            const bucket = bucketModule.buckets[dep.name];
+            if (!bucket) {
+                throw new Error(`Internal Error: unable to find bucket '${dep.tag}' during injection to module '${this.name}'`);
+            }
+            this.buckets[dep.refName] = bucket;
+        });
+        dependencies.jobs?.forEach(dep => {
+            const jobModule = daemon_1.Daemon.getModule(daemon, dep.module);
+            const job = jobModule.jobs[dep.name];
+            if (!job) {
+                throw new Error(`Internal Error: unable to find job '${dep.tag}' during injection to module '${this.name}'`);
+            }
+            this.jobs[dep.refName] = job;
+        });
+        dependencies.messages?.forEach(dep => {
+            const messageModule = daemon_1.Daemon.getModule(daemon, dep.module);
+            const message = messageModule.messages[dep.name];
+            if (!message) {
+                throw new Error(`Internal Error: unable to find message '${dep.tag}' during injection to module '${this.name}'`);
+            }
+            this.messages[dep.refName] = message;
+        });
+        dependencies.machines?.forEach(dep => {
+            const machineModule = daemon_1.Daemon.getModule(daemon, dep.module);
+            const machine = machineModule.machines[dep.name];
+            if (!machine) {
+                throw new Error(`Internal Error: unable to find machine '${dep.tag}' during injection to module '${this.name}'`);
+            }
+            this.machines[dep.refName] = machine;
+        });
+        return this;
+    }
+    // Treeshaking
+    scanFiles(dir, exclude = []) {
+        const files = [];
+        fs.readdirSync(dir, { withFileTypes: true })
+            .forEach(node => {
+            const nodePath = path.resolve(dir, node.name);
+            // TODO: Wildcards, this is just ugly
+            for (const path of exclude) {
+                if (nodePath.endsWith(path.slice(1))) {
+                    return;
+                }
+            }
+            if (node.isDirectory()) {
+                const childFiles = this.scanFiles(nodePath, exclude);
+                files.push(...childFiles);
+            }
+            else {
+                if (!nodePath.endsWith('.ts')) {
+                    return;
+                }
+                files.push(nodePath);
+            }
+        });
+        return files;
+    }
+    // Build Nodes
+    async buildNode(node, tree) {
+        log_1.Log.trace('compiler', 'module', `Building ${this.name}::${(0, log_1.scopeTag)(node.builder.$b, node.builder.name)}`);
+        if (node.builder.$b === 'constants') {
+            this.schema.constants = constants_builder_1.ConstantsBuilder.build(node);
+        }
+        else if (node.builder.$b === 'externals') {
+            this.schema.externals = externals_builder_1.ExternalsBuilder.build(node);
+        }
+        else if (node.builder.$b === 'bucket') {
+            this.schema.buckets[node.name] = bucket_builder_1.BucketBuilder.build(node, tree);
+        }
+        else if (node.builder.$b === 'message') {
+            this.schema.messages[node.name] = message_builder_1.MessageBuilder.build(node, tree, this.schema);
+        }
+        else if (node.builder.$b === 'job') {
+            const { schema, inlineMessages } = job_builder_1.JobBuilder.build(node, tree, this.schema);
+            this.schema.jobs[node.name] = schema;
+            this.mergeInlineMessages(node, inlineMessages);
+        }
+        else if (node.builder.$b === 'resource') {
+            const { schema, inlineMessages, inlineJobs } = resource_builder_1.ResourceBuilder.build(node, tree, this.schema);
+            this.schema.resources[schema.name] = schema;
+            this.mergeInlineMessages(node, inlineMessages);
+            this.mergeInlineJobs(node, inlineJobs);
+        }
+        else if (node.builder.$b === 'machine') {
+            const { schema, inlineMessages, inlineJobs } = machine_builder_1.MachineBuilder.build(node, tree, this.schema);
+            this.schema.machines[schema.name] = schema;
+            this.mergeInlineMessages(node, inlineMessages);
+            this.mergeInlineJobs(node, inlineJobs);
+        }
+        else if (node.builder.$b === 'controller') {
+            this.schema.controllers[node.name] = controller_builder_1.ControllerBuilder.build(node);
+        }
+        else if (node.builder.$b === 'queue') {
+            const { schema, inlineMessages } = queue_builder_1.QueueBuilder.build(node, tree, this.schema);
+            this.schema.queues[node.name] = schema;
+            this.mergeInlineMessages(node, inlineMessages);
+        }
+        else {
+            throw error_1.NesoiError.Module.UnknownBuilderType(this, node.filepath.toString(), node.name, node.builder.$b);
+        }
+    }
+    mergeInlineMessages(node, schemas) {
+        for (const name in schemas) {
+            const $msg = schemas[name];
+            this.schema.messages[name] = $msg;
+        }
+    }
+    mergeInlineJobs(node, schemas) {
+        for (const name in schemas) {
+            const $job = schemas[name];
+            this.schema.jobs[name] = $job;
+        }
+    }
+    // Start
+    start(app, providers) {
+        const info = app_1.App.getInfo(app);
+        const config = info.config;
+        Object.entries(this.schema.buckets).forEach(([name, schema]) => {
+            const bucketConfig = config.buckets?.[this.name]?.[name];
+            this.buckets[name] = new bucket_1.Bucket(schema, bucketConfig, providers);
+        });
+        Object.entries(this.schema.messages).forEach(([name, schema]) => {
+            this.messages[name] = new message_parser_1.MessageParser(schema);
+        });
+        Object.entries(this.schema.jobs).forEach(([name, schema]) => {
+            this.jobs[name] = new job_1.Job(this, schema);
+        });
+        Object.entries(this.schema.resources).forEach(([name, schema]) => {
+            this.resources[name] = new resource_1.Resource(this, schema);
+        });
+        Object.entries(this.schema.machines).forEach(([name, schema]) => {
+            this.machines[name] = new machine_1.Machine(this, schema);
+        });
+        Object.entries(this.schema.controllers).forEach(([name, schema]) => {
+            const controllerConfig = config.controllers?.[this.name]?.[name];
+            this.controllers[name] = new controller_1.Controller(this, schema, controllerConfig, providers);
+        });
+        Object.entries(this.schema.queues).forEach(([name, schema]) => {
+            this.queues[name] = new queue_1.Queue(this, schema);
+        });
+        this.nql = new nql_engine_1.NQL_Engine(this);
+    }
+    // Destroy
+    destroy() {
+        // Destroy messages
+        for (const name in this.messages || []) {
+            this.destroyBlock('message', name);
+        }
+        // Destroy buckets
+        for (const name in this.buckets || {}) {
+            this.destroyBlock('bucket', name);
+        }
+        // Destroy jobs
+        for (const name in this.jobs || []) {
+            this.destroyBlock('job', name);
+        }
+        // Destroy resources
+        for (const name in this.resources || []) {
+            this.destroyBlock('resource', name);
+        }
+        // Destroy machines
+        for (const name in this.machines || []) {
+            this.destroyBlock('machine', name);
+        }
+        // Destroy queues
+        for (const name in this.queues || []) {
+            this.destroyBlock('queue', name);
+        }
+        // Destroy controllers
+        for (const name in this.controllers || []) {
+            this.destroyBlock('controller', name);
+        }
+    }
+    async destroyBlock(type, name) {
+        const t = type + 's';
+        log_1.Log.info('module', this.name, 'Destroying');
+        delete this.schema[t][name];
+        delete this[t][name];
+    }
+    // Virtual
+    static async virtual(module, def) {
+        if (!module.daemon) {
+            throw new Error(`Internal Error: unable to reach nesoi daemon when building virtual module '${def.name}'`);
+        }
+        const virtualModule = new Module(def.name, { builders: [] });
+        // Inject schemas
+        if (def.schemas) {
+            virtualModule.inject(def.schemas);
+        }
+        // Build schemas
+        await virtualModule.start({ config: {} }, {});
+        // Inject externals
+        if (def.externals) {
+            virtualModule.injectDependencies(module.daemon, def.externals);
+        }
+        return virtualModule;
+    }
+}
+exports.Module = Module;

package/lib/engine/space.d.ts

@@ -0,0 +1,54 @@
+import { $Module, $Space } from "../schema";
+import { MachineBuilder } from "../elements/blocks/machine/machine.builder";
+import { ConstantsBuilder } from "../elements/entities/constants/constants.builder";
+import { ExternalsBuilder } from "../elements/blocks/externals/externals.builder";
+import { JobBuilder } from "../elements/blocks/job/job.builder";
+import { MessageBuilder } from "../elements/entities/message/message.builder";
+import { ResourceBuilder } from "../elements/blocks/resource/resource.builder";
+import { ControllerBuilder } from "../elements/edge/controller/controller.builder";
+import { BucketBuilder } from "../elements/entities/bucket/bucket.builder";
+import { $Message } from "../elements/entities/message/message.schema";
+import { BucketModelDef } from "../elements/entities/bucket/model/bucket_model.builder";
+import { BucketModelInfer } from "../elements/entities/bucket/model/bucket_model.infer";
+import { QueueBuilder } from "../elements/blocks/queue/queue.builder";
+import { $Bucket, $Job, $Resource } from "../elements";
+export declare class Space<$ extends $Space> {
+    private dirname;
+    private _authn;
+    private _name;
+    constructor(dirname: string);
+    /**
+     * Space Settings
+     * - Name
+     * - Authentication
+     */
+    name(name: string): this;
+    authn<Name extends string, Def extends BucketModelDef<$, never>, Obj = BucketModelInfer<Def>>(name: Name, $: Def): this;
+    externals<M extends keyof $['modules']>(module: M): ExternalsBuilder<$, M>;
+    constants<M extends keyof $['modules']>(module: M): ConstantsBuilder;
+    bucket<M extends keyof $['modules'], K extends string, Module extends $Module = $['modules'][M]>(globalName: `${M & string}::${K}`): BucketBuilder<$, Module, $Bucket & {
+        name: K;
+    }>;
+    message<M extends keyof $['modules'], K extends string, Module extends $Module = $['modules'][M]>(globalName: `${M & string}::${K}`): MessageBuilder<$, Module, $Message & {
+        name: K;
+    }>;
+    job<M extends keyof $['modules'], K extends string, Module extends $Module = $['modules'][M]>(globalName: `${M & string}::${K}`): JobBuilder<$, Module, $Job & {
+        name: K;
+    }, {}>;
+    resource<M extends keyof $['modules'], K extends string, Module extends $Module = $['modules'][M]>(globalName: `${M & string}::${K}`): ResourceBuilder<$, Module, $Resource & {
+        name: K;
+    }>;
+    machine<M extends keyof $['modules'], K extends string, Module extends $Module = $['modules'][M]>(globalName: `${M & string}::${K}`): MachineBuilder<$, Module, K, Module["machines"][K] & {
+        name: K;
+    }>;
+    controller<M extends keyof $['modules'], K extends string, Module extends $Module = $['modules'][M]>(globalName: `${M & string}::${K}`): ControllerBuilder<$, Module>;
+    queue<M extends keyof $['modules'], K extends string, Module extends $Module = $['modules'][M]>(globalName: `${M & string}::${K}`): QueueBuilder<$, Module, Module["queues"][K] & {
+        name: K;
+    }>;
+    /**
+     *
+     */
+    static path(space: Space<any>, ...relPath: string[]): string;
+    static scan(space: Space<any>, buildFn: (name: string, path: string) => void): void;
+}
+export type AnySpace = Space<$Space>;