@opra/common 1.0.0-beta.2 → 1.0.0-beta.3

package/esm/document/factory/msg-api.factory.js

@@ -0,0 +1,198 @@
+import { isConstructor, resolveThunk } from '../../helpers/index.js';
+import { MSG_CONTROLLER_METADATA } from '../constants.js';
+import { MsgApi } from '../msg/msg-api.js';
+import { MsgController } from '../msg/msg-controller.js';
+import { MsgHeader } from '../msg/msg-header.js';
+import { MsgOperation } from '../msg/msg-operation.js';
+import { MsgOperationResponse } from '../msg/msg-operation-response.js';
+import { DataTypeFactory } from './data-type.factory.js';
+/**
+ * @class MsgApiFactory
+ */
+export class MsgApiFactory {
+    /**
+     * Generates MsgApi
+     * @param context
+     * @param init
+     */
+    static async createApi(context, init) {
+        const api = new MsgApi(init);
+        if (init.controllers) {
+            await context.enterAsync('.controllers', async () => {
+                if (Array.isArray(init.controllers)) {
+                    for (const c of init.controllers) {
+                        const controller = await this._createController(context, api, c);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+                else {
+                    for (const [k, v] of Object.entries(init.controllers)) {
+                        const controller = await this._createController(context, api, v, k);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+            });
+        }
+        return api;
+    }
+    static async _createController(context, parent, thunk, name) {
+        if (typeof thunk === 'function' && !isConstructor(thunk)) {
+            thunk = thunk();
+        }
+        thunk = await resolveThunk(thunk);
+        let ctor;
+        let metadata;
+        let instance;
+        // If thunk is a class
+        if (typeof thunk === 'function') {
+            metadata = Reflect.getMetadata(MSG_CONTROLLER_METADATA, thunk);
+            if (!metadata)
+                return context.addError(`Class "${thunk.name}" doesn't have a valid MsgController metadata`);
+            ctor = thunk;
+        }
+        else {
+            // If thunk is an instance of a class decorated with MsgController()
+            ctor = Object.getPrototypeOf(thunk).constructor;
+            metadata = Reflect.getMetadata(MSG_CONTROLLER_METADATA, ctor);
+            if (metadata)
+                instance = thunk;
+            else {
+                // If thunk is a DecoratorMetadata or InitArguments
+                metadata = thunk;
+                if (thunk.instance === 'object') {
+                    instance = thunk.instance;
+                    ctor = Object.getPrototypeOf(instance).constructor;
+                }
+            }
+        }
+        if (!metadata)
+            return context.addError(`Class "${ctor.name}" is not decorated with MsgController()`);
+        name = name || metadata.name;
+        if (!name)
+            throw new TypeError(`Controller name required`);
+        const controller = new MsgController(parent, {
+            ...metadata,
+            name,
+            instance,
+            ctor,
+        });
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await DataTypeFactory.addDataTypes(context, controller, metadata.types);
+            });
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            if (v.type)
+                                prmArgs.type = controller.node.findDataType(v.type);
+                            if (!prmArgs.type && typeof v.type === 'object') {
+                                prmArgs.type = await DataTypeFactory.createDataType(context, controller, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = controller.node.getDataType('any');
+                        });
+                        const prm = new MsgHeader(controller, prmArgs);
+                        controller.headers.push(prm);
+                    });
+                }
+            });
+        }
+        if (metadata.operations) {
+            await context.enterAsync('.operations', async () => {
+                for (const [operationName, operationMeta] of Object.entries(metadata.operations)) {
+                    await context.enterAsync(`[${operationName}]`, async () => {
+                        const operation = new MsgOperation(controller, {
+                            ...operationMeta,
+                            name: operationName,
+                            types: undefined,
+                            payloadType: undefined,
+                            keyType: undefined,
+                        });
+                        await this._initMsgOperation(context, operation, operationMeta);
+                        controller.operations.set(operation.name, operation);
+                    });
+                }
+            });
+        }
+        return controller;
+    }
+    /**
+     * Initializes MsgOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    static async _initMsgOperation(context, operation, metadata) {
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await DataTypeFactory.addDataTypes(context, operation, metadata.types);
+            });
+        }
+        operation.payloadType = await DataTypeFactory.resolveDataType(context, operation, metadata.payloadType);
+        if (metadata.keyType) {
+            operation.keyType = await DataTypeFactory.resolveDataType(context, operation, metadata.keyType);
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            prmArgs.type = await DataTypeFactory.resolveDataType(context, operation, v.type);
+                        });
+                        const prm = new MsgHeader(operation, prmArgs);
+                        operation.headers.push(prm);
+                    });
+                }
+            });
+        }
+        if (metadata.response) {
+            await context.enterAsync('.response', async () => {
+                const response = new MsgOperationResponse(operation, {
+                    ...metadata.response,
+                    payloadType: undefined,
+                    keyType: undefined,
+                });
+                await this._initMsgOperationResponse(context, response, metadata.response);
+                operation.response = response;
+            });
+        }
+    }
+    /**
+     * Initializes MsgOperationResponse
+     * @param context
+     * @param response
+     * @param metadata
+     * @protected
+     */
+    static async _initMsgOperationResponse(context, response, metadata) {
+        response.payloadType = await DataTypeFactory.resolveDataType(context, response, metadata.payloadType);
+        if (metadata.keyType) {
+            response.keyType = await DataTypeFactory.resolveDataType(context, response, metadata.keyType);
+        }
+        if (metadata.headers) {
+            await context.enterAsync('.headers', async () => {
+                let i = 0;
+                for (const v of metadata.headers) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            prmArgs.type = await DataTypeFactory.resolveDataType(context, response, v.type);
+                        });
+                        const prm = new MsgHeader(response, prmArgs);
+                        response.headers.push(prm);
+                    });
+                }
+            });
+        }
+    }
+}

