nesoi 3.0.8 → 3.0.10

package/lib/elements/blocks/job/job.js

@@ -9,6 +9,10 @@ const promise_1 = __importDefault(require("../../../engine/util/promise"));
 const message_1 = require("../../entities/message/message");
 const trx_node_1 = require("../../../engine/transaction/trx_node");
 const error_1 = require("../../../engine/data/error");
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 class Job extends block_1.Block {
     constructor(module, schema) {
         super('job', module, schema);

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

@@ -10,6 +10,10 @@ export type $JobMethod<Trx, Message, O, Extra = never, Ctx = {}> = (ctx: {
     extra: Extra;
     job: $Job;
 } & Ctx) => O | Promise<O>;
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 export declare class $Job extends $Block {
     module: string;
     name: string;

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

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$Job = void 0;
 const block_schema_1 = require("../block.schema");
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 class $Job extends block_schema_1.$Block {
     constructor(module, name, alias, authn, input, output, extrasAndAsserts, method, scope) {
         super(module, name, alias, authn, input, output);

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

@@ -7,6 +7,10 @@ import { BlockBuilder } from '../block.builder';
 import { Overlay } from "../../../engine/util/type";
 import { ModuleTree } from "../../../engine/tree";
 import { ResolvedBuilderNode } from "../../../engine/dependency";
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 export declare class MachineBuilder<Space extends $Space, Module extends $Module, Name extends string, $ extends $Machine = $Machine> extends BlockBuilder<Space, Module, 'machine'> {
     $b: "machine";
     private _buckets;

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

@@ -8,6 +8,10 @@ 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");
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 class MachineBuilder extends block_builder_1.BlockBuilder {
     constructor(module, name) {
         super(module, 'machine', name);
@@ -82,7 +86,18 @@ class MachineBuilder extends block_builder_1.BlockBuilder {
         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);
+        const jobs = [];
+        Object.values(states).forEach(state => {
+            jobs.push(...Object.values(state.jobs));
+        });
+        Object.values(transitions.from).forEach(stateTransitions => {
+            Object.values(stateTransitions).forEach(transitionList => {
+                transitionList.forEach(trans => {
+                    jobs.push(...trans.jobs);
+                });
+            });
+        });
+        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, jobs, 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 => {

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

@@ -19,6 +19,10 @@ export declare const MachineOutputCode: {
         no_transition_run: string;
     };
 };
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 export declare class MachineOutputEntry<Type = string, Code = string, Text = string, Data = any> {
     type: Type;
     code: Code;
@@ -61,6 +65,10 @@ export declare class MachineOutputEntry<Type = string, Code = string, Text = str
         state: string;
     }>;
 }
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 export declare class MachineOutput {
     entries: MachineOutputEntry[];
     constructor(entries?: MachineOutputEntry[]);
@@ -68,6 +76,10 @@ export declare class MachineOutput {
     summary(): string;
     jobs(): MachineOutputEntry<string, string, string, any>[];
 }
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 export declare class Machine<S extends $Space, M extends $Module, $ extends $Machine> extends Block<S, M, $> {
     module: Module<S, M>;
     schema: $;

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

@@ -21,6 +21,10 @@ exports.MachineOutputCode = {
         'no_transition_run': 'No transition matched the required conditions to run',
     }
 };
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 class MachineOutputEntry {
     constructor(type, code, text, data) {
         this.type = type;
@@ -57,6 +61,10 @@ class MachineOutputEntry {
     }
 }
 exports.MachineOutputEntry = MachineOutputEntry;
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 class MachineOutput {
     constructor(entries = []) {
         this.entries = entries;
@@ -85,6 +93,10 @@ class MachineOutput {
     }
 }
 exports.MachineOutput = MachineOutput;
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 class Machine extends block_1.Block {
     constructor(module, schema) {
         super('machine', module, schema);

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

@@ -3,6 +3,10 @@ import { $JobAssert } from "../job/job.schema";
 import { $Dependency } from "../../../engine/dependency";
 import { AnyTrxNode } from "../../../engine/transaction/trx_node";
 import { MachineOutput } from './machine';
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 export declare class $MachineTransition extends $Block {
     module: string;
     name: string;
@@ -28,6 +32,10 @@ export type $MachineTransitions = {
         };
     };
 };
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 export declare class $MachineState extends $Block {
     module: string;
     name: string;
@@ -56,6 +64,10 @@ export declare class $MachineState extends $Block {
 export type $MachineStates = {
     [x: string]: $MachineState;
 };
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 export declare class $Machine extends $Block {
     module: string;
     name: string;
@@ -63,6 +75,7 @@ export declare class $Machine extends $Block {
     authn: string[];
     input: $Dependency[];
     buckets: $Dependency[];
+    jobs: $Dependency[];
     stateField: string;
     states: $MachineStates;
     transitions: $MachineTransitions;
@@ -70,8 +83,12 @@ export declare class $Machine extends $Block {
     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);
+    constructor(module: string, name: string, alias: string, authn: string[], input: $Dependency[], buckets: $Dependency[], jobs: $Dependency[], stateField: string, states: $MachineStates, transitions: $MachineTransitions, stateAliasField?: string | undefined, logger?: $MachineLogFn<any> | undefined);
 }
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 export declare class $MachineJobScope {
     module: string;
     machine: string;

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

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$MachineJobScope = exports.$Machine = exports.$MachineState = exports.$MachineTransition = void 0;
 const block_schema_1 = require("../block.schema");
 // Transition
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 class $MachineTransition extends block_schema_1.$Block {
     constructor(module, name, alias, authn, msg, from, to, condition, jobs = []) {
         super(module, name, alias, authn, [msg], {});
@@ -20,6 +24,10 @@ class $MachineTransition extends block_schema_1.$Block {
 }
 exports.$MachineTransition = $MachineTransition;
 // State
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 class $MachineState extends block_schema_1.$Block {
     constructor(module, name, alias, authn, initial, final, inputEnter, inputLeave, jobs) {
         super(module, name, alias, authn, [...inputEnter, ...inputLeave], {});
@@ -36,9 +44,12 @@ class $MachineState extends block_schema_1.$Block {
     }
 }
 exports.$MachineState = $MachineState;
-// Machine
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 class $Machine extends block_schema_1.$Block {
-    constructor(module, name, alias, authn, input, buckets, stateField, states, transitions, stateAliasField, logger) {
+    constructor(module, name, alias, authn, input, buckets, jobs, stateField, states, transitions, stateAliasField, logger) {
         super(module, name, alias, authn, input, {});
         this.module = module;
         this.name = name;
@@ -46,6 +57,7 @@ class $Machine extends block_schema_1.$Block {
         this.authn = authn;
         this.input = input;
         this.buckets = buckets;
+        this.jobs = jobs;
         this.stateField = stateField;
         this.states = states;
         this.transitions = transitions;
@@ -55,6 +67,10 @@ class $Machine extends block_schema_1.$Block {
     }
 }
 exports.$Machine = $Machine;
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 class $MachineJobScope {
     constructor(module, machine) {
         this.module = module;

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

@@ -6,6 +6,10 @@ import { BlockBuilder } from '../block.builder';
 import { $Job } from '../job/job.schema';
 import { AnyMachineBuilder } from './machine.builder';
 import { MachineJobDef } from '../job/internal/machine_job.builder';
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 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;

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

@@ -7,6 +7,10 @@ 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");
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 class MachineStateBuilder extends block_builder_1.BlockBuilder {
     constructor(machine, module, name, _initial = false) {
         super(module, 'machine', name);

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

@@ -11,6 +11,10 @@ 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']];
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 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;

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

@@ -5,6 +5,10 @@ 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");
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 class MachineTransitionBuilder extends block_builder_1.BlockBuilder {
     constructor(machine, module, _from, _msg, index = 0) {
         super(module, 'machine', `${_from}~${_msg.refName}`);

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

@@ -2,6 +2,10 @@ import { $Module } from "../../../../schema";
 import { QueueAdapter } from './queue_adapter';
 import { AnyMessage } from "../../../entities/message/message";
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
+/**
+ * @category Adapters
+ * @subcategory Block
+ */
 export declare class BucketQueueAdapter<M extends $Module> extends QueueAdapter {
     protected bucket: keyof M['buckets'];
     constructor(bucket: keyof M['buckets']);

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

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BucketQueueAdapter = void 0;
 const queue_adapter_1 = require("./queue_adapter");
+/**
+ * @category Adapters
+ * @subcategory Block
+ */
 class BucketQueueAdapter extends queue_adapter_1.QueueAdapter {
     constructor(bucket) {
         super();

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

@@ -1,5 +1,9 @@
 import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 import { AnyMessage } from "../../../entities/message/message";
+/**
+ * @category Adapters
+ * @subcategory Block
+ */
 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

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueAdapter = void 0;
+/**
+ * @category Adapters
+ * @subcategory Block
+ */
 class QueueAdapter {
 }
 exports.QueueAdapter = QueueAdapter;

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

@@ -6,6 +6,10 @@ 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";
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 export declare class QueueBuilder<Space extends $Space, M extends $Module, $ extends $Queue> extends BlockBuilder<Space, M, 'queue'> {
     $b: "queue";
     constructor(module: string, name: string);

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

@@ -4,6 +4,10 @@ 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");
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 class QueueBuilder extends block_builder_1.BlockBuilder {
     constructor(module, name) {
         super(module, 'queue', name);

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

@@ -1,5 +1,9 @@
 import { $Dependency } from "../../../engine/dependency";
 import { $Block } from '../block.schema';
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 export declare class $Queue extends $Block {
     module: string;
     name: string;

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

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$Queue = void 0;
 const block_schema_1 = require("../block.schema");
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 class $Queue extends block_schema_1.$Block {
     constructor(module, name, alias, authn, msgs) {
         super(module, name, alias, authn, msgs, {});

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

@@ -11,6 +11,10 @@ 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";
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 export declare class ResourceBuilder<Space extends $Space, Module extends $Module, Resource extends $Resource> extends BlockBuilder<Space, Module, 'resource'> {
     $b: "resource";
     private _jobs;

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

@@ -12,6 +12,10 @@ const name_helpers_1 = require("../../../compiler/helpers/name_helpers");
 const job_builder_1 = require("../job/job.builder");
 const resource_1 = require("./resource");
 const resource_job_1 = require("../job/internal/resource_job");
+/**
+ * @category Builders
+ * @subcategory Block
+ */
 class ResourceBuilder extends block_builder_1.BlockBuilder {
     constructor(module, name) {
         super(module, 'resource', name);

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

@@ -8,6 +8,10 @@ import { AnyTrxNode, TrxNode } from "../../../engine/transaction/trx_node";
 import { $Dependency } from "../../../engine/dependency";
 import { ResourceAssertions } from '../job/internal/resource_job.builder';
 import { $Job } from '../job/job.schema';
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 export declare class Resource<S extends $Space, M extends $Module, $ extends $Resource> extends Block<S, M, $> {
     module: Module<S, M>;
     schema: $;

package/lib/elements/blocks/resource/resource.js

@@ -4,6 +4,10 @@ exports.Resource = void 0;
 const block_1 = require("../block");
 const trx_node_1 = require("../../../engine/transaction/trx_node");
 const error_1 = require("../../../engine/data/error");
+/**
+ * @category Elements
+ * @subcategory Block
+ */
 class Resource extends block_1.Block {
     constructor(module, schema) {
         super('resource', module, schema);

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

@@ -2,6 +2,10 @@ import { $Block } from "../block.schema";
 import { $Bucket } from "../../entities/bucket/bucket.schema";
 import { $Message } from "../../entities/message/message.schema";
 import { $Dependency } from "../../../engine/dependency";
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 export declare class $Resource extends $Block {
     module: string;
     name: string;

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

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.$Resource = void 0;
 const block_schema_1 = require("../block.schema");
 const dependency_1 = require("../../../engine/dependency");
+/**
+ * @category Schemas
+ * @subcategory Block
+ */
 class $Resource extends block_schema_1.$Block {
     constructor(module, name, alias, authn, bucket, jobs) {
         const input = [];

package/lib/elements/edge/controller/adapters/cli.controller_adapter.d.ts

@@ -2,6 +2,10 @@ import { ControllerAdapter } from './controller_adapter';
 import { ControllerEndpoint } from '../controller';
 import { $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from '../controller.schema';
 export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
+/**
+ * @category Adapters
+ * @subcategory Edge
+ */
 export declare class CLIControllerAdapter extends ControllerAdapter {
     endpoints: Record<string, ControllerEndpoint<$ControllerEndpoint>>;
     protected makeEndpoint(path: string, schema: $ControllerEndpoint): void;

package/lib/elements/edge/controller/adapters/cli.controller_adapter.js

@@ -4,6 +4,10 @@ exports.CLIControllerAdapter = void 0;
 const controller_adapter_1 = require("./controller_adapter");
 const controller_1 = require("../controller");
 const log_1 = require("../../../../engine/util/log");
+/**
+ * @category Adapters
+ * @subcategory Edge
+ */
 class CLIControllerAdapter extends controller_adapter_1.ControllerAdapter {
     constructor() {
         super(...arguments);

package/lib/elements/edge/controller/adapters/controller_adapter.d.ts

@@ -2,11 +2,17 @@ import { AnyTrxNode } from "../../../../engine/transaction/trx_node";
 import { $Controller, $ControllerDomain, $ControllerEndpoint, $ControllerGroup } from '../controller.schema';
 import { AnyDaemon } from "../../../../engine/daemon";
 import { AuthnRequest } from "../../../../engine/auth/authn";
+import { $Module } from "../../..";
 export type ControllerEndpointPath = ($ControllerDomain | $ControllerGroup | $ControllerEndpoint)[];
+/**
+ * @category Adapters
+ * @subcategory Edge
+ */
 export declare abstract class ControllerAdapter {
+    protected module: $Module;
     protected schema: $Controller;
     protected daemon?: AnyDaemon;
-    constructor(schema: $Controller);
+    constructor(module: $Module, schema: $Controller);
     trx(fn: (trx: AnyTrxNode) => Promise<any>, authn?: AuthnRequest<any>): Promise<import("../../../../engine/transaction/trx").TrxStatus<any>>;
     bind(daemon: AnyDaemon): void;
     protected abstract makeEndpoint(path: string, schema: $ControllerEndpoint): void;

package/lib/elements/edge/controller/adapters/controller_adapter.js

@@ -2,8 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerAdapter = void 0;
 const log_1 = require("../../../../engine/util/log");
+/**
+ * @category Adapters
+ * @subcategory Edge
+ */
 class ControllerAdapter {
-    constructor(schema) {
+    constructor(module, schema) {
+        this.module = module;
         this.schema = schema;
     }
     async trx(fn, authn) {

package/lib/elements/edge/controller/controller.builder.d.ts

@@ -11,6 +11,10 @@ type ResourcesSupportingMsg<M extends $Module, Msg extends $Message> = {
 type MachinesSupportingMsg<M extends $Module, Msg extends $Message> = {
     [J in keyof M['machines']]: Msg extends M['machines'][J]['#input'] ? J : never;
 }[keyof M['machines']];
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 export declare class ControllerEndpointBuilder<S extends $Space, M extends $Module, Msg extends $Message = never> {
     private module;
     private name;
@@ -30,6 +34,10 @@ export declare class ControllerEndpointBuilder<S extends $Space, M extends $Modu
     toMachine(machine: MachinesSupportingMsg<M, Msg>): this;
     static build(builder: ControllerEndpointBuilder<any, any>): $ControllerEndpoint;
 }
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 export declare class ControllerGroupBuilder<S extends $Space, M extends $Module> {
     private module;
     protected name: string;
@@ -46,11 +54,19 @@ export declare class ControllerGroupBuilder<S extends $Space, M extends $Module>
     static buildGroups(builders: Record<string, ControllerGroupBuilder<any, any>>): Record<string, $ControllerGroup>;
     static buildEndpoints(builders: Record<string, ControllerEndpointBuilder<any, any>>): Record<string, $ControllerEndpoint>;
 }
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 export declare class ControllerDomainBuilder<S extends $Space, M extends $Module> extends ControllerGroupBuilder<S, M> {
     private _version;
     version(version: string): this;
     static build(builder: ControllerDomainBuilder<any, any>): $ControllerDomain;
 }
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 export declare class ControllerBuilder<S extends $Space, M extends $Module> {
     private module;
     private name;

package/lib/elements/edge/controller/controller.builder.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerBuilder = exports.ControllerDomainBuilder = exports.ControllerGroupBuilder = exports.ControllerEndpointBuilder = void 0;
 const controller_schema_1 = require("./controller.schema");
 const dependency_1 = require("../../../engine/dependency");
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 class ControllerEndpointBuilder {
     constructor(module, name, _authn = []) {
         this.module = module;
@@ -50,6 +54,10 @@ class ControllerEndpointBuilder {
     }
 }
 exports.ControllerEndpointBuilder = ControllerEndpointBuilder;
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 class ControllerGroupBuilder {
     constructor(module, name, _authn = []) {
         this.module = module;
@@ -104,6 +112,10 @@ class ControllerGroupBuilder {
     }
 }
 exports.ControllerGroupBuilder = ControllerGroupBuilder;
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 class ControllerDomainBuilder extends ControllerGroupBuilder {
     constructor() {
         super(...arguments);
@@ -119,6 +131,10 @@ class ControllerDomainBuilder extends ControllerGroupBuilder {
     }
 }
 exports.ControllerDomainBuilder = ControllerDomainBuilder;
+/**
+ * @category Builders
+ * @subcategory Edge
+ */
 class ControllerBuilder {
     constructor(module, name) {
         this.module = module;

package/lib/elements/edge/controller/controller.config.d.ts

@@ -1,6 +1,7 @@
+import { $Module } from "../..";
 import { ControllerAdapter } from './adapters/controller_adapter';
 import { $Controller } from './controller.schema';
-export type ControllerConfig<B extends $Controller, Providers extends Record<string, any>> = {
+export type ControllerConfig<M extends $Module, B extends $Controller, Services extends Record<string, any>> = {
     /** Adapter used by this Controller to communicate with a data source */
-    adapter?: (schema: B, providers: Providers) => ControllerAdapter;
+    adapter?: (module: M, schema: B, services: Services) => ControllerAdapter;
 };

package/lib/elements/edge/controller/controller.d.ts

@@ -5,6 +5,10 @@ import { ControllerAdapter } from './adapters/controller_adapter';
 import { ControllerConfig } from './controller.config';
 import { AnyDaemon } from "../../../engine/daemon";
 import { AuthnRequest } from "../../../engine/auth/authn";
+/**
+ * @category Elements
+ * @subcategory Edge
+ */
 export declare class ControllerEndpoint<$ extends $ControllerEndpoint> {
     schema: $;
     adapter: ControllerAdapter;
@@ -14,10 +18,10 @@ export declare class ControllerEndpoint<$ extends $ControllerEndpoint> {
 }
 export declare class Controller<S extends $Space, M extends $Module, $ extends $Controller> {
     schema: $;
-    config?: ControllerConfig<$, any> | undefined;
-    providers: Record<string, any>;
+    config?: ControllerConfig<M, $, any> | undefined;
+    services: Record<string, any>;
     adapter: ControllerAdapter;
-    constructor(module: Module<S, M>, schema: $, config?: ControllerConfig<$, any> | undefined, providers?: Record<string, any>);
+    constructor(module: Module<S, M>, schema: $, config?: ControllerConfig<M, $, any> | undefined, services?: Record<string, any>);
     bind(daemon: AnyDaemon): void;
 }
 export type AnyController = Controller<any, any, any>;