@twin.org/engine-server-types 0.0.1-next.14

package/dist/esm/index.mjs

@@ -0,0 +1,343 @@
+import { initSchema, EntityStorageAuthenticationService, AuthHeaderProcessor } from '@twin.org/api-auth-entity-storage-service';
+import { I18n, GeneralError, ComponentFactory } from '@twin.org/core';
+import { initialiseEntityStorageConnector } from '@twin.org/engine-types';
+import { InformationService } from '@twin.org/api-service';
+import { MimeTypeProcessorFactory, RestRouteProcessorFactory, SocketRouteProcessorFactory } from '@twin.org/api-models';
+import { JwtMimeTypeProcessor, LoggingProcessor, NodeIdentityProcessor, StaticUserIdentityProcessor, RestRouteProcessor, SocketRouteProcessor } from '@twin.org/api-processors';
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Authentication component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const AuthenticationComponentType = {
+    /**
+     * Entity storage.
+     */
+    EntityStorage: "entity-storage"
+};
+
+/**
+ * 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.EntityStorage) {
+        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;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Information component types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const InformationComponentType = {
+    /**
+     * Service.
+     */
+    Service: "service"
+};
+
+/**
+ * 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.
+/**
+ * Mime type route processor types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const MimeTypeProcessorType = {
+    /**
+     * Jwt.
+     */
+    Jwt: "jwt"
+};
+
+// 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.
+/**
+ * REST route processor types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const RestRouteProcessorType = {
+    /**
+     * Auth header.
+     */
+    AuthHeader: "auth-header",
+    /**
+     * Logging.
+     */
+    Logging: "logging",
+    /**
+     * Node Identity.
+     */
+    NodeIdentity: "node-identity",
+    /**
+     * Static User Identity.
+     */
+    StaticUserIdentity: "static-user-identity",
+    /**
+     * REST Route.
+     */
+    RestRoute: "rest-route"
+};
+
+// 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.
+/**
+ * Socket route processor types.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const SocketRouteProcessorType = {
+    /**
+     * Auth header.
+     */
+    AuthHeader: "auth-header",
+    /**
+     * Logging.
+     */
+    Logging: "logging",
+    /**
+     * Node Identity.
+     */
+    NodeIdentity: "node-identity",
+    /**
+     * Static User Identity.
+     */
+    StaticUserIdentity: "static-user-identity",
+    /**
+     * Socket Route.
+     */
+    SocketRoute: "socket-route"
+};
+
+// 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;
+}
+
+export { AuthenticationComponentType, InformationComponentType, MimeTypeProcessorType, RestRouteProcessorType, SocketRouteProcessorType, initialiseAuthenticationComponent, initialiseInformationComponent, initialiseMimeTypeProcessorComponent, initialiseRestRouteProcessorComponent, initialiseSocketRouteProcessorComponent };

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