package/esm/document/http/http-api.js

@@ -5,12 +5,13 @@ import { HttpController } from './http-controller.js';
  * @class HttpApi
  */
 export class HttpApi extends ApiBase {
-    constructor(owner) {
-        super(owner);
+    constructor(init) {
+        super(init);
         // noinspection JSUnusedGlobalSymbols
         this._controllerReverseMap = new WeakMap();
-        this.protocol = 'http';
+        this.transport = 'http';
         this.controllers = new ResponsiveMap();
+        this.url = init.url;
     }
     findController(arg0) {
         return HttpController.prototype.findController.call(this, arg0);
@@ -23,7 +24,7 @@ export class HttpApi extends ApiBase {
         const schema = super.toJSON();
         const out = {
             ...schema,
-            protocol: this.protocol,
+            transport: this.transport,
             url: this.url,
             controllers: {},
         };

package/esm/document/http/http-controller.js

@@ -4,7 +4,7 @@ import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
-import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
+import { CLASS_NAME_PATTERN, DECORATOR, HTTP_CONTROLLER_METADATA, kDataTypeMap } from '../constants.js';
 import { HttpControllerDecoratorFactory } from '../decorators/http-controller.decorator.js';
 import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
 /**
@@ -32,6 +32,8 @@ export const HttpController = function (...args) {
     _this.ctor = initArgs.ctor;
     _this._controllerReverseMap = new WeakMap();
     _this._initialize?.(initArgs);
+    _this.onInit = initArgs.onInit;
+    _this.onShutdown = initArgs.onShutdown;
 };
 /**
  *
@@ -151,3 +153,17 @@ class HttpControllerClass extends DocumentElement {
 HttpController.prototype = HttpControllerClass.prototype;
 Object.assign(HttpController, HttpControllerDecoratorFactory);
 HttpController[DECORATOR] = HttpControllerDecoratorFactory;
+HttpController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+HttpController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(HTTP_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(HTTP_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

package/esm/document/index.js

@@ -1,4 +1,5 @@
 import 'reflect-metadata';
+import * as MsgOperationDecorator_ from './decorators/msg-operation.decorator.js';
 import * as DataTypeFactory_ from './factory/data-type.factory.js';
 import * as HttpApiFactory_ from './factory/http-api.factory.js';
 export * from './api-document.js';
@@ -33,8 +34,13 @@ export * from './http/http-operation-response.js';
 export * from './http/http-parameter.js';
 export * from './http/http-request-body.js';
 export * from './http/http-status-range.js';
+export * from './msg/msg-api.js';
+export * from './msg/msg-controller.js';
+export * from './msg/msg-header.js';
+export * from './msg/msg-operation.js';
 export var classes;
 (function (classes) {
     classes.HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     classes.DataTypeFactory = DataTypeFactory_.DataTypeFactory;
+    classes.MsgOperationDecoratorFactory = MsgOperationDecorator_.MsgOperationDecoratorFactory;
 })(classes || (classes = {}));

package/esm/document/msg/msg-api.js

@@ -0,0 +1,50 @@
+import { ResponsiveMap } from '../../helpers/index.js';
+import { ApiBase } from '../common/api-base.js';
+/**
+ * @class MsgApi
+ */
+export class MsgApi extends ApiBase {
+    constructor(init) {
+        super(init);
+        // noinspection JSUnusedGlobalSymbols
+        this._controllerReverseMap = new WeakMap();
+        this.transport = 'msg';
+        this.controllers = new ResponsiveMap();
+        this.platform = init.platform;
+    }
+    findController(arg0) {
+        if (typeof arg0 === 'function') {
+            /** Check for cached mapping */
+            const controller = this._controllerReverseMap.get(arg0);
+            if (controller != null)
+                return controller;
+            /** Lookup for ctor in all controllers */
+            for (const c of this.controllers.values()) {
+                if (c.ctor === arg0) {
+                    this._controllerReverseMap.set(arg0, c);
+                    return c;
+                }
+            }
+            this._controllerReverseMap.set(arg0, null);
+            return;
+        }
+        return this.controllers.get(arg0);
+    }
+    findOperation(arg0, operationName) {
+        const controller = this.findController(arg0);
+        return controller?.operations.get(operationName);
+    }
+    toJSON() {
+        const schema = super.toJSON();
+        const out = {
+            ...schema,
+            transport: this.transport,
+            platform: this.platform,
+            controllers: {},
+        };
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
+        }
+        return out;
+    }
+}

package/esm/document/msg/msg-controller.js

@@ -0,0 +1,113 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined, ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap, MSG_CONTROLLER_METADATA } from '../constants.js';
+import { MsgControllerDecoratorFactory } from '../decorators/msg-controller.decorator.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
+/**
+ * MsgController
+ */
+export const MsgController = function (...args) {
+    // ClassDecorator
+    if (!this)
+        return MsgController[DECORATOR].apply(undefined, args);
+    // Constructor
+    const [owner, initArgs] = args;
+    DocumentElement.call(this, owner);
+    if (!CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid resource name (${initArgs.name})`);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.MsgController.Kind;
+    _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
+    _this.operations = new ResponsiveMap();
+    _this.headers = [];
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.instance = initArgs.instance;
+    _this.ctor = initArgs.ctor;
+    _this._controllerReverseMap = new WeakMap();
+    _this._initialize?.(initArgs);
+    _this.onInit = initArgs.onInit;
+    _this.onShutdown = initArgs.onShutdown;
+};
+/**
+ *
+ * @class MsgController
+ */
+class MsgControllerClass extends DocumentElement {
+    findHeader(paramName, location) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+        if (this.node.parent && this.node.parent.element instanceof MsgController) {
+            return this.node.parent.element.findHeader(paramName, location);
+        }
+    }
+    /**
+     *
+     */
+    toString() {
+        return `[MsgController ${this.name}]`;
+    }
+    /**
+     *
+     */
+    toJSON() {
+        const out = omitUndefined({
+            kind: this.kind,
+            description: this.description,
+        });
+        if (this.operations.size) {
+            out.operations = {};
+            for (const v of this.operations.values()) {
+                out.operations[v.name] = v.toJSON();
+            }
+        }
+        if (this.types.size) {
+            out.types = {};
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
+            }
+        }
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow}MsgController${colorFgMagenta + this.name + colorReset}]`;
+    }
+}
+MsgController.prototype = MsgControllerClass.prototype;
+Object.assign(MsgController, MsgControllerDecoratorFactory);
+MsgController[DECORATOR] = MsgControllerDecoratorFactory;
+MsgController.OnInit = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onInit = target[propertyKey];
+        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};
+MsgController.OnShutdown = function () {
+    return (target, propertyKey) => {
+        const sourceMetadata = (Reflect.getOwnMetadata(MSG_CONTROLLER_METADATA, target.constructor) || {});
+        sourceMetadata.onShutdown = target[propertyKey];
+        Reflect.defineMetadata(MSG_CONTROLLER_METADATA, target.constructor, sourceMetadata);
+    };
+};

package/esm/document/msg/msg-header.js

@@ -0,0 +1,37 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { Value } from '../common/value.js';
+import { parseRegExp } from '../utils/parse-regexp.util.js';
+export const MsgHeader = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    Value.call(this, owner, initArgs);
+    const _this = asMutable(this);
+    if (initArgs.name) {
+        _this.name =
+            initArgs.name instanceof RegExp
+                ? initArgs.name
+                : initArgs.name.startsWith('/')
+                    ? parseRegExp(initArgs.name, {
+                        includeFlags: 'i',
+                        excludeFlags: 'm',
+                    })
+                    : initArgs.name;
+    }
+    _this.deprecated = initArgs.deprecated;
+    _this.required = initArgs.required;
+};
+/**
+ * @class MsgHeader
+ */
+class MsgHeaderClass extends Value {
+    toJSON() {
+        return omitUndefined({
+            ...super.toJSON(),
+            name: this.name,
+            required: this.required,
+            deprecated: this.deprecated,
+        });
+    }
+}
+MsgHeader.prototype = MsgHeaderClass.prototype;

