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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.3",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -20,7 +20,7 @@
     "super-fast-md5": "^1.0.3",
     "tslib": "^2.7.0",
     "uid": "^2.0.1",
-    "valgen": "^5.9.0"
+    "valgen": "^5.10.0"
   },
   "type": "module",
   "exports": {

package/types/document/api-document.d.ts

@@ -6,7 +6,8 @@ import { DocumentElement } from './common/document-element.js';
 import { kTypeNSMap } from './constants.js';
 import { DataType } from './data-type/data-type.js';
 import type { EnumType } from './data-type/enum-type.js';
-import type { HttpApi } from './http/http-api.js';
+import { HttpApi } from './http/http-api.js';
+import { MsgApi } from './msg/msg-api.js';
 /**
  *
  * @class ApiDocument
@@ -18,7 +19,7 @@ export declare class ApiDocument extends DocumentElement {
     info: OpraSchema.DocumentInfo;
     references: ResponsiveMap<ApiDocument>;
     types: DataTypeMap;
-    api?: HttpApi;
+    api?: HttpApi | MsgApi;
     constructor();
     /**
      * Returns NS of datatype. Returns undefined if not found
@@ -26,6 +27,8 @@ export declare class ApiDocument extends DocumentElement {
      */
     getDataTypeNs(nameOrCtor: string | Type | Function | EnumType.EnumArray | EnumType.EnumObject | DataType): string | undefined;
     findDocument(id: string): ApiDocument | undefined;
+    get httpApi(): HttpApi;
+    get msgApi(): MsgApi;
     toJSON(): OpraSchema.ApiDocument;
     /**
      * Export as Opra schema definition object

package/types/document/common/api-base.d.ts

@@ -4,14 +4,15 @@ import { DocumentElement } from './document-element.js';
 import type { DocumentInitContext } from './document-init-context';
 export declare namespace ApiBase {
     interface InitArguments extends Pick<OpraSchema.Api, 'description' | 'name'> {
+        owner: ApiDocument | ApiBase;
     }
 }
 export declare abstract class ApiBase extends DocumentElement {
-    abstract readonly protocol: OpraSchema.Protocol;
+    abstract readonly transport: OpraSchema.Transport;
     readonly owner: ApiDocument | ApiBase;
     name: string;
     description?: string;
-    protected constructor(owner: ApiDocument | ApiBase);
+    protected constructor(init: ApiBase.InitArguments);
     toJSON(): OpraSchema.Api;
     protected _initialize(init: ApiBase.InitArguments, context: DocumentInitContext): Promise<void>;
 }

package/types/document/constants.d.ts

@@ -1,5 +1,6 @@
 export declare const DATATYPE_METADATA: unique symbol;
 export declare const HTTP_CONTROLLER_METADATA: unique symbol;
+export declare const MSG_CONTROLLER_METADATA: unique symbol;
 export declare const DECODER: unique symbol;
 export declare const ENCODER: unique symbol;
 export declare const DECORATOR: unique symbol;

package/types/document/decorators/http-operation.decorator.d.ts

@@ -1,9 +1,9 @@
 import type { StrictOmit, Type, TypeThunkAsync } from 'ts-gems';
 import { HttpMediaType } from '../http/http-media-type.js';
 import { HttpMultipartField } from '../http/http-multipart-field.js';
-import type { HttpOperation } from '../http/http-operation';
-import type { HttpOperationResponse } from '../http/http-operation-response';
-import type { HttpParameter } from '../http/http-parameter';
+import type { HttpOperation } from '../http/http-operation.js';
+import type { HttpOperationResponse } from '../http/http-operation-response.js';
+import type { HttpParameter } from '../http/http-parameter.js';
 export interface HttpOperationDecorator {
     (target: Object, propertyKey: string): void;
     Cookie(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | Type): this;

package/types/document/decorators/msg-controller.decorator.d.ts

@@ -0,0 +1,11 @@
+import type { TypeThunkAsync } from 'ts-gems';
+import type { MsgController } from '../msg/msg-controller.js';
+import type { MsgHeader } from '../msg/msg-header.js';
+export interface MsgControllerDecorator<T extends MsgControllerDecorator<any> = MsgControllerDecorator<any>> extends ClassDecorator {
+    Header(name: string | RegExp, optionsOrType?: MsgHeader.Options | string | TypeThunkAsync | false): T;
+    UseType(...type: TypeThunkAsync[]): T;
+}
+export interface MsgControllerDecoratorFactory {
+    <T extends MsgController.Options>(options?: T): MsgControllerDecorator;
+}
+export declare function MsgControllerDecoratorFactory<O extends MsgController.Options>(options?: O): MsgControllerDecorator;

package/types/document/decorators/msg-operation.decorator.d.ts

@@ -0,0 +1,29 @@
+import type { ThunkAsync, Type, TypeThunkAsync } from 'ts-gems';
+import type { MsgHeader } from '../msg/msg-header.js';
+import type { MsgOperation } from '../msg/msg-operation.js';
+import type { MsgOperationResponse } from '../msg/msg-operation-response.js';
+export interface MsgOperationDecorator {
+    (target: Object, propertyKey: string): void;
+    Header(name: string | RegExp, optionsOrType?: MsgHeader.Options | string | TypeThunkAsync): this;
+    Response(payloadType: TypeThunkAsync | string, options?: MsgOperationResponse.Options): MsgOperationResponseDecorator;
+    UseType(...type: Type[]): this;
+}
+export interface MsgOperationResponseDecorator {
+    (target: Object, propertyKey: string): void;
+    Header(name: string | RegExp, optionsOrType?: MsgHeader.Options | string | TypeThunkAsync): this;
+}
+export interface MsgOperationDecoratorFactory {
+    /**
+     * Property decorator
+     * @param decoratorChain
+     * @param payloadType
+     * @param options
+     */ <T extends MsgOperation.Options>(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: T): MsgOperationDecorator;
+}
+export declare namespace MsgOperationDecoratorFactory {
+    type AugmentationFunction = (decorator: MsgOperationDecorator, decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: MsgOperation.Options) => void;
+}
+export declare function MsgOperationDecoratorFactory(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string | TypeThunkAsync, options?: MsgOperation.Options): MsgOperationDecorator;
+export declare namespace MsgOperationDecoratorFactory {
+    var augment: (fn: MsgOperationDecoratorFactory.AugmentationFunction) => void;
+}