@@ -0,0 +1,13 @@
+import type { IEngineCoreContext, IEngineCore } from "@twin.org/engine-models";
+import type { AuthenticationComponentConfig } from "../models/config/authenticationComponentConfig";
+import type { IEngineServerTypesConfig } from "../models/IEngineServerTypesConfig";
+/**
+ * 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<IEngineServerTypesConfig>, context: IEngineCoreContext<IEngineServerTypesConfig>, instanceConfig: AuthenticationComponentConfig, overrideInstanceType?: string): string | undefined;

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

@@ -0,0 +1,13 @@
+import type { IEngineCore, IEngineCoreContext } from "@twin.org/engine-models";
+import type { InformationComponentConfig } from "../models/config/informationComponentConfig";
+import type { IEngineServerTypesConfig } from "../models/IEngineServerTypesConfig";
+/**
+ * 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<IEngineServerTypesConfig>, context: IEngineCoreContext<IEngineServerTypesConfig>, instanceConfig: InformationComponentConfig, overrideInstanceType?: string): string | undefined;

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

@@ -0,0 +1,13 @@
+import type { IEngineCore, IEngineCoreContext } from "@twin.org/engine-models";
+import type { MimeTypeProcessorConfig } from "../models/config/mimeTypeProcessorConfig";
+import type { IEngineServerTypesConfig } from "../models/IEngineServerTypesConfig";
+/**
+ * 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<IEngineServerTypesConfig>, context: IEngineCoreContext<IEngineServerTypesConfig>, instanceConfig: MimeTypeProcessorConfig, overrideInstanceType?: string): string | undefined;

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

@@ -0,0 +1,13 @@
+import type { IEngineCoreContext, IEngineCore } from "@twin.org/engine-models";
+import type { RestRouteProcessorConfig } from "../models/config/restRouteProcessorConfig";
+import type { IEngineServerTypesConfig } from "../models/IEngineServerTypesConfig";
+/**
+ * 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<IEngineServerTypesConfig>, context: IEngineCoreContext<IEngineServerTypesConfig>, instanceConfig: RestRouteProcessorConfig, overrideInstanceType?: string): string | undefined;

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

@@ -0,0 +1,13 @@
+import type { IEngineCore, IEngineCoreContext } from "@twin.org/engine-models";
+import type { SocketRouteProcessorConfig } from "../models/config/socketRouteProcessorConfig";
+import type { IEngineServerTypesConfig } from "../models/IEngineServerTypesConfig";
+/**
+ * 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<IEngineServerTypesConfig>, context: IEngineCoreContext<IEngineServerTypesConfig>, instanceConfig: SocketRouteProcessorConfig, overrideInstanceType?: string): string | undefined;

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./components/authentication";
+export * from "./components/information";
+export * from "./components/mimeTypeProcessor";
+export * from "./components/restRouteProcessor";
+export * from "./components/socketRouteProcessor";
+export * from "./models/config/authenticationComponentConfig";
+export * from "./models/config/informationComponentConfig";
+export * from "./models/config/mimeTypeProcessorConfig";
+export * from "./models/config/restRouteProcessorConfig";
+export * from "./models/config/socketRouteProcessorConfig";
+export * from "./models/IEngineServerTypesConfig";
+export * from "./models/types/authenticationComponentType";
+export * from "./models/types/informationComponentType";
+export * from "./models/types/mimeTypeProcessorType";
+export * from "./models/types/restRouteProcessorType";
+export * from "./models/types/socketRouteProcessorType";

package/dist/types/models/IEngineServerTypesConfig.d.ts

@@ -0,0 +1,43 @@
+import type { IWebServerOptions } from "@twin.org/api-models";
+import type { IEngineCoreTypeConfig } from "@twin.org/engine-models";
+import type { IEngineCoreTypesConfig } from "@twin.org/engine-types";
+import type { AuthenticationComponentConfig } from "./config/authenticationComponentConfig";
+import type { InformationComponentConfig } from "./config/informationComponentConfig";
+import type { MimeTypeProcessorConfig } from "./config/mimeTypeProcessorConfig";
+import type { RestRouteProcessorConfig } from "./config/restRouteProcessorConfig";
+import type { SocketRouteProcessorConfig } from "./config/socketRouteProcessorConfig";
+/**
+ * Extended engine server config with known types.
+ */
+export interface IEngineServerTypesConfig extends IEngineCoreTypesConfig {
+    /**
+     * Configuration for the web server.
+     */
+    web?: IWebServerOptions;
+    /**
+     * The types to initialise in the engine.
+     */
+    types: IEngineCoreTypesConfig["types"] & {
+        [type: string]: IEngineCoreTypeConfig[] | undefined;
+        /**
+         * Information component options which can be overridden by individual components by specifying types other than default..
+         */
+        informationComponent?: IEngineCoreTypeConfig<InformationComponentConfig>[];
+        /**
+         * REST route processors options which can be overridden by individual components by specifying types other than default..
+         */
+        restRouteProcessor?: IEngineCoreTypeConfig<RestRouteProcessorConfig>[];
+        /**
+         * Socket route processors options which can be overridden by individual components by specifying types other than default..
+         */
+        socketRouteProcessor?: IEngineCoreTypeConfig<SocketRouteProcessorConfig>[];
+        /**
+         * Mime type processors options which can be overridden by individual components by specifying types other than default..
+         */
+        mimeTypeProcessor?: IEngineCoreTypeConfig<MimeTypeProcessorConfig>[];
+        /**
+         * Authentication component options which can be overridden by individual components by specifying types other than default..
+         */
+        authenticationComponent?: IEngineCoreTypeConfig<AuthenticationComponentConfig>[];
+    };
+}

package/dist/types/models/config/authenticationComponentConfig.d.ts

@@ -0,0 +1,13 @@
+import type { IEntityStorageAuthenticationServiceConfig } from "@twin.org/api-auth-entity-storage-service";
+import type { AuthenticationComponentType } from "../types/authenticationComponentType";
+/**
+ * Authentication component config types.
+ */
+export type AuthenticationComponentConfig = {
+    type: typeof AuthenticationComponentType.EntityStorage;
+    options?: {
+        userEntityStorageType?: string;
+        vaultConnectorType?: string;
+        config?: IEntityStorageAuthenticationServiceConfig;
+    };
+};

package/dist/types/models/config/informationComponentConfig.d.ts

@@ -0,0 +1,11 @@
+import type { IInformationServiceConfig } from "@twin.org/api-service";
+import type { InformationComponentType } from "../types/informationComponentType";
+/**
+ * Information component config types.
+ */
+export type InformationComponentConfig = {
+    type: typeof InformationComponentType.Service;
+    options: {
+        config: IInformationServiceConfig;
+    };
+};

package/dist/types/models/config/mimeTypeProcessorConfig.d.ts