package/esm/document/msg/msg-operation-response.js

@@ -0,0 +1,54 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DataType } from '../data-type/data-type.js';
+/**
+ * @class MsgOperationResponse
+ */
+export class MsgOperationResponse extends DocumentElement {
+    constructor(owner, initArgs) {
+        super(owner);
+        this.headers = [];
+        this.channel = initArgs?.channel;
+        this.description = initArgs?.description;
+        if (initArgs?.payloadType) {
+            this.payloadType =
+                initArgs?.payloadType instanceof DataType
+                    ? initArgs.payloadType
+                    : this.owner.node.getDataType(initArgs.payloadType);
+        }
+        else
+            this.payloadType = this.owner.node.getDataType('any');
+        if (initArgs?.keyType) {
+            this.keyType =
+                initArgs?.keyType instanceof DataType ? initArgs.keyType : this.owner.node.getDataType(initArgs.keyType);
+        }
+    }
+    findHeader(paramName) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+    }
+    toJSON() {
+        const out = omitUndefined({
+            description: this.description,
+            channel: this.channel,
+            payloadType: this.payloadType.name ? this.payloadType.name : this.payloadType.toJSON(),
+            keyType: this.keyType ? (this.keyType.name ? this.keyType.name : this.keyType.toJSON()) : undefined,
+        });
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}

