@twin.org/engine-server 0.0.1-next.1

package/dist/esm/index.mjs

@@ -0,0 +1,511 @@
+import { initSchema, EntityStorageAuthenticationService, AuthHeaderProcessor, generateRestRoutesAuthentication } from '@twin.org/api-auth-entity-storage-service';
+import { MimeTypeProcessorFactory, RestRouteProcessorFactory, SocketRouteProcessorFactory } from '@twin.org/api-models';
+import { FastifyWebServer } from '@twin.org/api-server-fastify';
+import { InformationService, generateRestRoutesInformation } from '@twin.org/api-service';
+import { generateRestRoutesAttestation } from '@twin.org/attestation-service';
+import { generateRestRoutesAuditableItemGraph } from '@twin.org/auditable-item-graph-service';
+import { generateRestRoutesAuditableItemStream } from '@twin.org/auditable-item-stream-service';
+import { generateRestRoutesBlobStorage } from '@twin.org/blob-storage-service';
+import { I18n, GeneralError, ComponentFactory, Guards, Is } from '@twin.org/core';
+import { AuthenticationComponentType, InformationComponentType, MimeTypeProcessorType, RestRouteProcessorType, SocketRouteProcessorType } from '@twin.org/engine-models';
+import { generateRestRoutesEntityStorage } from '@twin.org/entity-storage-service';
+import { generateRestRoutesIdentity, generateRestRoutesIdentityProfile } from '@twin.org/identity-service';
+import { generateRestRoutesLogging } from '@twin.org/logging-service';
+import { generateRestRoutesNft } from '@twin.org/nft-service';
+import { generateRestRoutesTelemetry } from '@twin.org/telemetry-service';
+import { initialiseEntityStorageConnector } from '@twin.org/engine-core';
+import { JwtMimeTypeProcessor, LoggingProcessor, NodeIdentityProcessor, StaticUserIdentityProcessor, RestRouteProcessor, SocketRouteProcessor } from '@twin.org/api-processors';
+
+/**
+ * Initialise the authentication.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseAuthenticationComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
+        element: `Authentication Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === AuthenticationComponentType.AuthEntityStorage) {
+        initSchema();
+        initialiseEntityStorageConnector(engineCore, context, instanceConfig.options?.userEntityStorageType, "AuthenticationUser");
+        component = new EntityStorageAuthenticationService({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            ...instanceConfig.options
+        });
+        instanceType = EntityStorageAuthenticationService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "authenticationComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+/**
+ * Initialise the information component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseInformationComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
+        element: `Information Component: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === InformationComponentType.Service) {
+        component = new InformationService(instanceConfig.options);
+        instanceType = InformationService.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "informationComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    ComponentFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the mime type processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseMimeTypeProcessorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
+        element: `Mime Type Processor: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === MimeTypeProcessorType.Jwt) {
+        component = new JwtMimeTypeProcessor();
+        instanceType = JwtMimeTypeProcessor.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "mimeTypeProcessorComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    MimeTypeProcessorFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the rest route processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseRestRouteProcessorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
+        element: `REST Route Processor: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === RestRouteProcessorType.AuthHeader) {
+        component = new AuthHeaderProcessor({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            config: {
+                ...instanceConfig.options?.config
+            }
+        });
+        instanceType = AuthHeaderProcessor.NAMESPACE;
+    }
+    else if (type === RestRouteProcessorType.Logging) {
+        component = new LoggingProcessor({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            config: {
+                ...instanceConfig.options?.config
+            }
+        });
+        instanceType = LoggingProcessor.NAMESPACE;
+    }
+    else if (type === RestRouteProcessorType.NodeIdentity) {
+        component = new NodeIdentityProcessor();
+        instanceType = NodeIdentityProcessor.NAMESPACE;
+    }
+    else if (type === RestRouteProcessorType.StaticUserIdentity) {
+        component = new StaticUserIdentityProcessor(instanceConfig.options);
+        instanceType = StaticUserIdentityProcessor.NAMESPACE;
+    }
+    else if (type === RestRouteProcessorType.RestRoute) {
+        component = new RestRouteProcessor(instanceConfig.options);
+        instanceType = RestRouteProcessor.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "restRouteProcessorComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    RestRouteProcessorFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Initialise the socket route processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+function initialiseSocketRouteProcessorComponent(engineCore, context, instanceConfig, overrideInstanceType) {
+    engineCore.logInfo(I18n.formatMessage("engineCore.configuring", {
+        element: `Socket Route Processor: ${instanceConfig.type}`
+    }));
+    const type = instanceConfig.type;
+    let component;
+    let instanceType;
+    if (type === SocketRouteProcessorType.AuthHeader) {
+        component = new AuthHeaderProcessor({
+            vaultConnectorType: context.defaultTypes.vaultConnector,
+            config: {
+                ...instanceConfig.options?.config
+            }
+        });
+        instanceType = AuthHeaderProcessor.NAMESPACE;
+    }
+    else if (type === SocketRouteProcessorType.Logging) {
+        component = new LoggingProcessor({
+            loggingConnectorType: context.defaultTypes.loggingConnector,
+            config: {
+                ...instanceConfig.options.config
+            }
+        });
+        instanceType = LoggingProcessor.NAMESPACE;
+    }
+    else if (type === SocketRouteProcessorType.NodeIdentity) {
+        component = new NodeIdentityProcessor();
+        instanceType = NodeIdentityProcessor.NAMESPACE;
+    }
+    else if (type === SocketRouteProcessorType.StaticUserIdentity) {
+        component = new StaticUserIdentityProcessor(instanceConfig.options);
+        instanceType = StaticUserIdentityProcessor.NAMESPACE;
+    }
+    else if (type === SocketRouteProcessorType.SocketRoute) {
+        component = new SocketRouteProcessor(instanceConfig.options);
+        instanceType = SocketRouteProcessor.NAMESPACE;
+    }
+    else {
+        throw new GeneralError("engineCore", "componentUnknownType", {
+            type,
+            componentType: "socketRouteProcessorComponent"
+        });
+    }
+    const finalInstanceType = overrideInstanceType ?? instanceType;
+    context.componentInstances.push({
+        instanceType: finalInstanceType,
+        component
+    });
+    SocketRouteProcessorFactory.register(finalInstanceType, () => component);
+    return finalInstanceType;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Server for the engine.
+ */
+class EngineServer {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "EngineServer";
+    /**
+     * The server config.
+     */
+    _config;
+    /**
+     * The engine.
+     * @internal
+     */
+    _engineCore;
+    /**
+     * The REST route generators.
+     * @internal
+     */
+    _restRouteGenerators;
+    /**
+     * The socket route generators.
+     * @internal
+     */
+    _socketRouteGenerators;
+    /**
+     * The web server.
+     * @internal
+     */
+    _webServer;
+    /**
+     * The logging connector type.
+     * @internal
+     */
+    _loggingConnectorType;
+    /**
+     * Create a new instance of EngineServer.
+     * @param options The options for the engine.
+     * @param options.server The server options for the engine.
+     * @param options.engineCore The engine core to serve from.
+     */
+    constructor(options) {
+        Guards.object(this.CLASS_NAME, "options", options);
+        Guards.object(this.CLASS_NAME, "options.engineCore", options.engineCore);
+        this._config = options?.server ?? {};
+        this._engineCore = options.engineCore;
+        this._restRouteGenerators = [];
+        this._socketRouteGenerators = [];
+        const coreConfig = this._engineCore.getConfig();
+        const defaults = this._engineCore.getDefaultTypes();
+        this._loggingConnectorType = coreConfig.silent ? undefined : defaults.loggingConnector;
+        if (!Is.arrayValue(this._config.restRouteProcessor)) {
+            this._config.restRouteProcessor = [];
+            if (!coreConfig.silent) {
+                this._config.restRouteProcessor.push({
+                    type: RestRouteProcessorType.Logging,
+                    options: {
+                        config: {
+                            includeBody: coreConfig.debug
+                        }
+                    }
+                });
+            }
+            this._config.restRouteProcessor.push({
+                type: RestRouteProcessorType.RestRoute,
+                options: {
+                    config: {
+                        includeErrorStack: coreConfig.debug
+                    }
+                }
+            });
+        }
+        this.addServerTypeInitialisers();
+        this.addServerRestRouteGenerators();
+        this.addServerSocketRouteGenerators();
+    }
+    /**
+     * Add a REST route generator.
+     * @param type The type to add the generator for.
+     * @param typeConfig The type config.
+     * @param generator The generator to add.
+     */
+    addRestRouteGenerator(type, typeConfig, generator) {
+        if (!Is.empty(typeConfig)) {
+            this._restRouteGenerators.push({
+                type,
+                typeConfig,
+                generator
+            });
+        }
+    }
+    /**
+     * Add a socket route generator.
+     * @param type The type to add the generator for.
+     * @param typeConfig The type config.
+     * @param generator The generator to add.
+     */
+    addSocketRouteGenerator(type, typeConfig, generator) {
+        if (!Is.empty(typeConfig)) {
+            this._socketRouteGenerators.push({
+                type,
+                typeConfig,
+                generator
+            });
+        }
+    }
+    /**
+     * Start the engine server.
+     * @returns Nothing.
+     */
+    async start() {
+        await this._engineCore.start();
+        await this.startWebServer();
+    }
+    /**
+     * Stop the engine server.
+     * @returns Nothing.
+     */
+    async stop() {
+        if (this._webServer) {
+            await this._webServer.stop();
+            this._webServer = undefined;
+        }
+        await this._engineCore.stop();
+    }
+    /**
+     * Starts the web server.
+     * @internal
+     */
+    async startWebServer() {
+        const restRoutes = this.buildRestRoutes();
+        const socketRoutes = this.buildSocketRoutes();
+        const restRouteProcessors = RestRouteProcessorFactory.names().map(n => RestRouteProcessorFactory.get(n));
+        const socketRouteProcessors = SocketRouteProcessorFactory.names().map(n => SocketRouteProcessorFactory.get(n));
+        const mimeTypeProcessors = MimeTypeProcessorFactory.names().map(n => MimeTypeProcessorFactory.get(n));
+        this._webServer = new FastifyWebServer({
+            loggingConnectorType: this._loggingConnectorType,
+            mimeTypeProcessors
+        });
+        await this._webServer.build(restRouteProcessors, restRoutes, socketRouteProcessors, socketRoutes, this._config.web);
+        await this._webServer.start();
+    }
+    /**
+     * The REST routes for the application.
+     * @returns The REST routes for the application.
+     * @internal
+     */
+    buildRestRoutes() {
+        const routes = [];
+        for (const { type, typeConfig, generator } of this._restRouteGenerators) {
+            this.initialiseRestTypeRoute(routes, type, typeConfig, generator);
+        }
+        return routes;
+    }
+    /**
+     * The socket routes for the application.
+     * @returns The socket routes for the application.
+     * @internal
+     */
+    buildSocketRoutes() {
+        const routes = [];
+        for (const { type, typeConfig, generator } of this._socketRouteGenerators) {
+            this.initialiseSocketTypeRoute(routes, type, typeConfig, generator);
+        }
+        return routes;
+    }
+    /**
+     * Initialise the rest routes from connector.
+     * @param routes The routes to add to.
+     * @param typeKey The key for the default types.
+     * @param typeConfig The type config.
+     * @param generateRoutes The function to generate the routes.
+     * @internal
+     */
+    initialiseRestTypeRoute(routes, typeKey, typeConfig, generateRoutes) {
+        if (Is.arrayValue(typeConfig)) {
+            const defaultEngineTypes = this._engineCore.getDefaultTypes();
+            for (let i = 0; i < typeConfig.length; i++) {
+                const restPath = typeConfig[i].restPath;
+                if (Is.string(restPath)) {
+                    const serviceType = typeConfig[i].overrideInstanceType ?? defaultEngineTypes[typeKey];
+                    if (Is.stringValue(serviceType)) {
+                        routes.push(...generateRoutes(restPath, serviceType));
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Initialise the rest routes from connector.
+     * @param routes The routes to add to.
+     * @param typeKey The key for the default types.
+     * @param typeConfig The type config.
+     * @param generateRoutes The function to generate the routes.
+     * @internal
+     */
+    initialiseSocketTypeRoute(routes, typeKey, typeConfig, generateRoutes) {
+        if (Is.arrayValue(typeConfig)) {
+            const defaultEngineTypes = this._engineCore.getDefaultTypes();
+            for (let i = 0; i < typeConfig.length; i++) {
+                const socketPath = typeConfig[i].socketPath;
+                if (Is.string(socketPath)) {
+                    const serviceType = typeConfig[i].overrideInstanceType ?? defaultEngineTypes[typeKey];
+                    if (Is.stringValue(serviceType)) {
+                        routes.push(...generateRoutes(socketPath, serviceType));
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Add the server type initializers.
+     * @internal
+     */
+    addServerTypeInitialisers() {
+        this._engineCore.addTypeInitialiser("authenticationComponent", this._config.authenticationComponent, initialiseAuthenticationComponent);
+        this._engineCore.addTypeInitialiser("informationComponent", this._config.informationComponent, initialiseInformationComponent);
+        this._engineCore.addTypeInitialiser("restRouteProcessor", this._config.restRouteProcessor, initialiseRestRouteProcessorComponent);
+        this._engineCore.addTypeInitialiser("socketRouteProcessor", this._config.socketRouteProcessor, initialiseSocketRouteProcessorComponent);
+        this._engineCore.addTypeInitialiser("mimeTypeProcessor", this._config.mimeTypeProcessor, initialiseMimeTypeProcessorComponent);
+    }
+    /**
+     * Add the server REST route generators.
+     * @internal
+     */
+    addServerRestRouteGenerators() {
+        this.addRestRouteGenerator("informationComponent", this._config.informationComponent, generateRestRoutesInformation);
+        this.addRestRouteGenerator("authenticationComponent", this._config.authenticationComponent, generateRestRoutesAuthentication);
+        const coreConfig = this._engineCore.getConfig();
+        this.addRestRouteGenerator("loggingComponent", coreConfig.loggingComponent, generateRestRoutesBlobStorage);
+        this.addRestRouteGenerator("telemetryComponent", coreConfig.telemetryComponent, generateRestRoutesTelemetry);
+        this.addRestRouteGenerator("blobStorageComponent", coreConfig.blobStorageComponent, generateRestRoutesLogging);
+        this.addRestRouteGenerator("identityComponent", coreConfig.identityComponent, generateRestRoutesIdentity);
+        this.addRestRouteGenerator("identityProfileComponent", coreConfig.identityProfileComponent, generateRestRoutesIdentityProfile);
+        this.addRestRouteGenerator("nftComponent", coreConfig.nftComponent, generateRestRoutesNft);
+        this.addRestRouteGenerator("attestationComponent", coreConfig.attestationComponent, generateRestRoutesAttestation);
+        this.addRestRouteGenerator("auditableItemGraphComponent", coreConfig.auditableItemGraphComponent, generateRestRoutesAuditableItemGraph);
+        this.addRestRouteGenerator("auditableItemStreamComponent", coreConfig.auditableItemStreamComponent, generateRestRoutesAuditableItemStream);
+        this.addRestRouteGenerator("entityStorageComponent", coreConfig.entityStorageComponent, generateRestRoutesEntityStorage);
+    }
+    /**
+     * Add the server socket route generators.
+     * @internal
+     */
+    addServerSocketRouteGenerators() {
+        // const coreConfig = this._engineCore.getConfig();
+        // this.addSocketRouteGenerator("eventBusComponent", coreConfig.eventBusComponent, generateSocketRoutesEventBus);
+    }
+}
+
+export { EngineServer };

package/dist/types/components/authentication.d.ts

@@ -0,0 +1,11 @@
+import { type IEngineCoreContext, type AuthenticationComponentConfig, type IEngineCore } from "@twin.org/engine-models";
+/**
+ * Initialise the authentication.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+export declare function initialiseAuthenticationComponent(engineCore: IEngineCore, context: IEngineCoreContext, instanceConfig: AuthenticationComponentConfig, overrideInstanceType?: string): string | undefined;

package/dist/types/components/information.d.ts

@@ -0,0 +1,11 @@
+import { type IEngineCore, type IEngineCoreContext, type InformationComponentConfig } from "@twin.org/engine-models";
+/**
+ * Initialise the information component.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+export declare function initialiseInformationComponent(engineCore: IEngineCore, context: IEngineCoreContext, instanceConfig: InformationComponentConfig, overrideInstanceType?: string): string | undefined;

package/dist/types/components/mimeTypeProcessor.d.ts

@@ -0,0 +1,11 @@
+import { type IEngineCore, type IEngineCoreContext, type MimeTypeProcessorConfig } from "@twin.org/engine-models";
+/**
+ * Initialise the mime type processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+export declare function initialiseMimeTypeProcessorComponent(engineCore: IEngineCore, context: IEngineCoreContext, instanceConfig: MimeTypeProcessorConfig, overrideInstanceType?: string): string | undefined;

package/dist/types/components/restRouteProcessor.d.ts

@@ -0,0 +1,11 @@
+import { type IEngineCoreContext, type IEngineCore, type RestRouteProcessorConfig } from "@twin.org/engine-models";
+/**
+ * Initialise the rest route processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+export declare function initialiseRestRouteProcessorComponent(engineCore: IEngineCore, context: IEngineCoreContext, instanceConfig: RestRouteProcessorConfig, overrideInstanceType?: string): string | undefined;

package/dist/types/components/socketRouteProcessor.d.ts

@@ -0,0 +1,11 @@
+import { type IEngineCoreContext, type IEngineCore, type SocketRouteProcessorConfig } from "@twin.org/engine-models";
+/**
+ * Initialise the socket route processor.
+ * @param engineCore The engine core.
+ * @param context The context for the engine.
+ * @param instanceConfig The instance config.
+ * @param overrideInstanceType The instance type to override the default.
+ * @returns The name of the instance created.
+ * @throws GeneralError if the component type is unknown.
+ */
+export declare function initialiseSocketRouteProcessorComponent(engineCore: IEngineCore, context: IEngineCoreContext, instanceConfig: SocketRouteProcessorConfig, overrideInstanceType?: string): string | undefined;

package/dist/types/engineServer.d.ts

@@ -0,0 +1,48 @@
+import { type IEngineCore, type IEngineCoreTypeConfig, type IEngineServer, type IEngineServerConfig, type RestRouteGenerator, type SocketRouteGenerator } from "@twin.org/engine-models";
+/**
+ * Server for the engine.
+ */
+export declare class EngineServer implements IEngineServer {
+    /**
+     * Runtime name for the class.
+     */
+    readonly CLASS_NAME: string;
+    /**
+     * The server config.
+     */
+    protected readonly _config: IEngineServerConfig;
+    /**
+     * Create a new instance of EngineServer.
+     * @param options The options for the engine.
+     * @param options.server The server options for the engine.
+     * @param options.engineCore The engine core to serve from.
+     */
+    constructor(options: {
+        engineCore: IEngineCore;
+        server?: IEngineServerConfig;
+    });
+    /**
+     * Add a REST route generator.
+     * @param type The type to add the generator for.
+     * @param typeConfig The type config.
+     * @param generator The generator to add.
+     */
+    addRestRouteGenerator(type: string, typeConfig: IEngineCoreTypeConfig[] | undefined, generator: RestRouteGenerator): void;
+    /**
+     * Add a socket route generator.
+     * @param type The type to add the generator for.
+     * @param typeConfig The type config.
+     * @param generator The generator to add.
+     */
+    addSocketRouteGenerator(type: string, typeConfig: IEngineCoreTypeConfig[] | undefined, generator: SocketRouteGenerator): void;
+    /**
+     * Start the engine server.
+     * @returns Nothing.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the engine server.
+     * @returns Nothing.
+     */
+    stop(): Promise<void>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./engineServer";

package/docs/changelog.md

@@ -0,0 +1,5 @@
+# @twin.org/engine-server - Changelog
+
+## v0.0.1-next.1
+
+- Initial Release

package/docs/examples.md

@@ -0,0 +1 @@
+# @twin.org/engine-server - Examples