package/types/document/factory/api-document.factory.d.ts

@@ -4,11 +4,12 @@ import { ApiDocument } from '../api-document.js';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { DataTypeFactory } from './data-type.factory.js';
 import { HttpApiFactory } from './http-api.factory.js';
+import { MsgApiFactory } from './msg-api.factory.js';
 export declare namespace ApiDocumentFactory {
     interface InitArguments extends PartialSome<StrictOmit<OpraSchema.ApiDocument, 'id' | 'references' | 'types' | 'api'>, 'spec'> {
         references?: Record<string, ReferenceThunk>;
         types?: DataTypeInitSources;
-        api?: HttpApiFactory.InitArguments;
+        api?: StrictOmit<HttpApiFactory.InitArguments, 'owner'> | StrictOmit<MsgApiFactory.InitArguments, 'owner'>;
     }
     type ReferenceSource = string | OpraSchema.ApiDocument | InitArguments | ApiDocument;
     type ReferenceThunk = ThunkAsync<ReferenceSource>;

package/types/document/factory/data-type.factory.d.ts

@@ -60,6 +60,7 @@ export declare namespace DataTypeFactory {
  */
 export declare class DataTypeFactory {
     static createDataType(context: DocumentInitContext | undefined, owner: DocumentElement, thunk: DataTypeFactory.DataTypeThunk): Promise<DataType | undefined>;
+    static resolveDataType(context: DocumentInitContext | undefined, owner: DocumentElement, v: any): Promise<DataType>;
     /**
      *
      * @param context

package/types/document/factory/http-api.factory.d.ts

@@ -1,6 +1,5 @@
-import type { StrictOmit, Type } from 'ts-gems';
+import type { Type } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
-import { ApiDocument } from '../api-document.js';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { HttpApi } from '../http/http-api.js';
 import { HttpController } from '../http/http-controller.js';
@@ -9,7 +8,7 @@ import { HttpOperation } from '../http/http-operation.js';
 import { HttpOperationResponse } from '../http/http-operation-response.js';
 import { HttpRequestBody } from '../http/http-request-body.js';
 export declare namespace HttpApiFactory {
-    interface InitArguments extends StrictOmit<OpraSchema.HttpApi, 'controllers'> {
+    interface InitArguments extends HttpApi.InitArguments {
         controllers: Type[] | any[] | ((parent: any) => any) | OpraSchema.HttpApi['controllers'];
     }
 }
@@ -20,11 +19,16 @@ export declare class HttpApiFactory {
     /**
      * Generates HttpApi
      * @param context
-     * @param document
      * @param init
      */
-    static createApi(context: DocumentInitContext, document: ApiDocument, init: HttpApiFactory.InitArguments): Promise<HttpApi>;
-    protected static _createController(context: DocumentInitContext, parent: HttpApi | HttpController, thunk: Type | object | Function | OpraSchema.HttpController, name?: string): Promise<HttpController | undefined | void>;
+    static createApi(context: DocumentInitContext, init: HttpApiFactory.InitArguments): Promise<HttpApi>;
+    protected static _createControllers(context: DocumentInitContext, parent: HttpApi | HttpController, controllers: Type[] | any[] | ((parent: any) => any) | OpraSchema.HttpApi['controllers']): Promise<void>;
+    protected static _resolveControllerMetadata(context: DocumentInitContext, parent: HttpApi | HttpController, thunk: Type | object | Function | OpraSchema.HttpController): Promise<{
+        metadata: HttpController.Metadata | OpraSchema.HttpController;
+        instance: any;
+        ctor: Type;
+    } | undefined | void>;
+    protected static _createController(context: DocumentInitContext, parent: HttpApi | HttpController, metadata: HttpController.Metadata | OpraSchema.HttpController, instance: any, ctor: Type): Promise<HttpController | undefined | void>;
     /**
      * Initializes HttpOperation
      * @param context

package/types/document/factory/msg-api.factory.d.ts

@@ -0,0 +1,40 @@
+import type { Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { MsgApi } from '../msg/msg-api.js';
+import { MsgController } from '../msg/msg-controller.js';
+import { MsgOperation } from '../msg/msg-operation.js';
+import { MsgOperationResponse } from '../msg/msg-operation-response.js';
+export declare namespace MsgApiFactory {
+    interface InitArguments extends MsgApi.InitArguments {
+        controllers: Type[] | any[] | ((parent: any) => any) | OpraSchema.MsgApi['controllers'];
+    }
+}
+/**
+ * @class MsgApiFactory
+ */
+export declare class MsgApiFactory {
+    /**
+     * Generates MsgApi
+     * @param context
+     * @param init
+     */
+    static createApi(context: DocumentInitContext, init: MsgApiFactory.InitArguments): Promise<MsgApi>;
+    protected static _createController(context: DocumentInitContext, parent: MsgApi, thunk: Type | object | Function | OpraSchema.MsgController, name?: string): Promise<MsgController | undefined | void>;
+    /**
+     * Initializes MsgOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    protected static _initMsgOperation(context: DocumentInitContext, operation: MsgOperation, metadata: MsgOperation.Metadata | OpraSchema.MsgOperation): Promise<void>;
+    /**
+     * Initializes MsgOperationResponse
+     * @param context
+     * @param response
+     * @param metadata
+     * @protected
+     */
+    protected static _initMsgOperationResponse(context: DocumentInitContext, response: MsgOperationResponse, metadata: MsgOperationResponse.Metadata | OpraSchema.MsgOperationResponse): Promise<void>;
+}

package/types/document/http/http-api.d.ts

@@ -1,20 +1,25 @@
-import type { Type } from 'ts-gems';
+import type { StrictOmit, Type } from 'ts-gems';
 import { ResponsiveMap } from '../../helpers/index.js';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document';
 import { ApiBase } from '../common/api-base.js';
 import { HttpController } from './http-controller.js';
 import type { HttpOperation } from './http-operation.js';
+export declare namespace HttpApi {
+    interface InitArguments extends ApiBase.InitArguments, StrictOmit<OpraSchema.HttpApi, 'controllers'> {
+        transport: 'http';
+    }
+}
 /**
  * @class HttpApi
  */
 export declare class HttpApi extends ApiBase {
     protected _controllerReverseMap: WeakMap<Type, HttpController | null>;
     readonly owner: ApiDocument;
-    readonly protocol = "http";
+    readonly transport = "http";
     controllers: ResponsiveMap<HttpController>;
     url?: string;
-    constructor(owner: ApiDocument);
+    constructor(init: HttpApi.InitArguments);
     findController(controller: Type): HttpController | undefined;
     findController(resourcePath: string): HttpController | undefined;
     findOperation(controller: Type, operationName: string): HttpOperation | undefined;

package/types/document/http/http-controller.d.ts

@@ -19,6 +19,8 @@ export declare namespace HttpController {
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
         operations?: Record<string, HttpOperation.Metadata>;
         parameters?: HttpParameter.Metadata[];
+        onInit?: (resource: HttpController) => void;
+        onShutdown?: (resource: HttpController) => void | Promise<void>;
     }
     interface Options extends Partial<Pick<OpraSchema.HttpController, 'description' | 'path'>> {
         name?: string;
@@ -27,11 +29,11 @@ export declare namespace HttpController {
     interface InitArguments extends Combine<{
         instance?: object;
         ctor?: Type;
-    }, Pick<Metadata, 'name' | 'description' | 'path'>> {
+    }, Pick<Metadata, 'name' | 'description' | 'path' | 'onInit' | 'onShutdown'>> {
     }
 }
 /**
- * Type definition for HttpOperation
+ * Type definition for HttpController
  * @class HttpController
  */
 export interface HttpControllerStatic extends HttpControllerDecoratorFactory {
@@ -42,6 +44,8 @@ export interface HttpControllerStatic extends HttpControllerDecoratorFactory {
      */
     new (owner: HttpApi | HttpController, args: HttpController.InitArguments): HttpController;
     prototype: HttpController;
+    OnInit(): PropertyDecorator;
+    OnShutdown(): PropertyDecorator;
 }
 /**
  * Type definition of HttpController prototype
@@ -69,6 +73,8 @@ declare class HttpControllerClass extends DocumentElement {
     operations: ResponsiveMap<HttpOperation>;
     controllers: ResponsiveMap<HttpController>;
     types: DataTypeMap;
+    onInit?: (resource: HttpController) => void;
+    onShutdown?: (resource: HttpController) => void | Promise<void>;
     /**
      * @property isRoot
      */

package/types/document/index.d.ts

@@ -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';
@@ -23,6 +24,7 @@ export * from './data-type/primitive-types/index.js';
 export * from './data-type/required-type.js';
 export * from './data-type/simple-type.js';
 export * from './decorators/http-operation-entity.decorator.js';
+export type { MsgOperationDecorator } from './decorators/msg-operation.decorator.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
 export * from './http/http-controller.js';
@@ -33,7 +35,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 type { MsgOperationResponse } from './msg/msg-operation-response.js';
 export declare namespace classes {
     export import HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     export import DataTypeFactory = DataTypeFactory_.DataTypeFactory;
+    export import MsgOperationDecoratorFactory = MsgOperationDecorator_.MsgOperationDecoratorFactory;
 }

package/types/document/msg/msg-api.d.ts

@@ -0,0 +1,27 @@
+import type { StrictOmit, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document';
+import { ApiBase } from '../common/api-base.js';
+import { MsgController } from './msg-controller.js';
+import { MsgOperation } from './msg-operation.js';
+export declare namespace MsgApi {
+    interface InitArguments extends ApiBase.InitArguments, StrictOmit<OpraSchema.MsgApi, 'controllers'> {
+    }
+}
+/**
+ * @class MsgApi
+ */
+export declare class MsgApi extends ApiBase {
+    protected _controllerReverseMap: WeakMap<Type, MsgController | null>;
+    readonly owner: ApiDocument;
+    readonly transport = "msg";
+    platform: string;
+    controllers: ResponsiveMap<MsgController>;
+    constructor(init: MsgApi.InitArguments);
+    findController(controller: Type): MsgController | undefined;
+    findController(name: string): MsgController | undefined;
+    findOperation(controller: Type, operationName: string): MsgOperation | undefined;
+    findOperation(controllerName: string, operationName: string): MsgOperation | undefined;
+    toJSON(): OpraSchema.MsgApi;
+}

package/types/document/msg/msg-controller.d.ts

@@ -0,0 +1,89 @@
+import type { Combine, ThunkAsync, Type } from 'ts-gems';
+import { 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 type { EnumType } from '../data-type/enum-type.js';
+import { MsgControllerDecoratorFactory } from '../decorators/msg-controller.decorator.js';
+import { nodeInspectCustom } from '../utils/inspect.util.js';
+import type { MsgApi } from './msg-api.js';
+import type { MsgHeader } from './msg-header.js';
+import type { MsgOperation } from './msg-operation.js';
+/**
+ * @namespace MsgController
+ */
+export declare namespace MsgController {
+    interface Metadata extends Pick<OpraSchema.MsgController, 'description'> {
+        name: string;
+        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+        operations?: Record<string, MsgOperation.Metadata>;
+        headers?: MsgHeader.Metadata[];
+        onInit?: (resource: MsgController) => void;
+        onShutdown?: (resource: MsgController) => void | Promise<void>;
+    }
+    interface Options extends Partial<Pick<OpraSchema.MsgController, 'description'>> {
+        name?: string;
+    }
+    interface InitArguments extends Combine<{
+        instance?: object;
+        ctor?: Type;
+    }, Pick<Metadata, 'name' | 'description' | 'onInit' | 'onShutdown'>> {
+    }
+}
+/**
+ * Type definition for MsgController
+ * @class MsgController
+ */
+export interface MsgControllerStatic extends MsgControllerDecoratorFactory {
+    /**
+     * Class constructor of MsgController
+     * @param owner
+     * @param args
+     */
+    new (owner: MsgApi | MsgController, args: MsgController.InitArguments): MsgController;
+    prototype: MsgController;
+    OnInit(): PropertyDecorator;
+    OnShutdown(): PropertyDecorator;
+}
+/**
+ * Type definition of MsgController prototype
+ * @interface MsgController
+ */
+export interface MsgController extends MsgControllerClass {
+}
+/**
+ * MsgController
+ */
+export declare const MsgController: MsgControllerStatic;
+/**
+ *
+ * @class MsgController
+ */
+declare class MsgControllerClass extends DocumentElement {
+    protected _controllerReverseMap: WeakMap<Type, MsgController | null>;
+    readonly kind: OpraSchema.MsgController.Kind;
+    readonly name: string;
+    description?: string;
+    path: string;
+    instance?: any;
+    ctor?: Type;
+    headers: MsgHeader[];
+    operations: ResponsiveMap<MsgOperation>;
+    types: DataTypeMap;
+    onInit?: (resource: MsgController) => void;
+    onShutdown?: (resource: MsgController) => void | Promise<void>;
+    findHeader(paramName: string, location?: OpraSchema.HttpParameterLocation): MsgHeader | undefined;
+    /**
+     *
+     */
+    toString(): string;
+    /**
+     *
+     */
+    toJSON(): OpraSchema.MsgController;
+    /**
+     *
+     */
+    protected [nodeInspectCustom](): string;
+}
+export {};

package/types/document/msg/msg-header.d.ts

@@ -0,0 +1,47 @@
+import { type Combine, type StrictOmit, type TypeThunkAsync } from 'ts-gems';
+import type { OpraSchema } from '../../schema/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { Value } from '../common/value.js';
+import { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+/**
+ * @namespace MsgHeader
+ */
+export declare namespace MsgHeader {
+    interface Metadata extends StrictOmit<OpraSchema.MsgHeader, 'type'> {
+        name: string | RegExp;
+        type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
+    }
+    interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
+        type?: string | TypeThunkAsync | object;
+    }
+    interface InitArguments extends Combine<{
+        type?: DataType;
+    }, Metadata> {
+    }
+}
+/**
+ * Type definition for MsgHeader
+ * @class MsgHeader
+ */
+interface MsgHeaderStatic {
+    new (owner: DocumentElement, args: MsgHeader.InitArguments): MsgHeader;
+    prototype: MsgHeader;
+}
+/**
+ * Type definition of MsgHeader prototype
+ * @interface MsgHeader
+ */
+export interface MsgHeader extends MsgHeaderClass {
+}
+export declare const MsgHeader: MsgHeaderStatic;
+/**
+ * @class MsgHeader
+ */
+declare class MsgHeaderClass extends Value {
+    readonly owner: DocumentElement;
+    deprecated?: boolean | string;
+    required?: boolean;
+    toJSON(): OpraSchema.MsgHeader;
+}
+export {};

package/types/document/msg/msg-operation-response.d.ts

@@ -0,0 +1,41 @@
+import type { Combine, Type } from 'ts-gems';
+import { TypeThunkAsync } from 'ts-gems/lib/types';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DataType } from '../data-type/data-type.js';
+import type { MsgHeader } from './msg-header.js';
+import type { MsgOperation } from './msg-operation.js';
+/**
+ * @namespace MsgOperationResponse
+ */
+export declare namespace MsgOperationResponse {
+    interface Metadata extends Combine<{
+        payloadType?: TypeThunkAsync | string;
+        keyType?: TypeThunkAsync | string;
+        headers?: MsgHeader.Metadata[];
+    }, OpraSchema.MsgOperationResponse> {
+    }
+    interface Options extends Combine<{
+        keyType?: Type | string;
+    }, Pick<Metadata, 'channel' | 'description'>> {
+    }
+    interface InitArguments extends Combine<{
+        payloadType?: DataType | string | Type;
+        keyType?: DataType | string | Type;
+    }, Pick<Metadata, 'channel' | 'description'>> {
+    }
+}
+/**
+ * @class MsgOperationResponse
+ */
+export declare class MsgOperationResponse extends DocumentElement {
+    readonly owner: MsgOperation;
+    channel?: string | RegExp | (string | RegExp)[];
+    description?: string;
+    payloadType: DataType;
+    keyType?: DataType;
+    headers: MsgHeader[];
+    constructor(owner: MsgOperation, initArgs?: MsgOperationResponse.InitArguments);
+    findHeader(paramName: string): MsgHeader | undefined;
+    toJSON(): OpraSchema.MsgOperationResponse;
+}

package/types/document/msg/msg-operation.d.ts

@@ -0,0 +1,77 @@
+import type { Combine, ThunkAsync, Type } from 'ts-gems';
+import { TypeThunkAsync } from 'ts-gems/lib/types';
+import { OpraSchema } from '../../schema/index.js';
+import { DataTypeMap } from '../common/data-type-map.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DataType } from '../data-type/data-type.js';
+import type { EnumType } from '../data-type/enum-type.js';
+import { MsgOperationDecorator } from '../decorators/msg-operation.decorator.js';
+import type { MsgController } from './msg-controller.js';
+import type { MsgHeader } from './msg-header.js';
+import type { MsgOperationResponse } from './msg-operation-response.js';
+/**
+ * @namespace MsgOperation
+ */
+export declare namespace MsgOperation {
+    interface Metadata extends Pick<OpraSchema.MsgOperation, 'description' | 'channel'> {
+        payloadType: TypeThunkAsync | string;
+        keyType?: TypeThunkAsync | string;
+        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+        headers?: MsgHeader.Metadata[];
+        response?: MsgOperationResponse.Metadata;
+    }
+    interface Options extends Partial<Pick<Metadata, 'description' | 'keyType'>> {
+        channel?: (string | RegExp) | (string | RegExp)[];
+    }
+    interface InitArguments extends Combine<{
+        name: string;
+        types?: DataType[];
+        payloadType?: DataType | string | Type;
+        keyType?: DataType | string | Type;
+    }, Pick<Metadata, 'description' | 'channel'>> {
+    }
+}
+/**
+ * Type definition for MsgOperation
+ * @class MsgOperation
+ */
+export interface MsgOperationStatic {
+    /**
+     * Class constructor of MsgOperation
+     * @param controller
+     * @param args
+     */
+    new (controller: MsgController, args: MsgOperation.InitArguments): MsgOperation;
+    /**
+     * Property decorator
+     * @param payloadType
+     * @param options
+     */ <T extends MsgOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): MsgOperationDecorator;
+    prototype: MsgOperation;
+}
+/**
+ * @class MsgOperation
+ */
+export interface MsgOperation extends MsgOperationClass {
+}
+/**
+ *  MsgOperation
+ */
+export declare const MsgOperation: MsgOperationStatic;
+/**
+ * @class MsgOperation
+ */
+declare class MsgOperationClass extends DocumentElement {
+    readonly owner: MsgController;
+    readonly name: string;
+    channel: string | RegExp | (string | RegExp)[];
+    description?: string;
+    payloadType: DataType;
+    keyType?: DataType;
+    types: DataTypeMap;
+    headers: MsgHeader[];
+    response: MsgOperationResponse;
+    findHeader(paramName: string): MsgHeader | undefined;
+    toJSON(): OpraSchema.MsgOperation;
+}
+export {};

package/types/enums/index.d.ts

@@ -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/types/exception/http-errors/forbidden.error.d.ts

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

package/types/index.d.cts

@@ -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/types/index.d.ts

@@ -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';