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

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

@@ -0,0 +1,32 @@
+import type { ThunkAsync, Type, TypeThunkAsync } from 'ts-gems';
+import type { RpcHeader } from '../rpc/rpc-header';
+import type { RpcOperation } from '../rpc/rpc-operation';
+import type { RpcOperationResponse } from '../rpc/rpc-operation-response';
+export interface RpcOperationDecorator {
+    (target: Object, propertyKey: string): void;
+    Header(name: string | RegExp, optionsOrType?: RpcHeader.Options | string | TypeThunkAsync): this;
+    Response(payloadType: TypeThunkAsync | string, options?: RpcOperationResponse.Options): RpcOperationResponseDecorator;
+    UseType(...type: Type[]): this;
+}
+export interface RpcOperationResponseDecorator {
+    (target: Object, propertyKey: string): void;
+    Header(name: string | RegExp, optionsOrType?: RpcHeader.Options | string | TypeThunkAsync): this;
+}
+/**
+ * @namespace RpcOperationDecoratorFactory
+ */
+export interface RpcOperationDecoratorFactory {
+    /**
+     * Property decorator
+     * @param decoratorChain
+     * @param payloadType
+     * @param options
+     */ <T extends RpcOperation.Options>(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: T): RpcOperationDecorator;
+}
+export declare namespace RpcOperationDecoratorFactory {
+    type AugmentationFunction = (decorator: RpcOperationDecorator, decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: RpcOperation.Options) => void;
+}
+export declare function RpcOperationDecoratorFactory(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string | TypeThunkAsync, options?: RpcOperation.Options): RpcOperationDecorator;
+export declare namespace RpcOperationDecoratorFactory {
+    var augment: (fn: RpcOperationDecoratorFactory.AugmentationFunction) => void;
+}

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

@@ -4,12 +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';
+import { RpcApiFactory } from './rpc-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?: StrictOmit<HttpApiFactory.InitArguments, 'owner'> | StrictOmit<MsgApiFactory.InitArguments, 'owner'>;
+        api?: StrictOmit<HttpApiFactory.InitArguments, 'owner'> | StrictOmit<RpcApiFactory.InitArguments, 'owner'>;
     }
     type ReferenceSource = string | OpraSchema.ApiDocument | InitArguments | ApiDocument;
     type ReferenceThunk = ThunkAsync<ReferenceSource>;

package/types/document/factory/rpc-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 { RpcApi } from '../rpc/rpc-api.js';
+import { RpcController } from '../rpc/rpc-controller.js';
+import { RpcOperation } from '../rpc/rpc-operation.js';
+import { RpcOperationResponse } from '../rpc/rpc-operation-response.js';
+export declare namespace RpcApiFactory {
+    interface InitArguments extends RpcApi.InitArguments {
+        controllers: Type[] | any[] | ((parent: any) => any) | OpraSchema.RpcApi['controllers'];
+    }
+}
+/**
+ * @class RpcApiFactory
+ */
+export declare class RpcApiFactory {
+    /**
+     * Generates RpcApi
+     * @param context
+     * @param init
+     */
+    static createApi(context: DocumentInitContext, init: RpcApiFactory.InitArguments): Promise<RpcApi>;
+    protected static _createController(context: DocumentInitContext, parent: RpcApi, thunk: Type | object | Function | OpraSchema.RpcController, name?: string): Promise<RpcController | undefined | void>;
+    /**
+     * Initializes RpcOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    protected static _initRpcOperation(context: DocumentInitContext, operation: RpcOperation, metadata: RpcOperation.Metadata | OpraSchema.RpcOperation): Promise<void>;
+    /**
+     * Initializes RpcOperationResponse
+     * @param context
+     * @param response
+     * @param metadata
+     * @protected
+     */
+    protected static _initRpcOperationResponse(context: DocumentInitContext, response: RpcOperationResponse, metadata: RpcOperationResponse.Metadata | OpraSchema.RpcOperationResponse): Promise<void>;
+}

package/types/document/index.d.ts

@@ -1,5 +1,6 @@
 import 'reflect-metadata';
-import * as MsgOperationDecorator_ from './decorators/msg-operation.decorator.js';
+import * as RpcControllerDecorator_ from './decorators/rpc-controller.decorator.js';
+import * as RpcOperationDecorator_ from './decorators/rpc-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';
@@ -24,7 +25,8 @@ 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 type { RpcControllerDecorator } from './decorators/rpc-controller.decorator.js';
+export type { RpcOperationDecorator } from './decorators/rpc-operation.decorator.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
 export * from './http/http-controller.js';
