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

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

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

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

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.4",
   "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 { RpcApi } from './rpc/rpc-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 | RpcApi;
     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 rpcApi(): RpcApi;
     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 RPC_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/rpc-controller.decorator.d.ts

@@ -0,0 +1,20 @@
+import type { TypeThunkAsync } from 'ts-gems';
+import type { RpcController } from '../rpc/rpc-controller';
+import type { RpcHeader } from '../rpc/rpc-header';
+export interface RpcControllerDecorator<T extends RpcControllerDecorator<any> = RpcControllerDecorator<any>> extends ClassDecorator {
+    Header(name: string | RegExp, optionsOrType?: RpcHeader.Options | string | TypeThunkAsync | false): T;
+    UseType(...type: TypeThunkAsync[]): T;
+}
+export interface RpcControllerDecoratorFactory {
+    <T extends RpcController.Options>(options?: T): RpcControllerDecorator;
+}
+/**
+ * @namespace RpcControllerDecoratorFactory
+ */
+export declare namespace RpcControllerDecoratorFactory {
+    type AugmentationFunction = (decorator: RpcControllerDecorator, decoratorChain: Function[], options?: RpcController.Options) => void;
+}
+export declare function RpcControllerDecoratorFactory<O extends RpcController.Options>(options?: O): RpcControllerDecorator;
+export declare namespace RpcControllerDecoratorFactory {
+    var augment: (fn: RpcControllerDecoratorFactory.AugmentationFunction) => void;
+}

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,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 { 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?: HttpApiFactory.InitArguments;
+        api?: StrictOmit<HttpApiFactory.InitArguments, 'owner'> | StrictOmit<RpcApiFactory.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/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/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,6 @@
 import 'reflect-metadata';
+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';
@@ -23,6 +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 { 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';
@@ -33,7 +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 './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 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/rpc/rpc-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 RpcHeader
+ */
+export declare namespace RpcHeader {
+    interface Metadata extends StrictOmit<OpraSchema.RpcHeader, '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 RpcHeader
+ * @class RpcHeader
+ */
+interface RpcHeaderStatic {
+    new (owner: DocumentElement, args: RpcHeader.InitArguments): RpcHeader;
+    prototype: RpcHeader;
+}
+/**
+ * Type definition of RpcHeader prototype
+ * @interface RpcHeader
+ */
+export interface RpcHeader extends RpcHeaderClass {
+}
+export declare const RpcHeader: RpcHeaderStatic;
+/**
+ * @class RpcHeader
+ */
+declare class RpcHeaderClass extends Value {
+    readonly owner: DocumentElement;
+    deprecated?: boolean | string;
+    required?: boolean;
+    toJSON(): OpraSchema.RpcHeader;
+}
+export {};

package/types/document/rpc/rpc-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 { RpcHeader } from './rpc-header';
+import type { RpcOperation } from './rpc-operation';
+/**
+ * @namespace RpcOperationResponse
+ */
+export declare namespace RpcOperationResponse {
+    interface Metadata extends Combine<{
+        payloadType?: TypeThunkAsync | string;
+        keyType?: TypeThunkAsync | string;
+        headers?: RpcHeader.Metadata[];
+    }, OpraSchema.RpcOperationResponse> {
+    }
+    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 RpcOperationResponse
+ */
+export declare class RpcOperationResponse extends DocumentElement {
+    readonly owner: RpcOperation;
+    channel?: string | RegExp | (string | RegExp)[];
+    description?: string;
+    payloadType: DataType;
+    keyType?: DataType;
+    headers: RpcHeader[];
+    constructor(owner: RpcOperation, initArgs?: RpcOperationResponse.InitArguments);
+    findHeader(paramName: string): RpcHeader | undefined;
+    toJSON(): OpraSchema.RpcOperationResponse;
+}

package/types/document/rpc/rpc-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 { 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 RpcOperation
+ */
+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?: RpcHeader.Metadata[];
+        response?: RpcOperationResponse.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 RpcOperation
+ * @class RpcOperation
+ */
+export interface RpcOperationStatic {
+    /**
+     * Class constructor of RpcOperation
+     * @param controller
+     * @param args
+     */
+    new (controller: RpcController, args: RpcOperation.InitArguments): RpcOperation;
+    /**
+     * Property decorator
+     * @param payloadType
+     * @param options
+     */ <T extends RpcOperation.Options>(payloadType: ThunkAsync<Type> | string, options?: T): RpcOperationDecorator;
+    prototype: RpcOperation;
+}
+/**
+ * @class RpcOperation
+ */
+export interface RpcOperation extends RpcOperationClass {
+}
+/**
+ *  RpcOperation
+ */
+export declare const RpcOperation: RpcOperationStatic;
+/**
+ * @class RpcOperation
+ */
+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: RpcHeader[];
+    response: RpcOperationResponse;
+    findHeader(paramName: string): RpcHeader | undefined;
+    toJSON(): OpraSchema.RpcOperation;
+}
+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';