package/esm/document/msg/msg-operation.js

@@ -0,0 +1,77 @@
+import { asMutable } from 'ts-gems';
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
+import { DataType } from '../data-type/data-type.js';
+import { MsgOperationDecoratorFactory } from '../decorators/msg-operation.decorator.js';
+/**
+ *  MsgOperation
+ */
+export const MsgOperation = function (...args) {
+    // Decorator
+    if (!this) {
+        const [payloadType, options] = args;
+        const decoratorChain = [];
+        return MsgOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
+    }
+    // Constructor
+    const [resource, initArgs] = args;
+    DocumentElement.call(this, resource);
+    if (!CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid operation name (${initArgs.name})`);
+    const _this = asMutable(this);
+    _this.headers = [];
+    _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.channel = initArgs.channel;
+    if (initArgs?.payloadType) {
+        _this.payloadType =
+            initArgs?.payloadType instanceof DataType
+                ? initArgs.payloadType
+                : _this.owner.node.getDataType(initArgs.payloadType);
+    }
+    if (initArgs?.keyType) {
+        _this.keyType =
+            initArgs?.keyType instanceof DataType ? initArgs.keyType : _this.owner.node.getDataType(initArgs.keyType);
+    }
+};
+/**
+ * @class MsgOperation
+ */
+class MsgOperationClass extends DocumentElement {
+    findHeader(paramName) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.headers) {
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+    }
+    toJSON() {
+        const out = omitUndefined({
+            kind: OpraSchema.MsgOperation.Kind,
+            description: this.description,
+            channel: this.channel,
+            payloadType: this.payloadType.name ? this.payloadType.name : this.payloadType.toJSON(),
+            keyType: this.keyType ? (this.keyType.name ? this.keyType.name : this.keyType.toJSON()) : undefined,
+            response: this.response?.toJSON(),
+        });
+        if (this.headers.length) {
+            out.headers = [];
+            for (const prm of this.headers) {
+                out.headers.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}
+MsgOperation.prototype = MsgOperationClass.prototype;
+MsgOperation[DECORATOR] = MsgOperationDecoratorFactory;

package/esm/enums/index.js

@@ -0,0 +1,4 @@
+export * from './http-headers-codes.enum.js';
+export * from './http-status-codes.enum.js';
+export * from './http-status-messages.js';
+export * from './mime-types.enum.js';

package/esm/exception/http-errors/forbidden.error.js

@@ -1,4 +1,4 @@
-import { HttpStatusCode } from '../../http/index.js';
+import { HttpStatusCode } from '../../enums/index.js';
 import { translate } from '../../i18n/index.js';
 import { OpraHttpError } from '../opra-http-error.js';
 /**

package/esm/exception/http-errors/resource-not.available.error.js

@@ -1,4 +1,4 @@
-import { HttpStatusCode } from '../../http/index.js';
+import { HttpStatusCode } from '../../enums/index.js';
 import { translate } from '../../i18n/index.js';
 import { OpraHttpError } from '../opra-http-error.js';
 /**

package/esm/index.js

@@ -1,8 +1,8 @@
 export * from './document/index.js';
+export * from './enums/index.js';
 export * from './exception/index.js';
 export * from './filter/index.js';
 export * from './helpers/index.js';
-export * from './http/index.js';
 export * from './i18n/index.js';
 export * from './schema/index.js';
 export * from './types.js';

package/esm/schema/msg/msg-controller.interface.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @namespace MsgController
+ */
+export var MsgController;
+(function (MsgController) {
+    MsgController.Kind = 'MsgController';
+})(MsgController || (MsgController = {}));

package/esm/schema/msg/msg-header.interface.js

@@ -0,0 +1 @@
+export {};

package/esm/schema/msg/msg-operation.interface.js

@@ -0,0 +1,4 @@
+export var MsgOperation;
+(function (MsgOperation) {
+    MsgOperation.Kind = 'MsgOperation';
+})(MsgOperation || (MsgOperation = {}));

package/esm/schema/opra-schema.js

@@ -16,6 +16,9 @@ export * from './http/http-operation-response.interface.js';
 export * from './http/http-parameter.interface.js';
 export * from './http/http-request-body.interface.js';
 export * from './http/http-status-range.interface.js';
+export * from './msg/msg-controller.interface.js';
+export * from './msg/msg-header.interface.js';
+export * from './msg/msg-operation.interface.js';
 export * from './type-guards.js';
 export * from './types.js';
 export * from './value.interface.js';