@@ -35,13 +37,14 @@ 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 * from './rpc/rpc-api.js';
+export * from './rpc/rpc-controller.js';
+export * from './rpc/rpc-header.js';
+export * from './rpc/rpc-operation.js';
+export type { RpcOperationResponse } from './rpc/rpc-operation-response';
 export declare namespace classes {
     export import HttpApiFactory = HttpApiFactory_.HttpApiFactory;
     export import DataTypeFactory = DataTypeFactory_.DataTypeFactory;
-    export import MsgOperationDecoratorFactory = MsgOperationDecorator_.MsgOperationDecoratorFactory;
+    export import RpcOperationDecoratorFactory = RpcOperationDecorator_.RpcOperationDecoratorFactory;
+    export import RpcControllerDecoratorFactory = RpcControllerDecorator_.RpcControllerDecoratorFactory;
 }

package/types/document/rpc/rpc-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 { RpcController } from './rpc-controller.js';
+import { RpcOperation } from './rpc-operation.js';
+export declare namespace RpcApi {
+    interface InitArguments extends ApiBase.InitArguments, StrictOmit<OpraSchema.RpcApi, 'controllers'> {
+    }
+}
+/**
+ * @class RpcApi
+ */
+export declare class RpcApi extends ApiBase {
+    protected _controllerReverseMap: WeakMap<Type, RpcController | null>;
+    readonly owner: ApiDocument;
+    readonly transport = "rpc";
+    platform: string;
+    controllers: ResponsiveMap<RpcController>;
+    constructor(init: RpcApi.InitArguments);
+    findController(controller: Type): RpcController | undefined;
+    findController(name: string): RpcController | undefined;
+    findOperation(controller: Type, operationName: string): RpcOperation | undefined;
+    findOperation(controllerName: string, operationName: string): RpcOperation | undefined;
+    toJSON(): OpraSchema.RpcApi;
+}

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

package/types/document/{msg/msg-header.d.ts → rpc/rpc-header.d.ts}

@@ -5,10 +5,10 @@ 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
+ * @namespace RpcHeader
  */