@@ -0,0 +1,8 @@
+import type { MimeTypeProcessorType } from "../types/mimeTypeProcessorType";
+/**
+ * Mime type processor config types.
+ */
+export type MimeTypeProcessorConfig = {
+    type: typeof MimeTypeProcessorType.Jwt;
+    options?: never;
+};

package/dist/types/models/config/restRouteProcessorConfig.d.ts

@@ -0,0 +1,32 @@
+import type { IAuthHeaderProcessorConfig } from "@twin.org/api-auth-entity-storage-service";
+import type { ILoggingProcessorConfig, IRouteProcessorConfig, IStaticUserIdentityProcessorConfig } from "@twin.org/api-processors";
+import type { RestRouteProcessorType } from "../types/restRouteProcessorType";
+/**
+ * REST route processor config types.
+ */
+export type RestRouteProcessorConfig = {
+    type: typeof RestRouteProcessorType.AuthHeader;
+    options?: {
+        vaultConnectorType?: string;
+        config?: IAuthHeaderProcessorConfig;
+    };
+} | {
+    type: typeof RestRouteProcessorType.Logging;
+    options?: {
+        loggingConnectorType?: string;
+        config?: ILoggingProcessorConfig;
+    };
+} | {
+    type: typeof RestRouteProcessorType.NodeIdentity;
+    options?: never;
+} | {
+    type: typeof RestRouteProcessorType.StaticUserIdentity;
+    options: {
+        config: IStaticUserIdentityProcessorConfig;
+    };
+} | {
+    type: typeof RestRouteProcessorType.RestRoute;
+    options?: {
+        config?: IRouteProcessorConfig;
+    };
+};

package/dist/types/models/config/socketRouteProcessorConfig.d.ts

@@ -0,0 +1,32 @@
+import type { IAuthHeaderProcessorConfig } from "@twin.org/api-auth-entity-storage-service";
+import type { ILoggingProcessorConfig, IRouteProcessorConfig, IStaticUserIdentityProcessorConfig } from "@twin.org/api-processors";
+import type { SocketRouteProcessorType } from "../types/socketRouteProcessorType";
+/**
+ * Socket route processor config types.
+ */
+export type SocketRouteProcessorConfig = {
+    type: typeof SocketRouteProcessorType.AuthHeader;
+    options?: {
+        vaultConnectorType?: string;
+        config?: IAuthHeaderProcessorConfig;
+    };
+} | {
+    type: typeof SocketRouteProcessorType.Logging;
+    options?: {
+        loggingConnectorType?: string;
+        config?: ILoggingProcessorConfig;
+    };
+} | {
+    type: typeof SocketRouteProcessorType.NodeIdentity;
+    options?: never;
+} | {
+    type: typeof SocketRouteProcessorType.StaticUserIdentity;
+    options: {
+        config: IStaticUserIdentityProcessorConfig;
+    };
+} | {
+    type: typeof SocketRouteProcessorType.SocketRoute;
+    options?: {
+        config?: IRouteProcessorConfig;
+    };
+};

package/dist/types/models/types/authenticationComponentType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Authentication component types.
+ */
+export declare const AuthenticationComponentType: {
+    /**
+     * Entity storage.
+     */
+    readonly EntityStorage: "entity-storage";
+};
+/**
+ * Authentication component types.
+ */
+export type AuthenticationComponentType = (typeof AuthenticationComponentType)[keyof typeof AuthenticationComponentType];

package/dist/types/models/types/informationComponentType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Information component types.
+ */
+export declare const InformationComponentType: {
+    /**
+     * Service.
+     */
+    readonly Service: "service";
+};
+/**
+ * Information component types.
+ */
+export type InformationComponentType = (typeof InformationComponentType)[keyof typeof InformationComponentType];

package/dist/types/models/types/mimeTypeProcessorType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Mime type route processor types.
+ */
+export declare const MimeTypeProcessorType: {
+    /**
+     * Jwt.
+     */
+    readonly Jwt: "jwt";
+};
+/**
+ * Mime type processor types.
+ */
+export type MimeTypeProcessorType = (typeof MimeTypeProcessorType)[keyof typeof MimeTypeProcessorType];

package/dist/types/models/types/restRouteProcessorType.d.ts

@@ -0,0 +1,29 @@
+/**
+ * REST route processor types.
+ */
+export declare const RestRouteProcessorType: {
+    /**
+     * Auth header.
+     */
+    readonly AuthHeader: "auth-header";
+    /**
+     * Logging.
+     */
+    readonly Logging: "logging";
+    /**
+     * Node Identity.
+     */
+    readonly NodeIdentity: "node-identity";
+    /**
+     * Static User Identity.
+     */
+    readonly StaticUserIdentity: "static-user-identity";
+    /**
+     * REST Route.
+     */
+    readonly RestRoute: "rest-route";
+};
+/**
+ * REST route processor types.
+ */
+export type RestRouteProcessorType = (typeof RestRouteProcessorType)[keyof typeof RestRouteProcessorType];