-export declare namespace MsgHeader {
-    interface Metadata extends StrictOmit<OpraSchema.MsgHeader, 'type'> {
+export declare namespace RpcHeader {
+    interface Metadata extends StrictOmit<OpraSchema.RpcHeader, 'type'> {
         name: string | RegExp;
         type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
     }
@@ -21,27 +21,27 @@ export declare namespace MsgHeader {
     }
 }
 /**
- * Type definition for MsgHeader
- * @class MsgHeader
+ * Type definition for RpcHeader
+ * @class RpcHeader
  */
-interface MsgHeaderStatic {
-    new (owner: DocumentElement, args: MsgHeader.InitArguments): MsgHeader;
-    prototype: MsgHeader;
+interface RpcHeaderStatic {
+    new (owner: DocumentElement, args: RpcHeader.InitArguments): RpcHeader;
+    prototype: RpcHeader;
 }
 /**
- * Type definition of MsgHeader prototype
- * @interface MsgHeader
+ * Type definition of RpcHeader prototype
+ * @interface RpcHeader
  */
-export interface MsgHeader extends MsgHeaderClass {
+export interface RpcHeader extends RpcHeaderClass {
 }
-export declare const MsgHeader: MsgHeaderStatic;
+export declare const RpcHeader: RpcHeaderStatic;
 /**
- * @class MsgHeader
+ * @class RpcHeader
  */
-declare class MsgHeaderClass extends Value {
+declare class RpcHeaderClass extends Value {
     readonly owner: DocumentElement;
     deprecated?: boolean | string;
     required?: boolean;
-    toJSON(): OpraSchema.MsgHeader;
+    toJSON(): OpraSchema.RpcHeader;
 }
 export {};

package/types/document/{msg/msg-operation-response.d.ts → rpc/rpc-operation-response.d.ts}

@@ -3,17 +3,17 @@ 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';
+import type { RpcHeader } from './rpc-header';
+import type { RpcOperation } from './rpc-operation';
 /**
- * @namespace MsgOperationResponse
+ * @namespace RpcOperationResponse
  */
-export declare namespace MsgOperationResponse {
+export declare namespace RpcOperationResponse {
     interface Metadata extends Combine<{
         payloadType?: TypeThunkAsync | string;
         keyType?: TypeThunkAsync | string;
-        headers?: MsgHeader.Metadata[];
-    }, OpraSchema.MsgOperationResponse> {
+        headers?: RpcHeader.Metadata[];
+    }, OpraSchema.RpcOperationResponse> {
     }
     interface Options extends Combine<{
         keyType?: Type | string;
@@ -26,16 +26,16 @@ export declare namespace MsgOperationResponse {
     }
 }
 /**
- * @class MsgOperationResponse
+ * @class RpcOperationResponse
  */
-export declare class MsgOperationResponse extends DocumentElement {
-    readonly owner: MsgOperation;
+export declare class RpcOperationResponse extends DocumentElement {
+    readonly owner: RpcOperation;
     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;
+    headers: RpcHeader[];
+    constructor(owner: RpcOperation, initArgs?: RpcOperationResponse.InitArguments);
+    findHeader(paramName: string): RpcHeader | undefined;
+    toJSON(): OpraSchema.RpcOperationResponse;
 }

package/types/document/{msg/msg-operation.d.ts → rpc/rpc-operation.d.ts}

@@ -5,20 +5,20 @@ 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';
+import { RpcOperationDecorator } from '../decorators/rpc-operation.decorator.js';
+import type { RpcController } from './rpc-controller';
+import type { RpcHeader } from './rpc-header';
+import type { RpcOperationResponse } from './rpc-operation-response';
 /**
- * @namespace MsgOperation
+ * @namespace RpcOperation
  */
-export declare namespace MsgOperation {
-    interface Metadata extends Pick<OpraSchema.MsgOperation, 'description' | 'channel'> {
+export declare namespace RpcOperation {
+    interface Metadata extends Pick<OpraSchema.RpcOperation, 'description' | 'channel'> {
         payloadType: TypeThunkAsync | string;
         keyType?: TypeThunkAsync | string;
         types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
-        headers?: MsgHeader.Metadata[];
-        response?: MsgOperationResponse.Metadata;
+        headers?: RpcHeader.Metadata[];
+        response?: RpcOperationResponse.Metadata;
     }
     interface Options extends Partial<Pick<Metadata, 'description' | 'keyType'>> {
         channel?: (string | RegExp) | (string | RegExp)[];
@@ -32,46 +32,46 @@ export declare namespace MsgOperation {
     }
 }
 /**
- * Type definition for MsgOperation
- * @class MsgOperation
+ * Type definition for RpcOperation
+ * @class RpcOperation
  */
-export interface MsgOperationStatic {
+export interface RpcOperationStatic {
     /**
-     * Class constructor of MsgOperation
+     * Class constructor of RpcOperation
      * @param controller
      * @param args
      */
-    new (controller: MsgController, args: MsgOperation.InitArguments): MsgOperation;
+    new (controller: RpcController, args: RpcOperation.InitArguments): RpcOperation;
     /**
      * Property decorator
      * @param payloadType
      * @param options
-     */ <T extends MsgOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): MsgOperationDecorator;
-    prototype: MsgOperation;
+     */ <T extends RpcOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): RpcOperationDecorator;
+    prototype: RpcOperation;
 }
 /**
- * @class MsgOperation
+ * @class RpcOperation
  */
-export interface MsgOperation extends MsgOperationClass {
+export interface RpcOperation extends RpcOperationClass {
 }
 /**
- *  MsgOperation
+ *  RpcOperation
  */
-export declare const MsgOperation: MsgOperationStatic;
+export declare const RpcOperation: RpcOperationStatic;
 /**
- * @class MsgOperation
+ * @class RpcOperation
  */
-declare class MsgOperationClass extends DocumentElement {
-    readonly owner: MsgController;
+declare class RpcOperationClass extends DocumentElement {
+    readonly owner: RpcController;
     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;
+    headers: RpcHeader[];
+    response: RpcOperationResponse;
+    findHeader(paramName: string): RpcHeader | undefined;
+    toJSON(): OpraSchema.RpcOperation;
 }
 export {};

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

@@ -1,16 +1,14 @@
 import type { SpecVersion } from './constants.js';
 import type { DataTypeContainer } from './data-type-container.interface.js';
 import type { HttpController } from './http/http-controller.interface.js';
-import type { MsgController } from './msg/msg-controller.interface.js';
+import type { RpcController } from './rpc/rpc-controller.interface.js';
 export type Transport = 
 /** HTTP **/
 'http'
 /** WebSocket*/
  | 'ws'
-/** Remote Procedure Call */
- | 'rpc'
-/** Message (Kafka, RabbitMQ, MQTT etc) */
- | 'msg';
+/** Remote Procedure Call (Kafka, RabbitMQ, MQTT etc) */
+ | 'rpc';
 /**
  * @interface ApiDocument
  */
@@ -20,7 +18,7 @@ export interface ApiDocument extends DataTypeContainer {
     url?: string;
     info?: DocumentInfo;
     references?: Record<string, DocumentReference>;
-    api?: HttpApi | MsgApi;
+    api?: HttpApi | RpcApi;
 }
 /**
  * @interface DocumentInfo
@@ -77,14 +75,14 @@ export interface HttpApi extends Api {
 }
 /**
  * Message Api (Kafka, RabbitMQ, MQTT etc)
- * @interface MsgApi
+ * @interface RpcApi
  */
-export interface MsgApi extends Api {
-    transport: 'msg';
+export interface RpcApi extends Api {
+    transport: 'rpc';
     /**
-     * Name of the message platform. (Kafka, RabbitMQ, etc.)
+     * Name of the platform. (Kafka, RabbitMQ, etc.)
      */
     platform: string;
     description?: string;
-    controllers: Record<string, MsgController>;
+    controllers: Record<string, RpcController>;
 }

package/types/schema/opra-schema.d.ts

@@ -16,9 +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 './rpc/rpc-controller.interface.js';
+export * from './rpc/rpc-header.interface.js';
+export * from './rpc/rpc-operation.interface.js';
 export * from './type-guards.js';
 export * from './types.js';
 export * from './value.interface.js';

package/types/schema/rpc/rpc-controller.interface.d.ts

@@ -0,0 +1,22 @@
+import type { DataTypeContainer } from '../data-type-container.interface.js';
+import type { RpcHeader } from './rpc-header.interface.js';
+import type { RpcOperation } from './rpc-operation.interface.js';
+/**
+ * RPC Controller
+ * @interface RpcController
+ */
+export interface RpcController extends DataTypeContainer {
+    kind: RpcController.Kind;
+    description?: string;
+    operations?: Record<string, RpcOperation>;
+    headers?: RpcHeader[];
+}
+/**
+ *
+ * @namespace RpcController
+ */
+export declare namespace RpcController {
+    type Name = string;
+    const Kind = "RpcController";
+    type Kind = 'RpcController';
+}

package/types/schema/{msg/msg-header.interface.d.ts → rpc/rpc-header.interface.d.ts}

@@ -1,9 +1,9 @@
 import type { Value } from '../value.interface.js';
 /**
  *
- * @interface MsgHeader
+ * @interface RpcHeader
  */
-export interface MsgHeader extends Value {
+export interface RpcHeader extends Value {
     /**
      * Name of the parameter. RegExp pattern can be used matching parameter name
      */

package/types/schema/{msg/msg-operation.interface.d.ts → rpc/rpc-operation.interface.d.ts}

@@ -1,26 +1,26 @@
 import { DataType } from '../data-type/data-type.interface.js';
 import type { DataTypeContainer } from '../data-type-container.interface.js';
-import type { MsgHeader } from './msg-header.interface.js';
+import type { RpcHeader } from './rpc-header.interface.js';
 /**
- * @interface MsgOperation
+ * @interface RpcOperation
  */
-export interface MsgOperation extends DataTypeContainer {
-    kind: MsgOperation.Kind;
+export interface RpcOperation extends DataTypeContainer {
+    kind: RpcOperation.Kind;
     description?: string;
     channel: string | RegExp | (string | RegExp)[];
     payloadType: string | DataType;
     keyType?: string | DataType;
-    headers?: MsgHeader[];
-    response?: MsgOperationResponse;
+    headers?: RpcHeader[];
+    response?: RpcOperationResponse;
 }
-export interface MsgOperationResponse {
+export interface RpcOperationResponse {
     description?: string;
     channel?: string | RegExp | (string | RegExp)[];
     payloadType: string | DataType;
     keyType?: string | DataType;
-    headers?: MsgHeader[];
+    headers?: RpcHeader[];
 }
-export declare namespace MsgOperation {
-    const Kind = "MsgOperation";
-    type Kind = 'MsgOperation';
+export declare namespace RpcOperation {
+    const Kind = "RpcOperation";
+    type Kind = 'RpcOperation';
 }

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsgController = void 0;
-/**
- *
- * @namespace MsgController
- */
-var MsgController;
-(function (MsgController) {
-    MsgController.Kind = 'MsgController';
-})(MsgController || (exports.MsgController = MsgController = {}));

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MsgOperation = void 0;
-var MsgOperation;
-(function (MsgOperation) {
-    MsgOperation.Kind = 'MsgOperation';
-})(MsgOperation || (exports.MsgOperation = MsgOperation = {}));

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

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

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

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

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

@@ -1,11 +0,0 @@
-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;