@opra/common 1.19.4 → 1.19.7

package/types/filter/antlr/OpraFilterVisitor.d.ts

@@ -1,31 +1,31 @@
 import { ParseTreeVisitor } from '@browsery/antlr4';
-import type { RootContext } from "./OpraFilterParser.js";
-import type { ParenthesizedExpressionContext } from "./OpraFilterParser.js";
-import type { NegativeExpressionContext } from "./OpraFilterParser.js";
-import type { ComparisonExpressionContext } from "./OpraFilterParser.js";
-import type { LogicalExpressionContext } from "./OpraFilterParser.js";
-import type { ComparisonLeftContext } from "./OpraFilterParser.js";
-import type { ComparisonRightContext } from "./OpraFilterParser.js";
-import type { ParenthesizedItemContext } from "./OpraFilterParser.js";
-import type { NumberLiteralContext } from "./OpraFilterParser.js";
-import type { InfinityLiteralContext } from "./OpraFilterParser.js";
-import type { BooleanLiteralContext } from "./OpraFilterParser.js";
-import type { NullLiteralContext } from "./OpraFilterParser.js";
-import type { DateTimeLiteralContext } from "./OpraFilterParser.js";
-import type { DateLiteralContext } from "./OpraFilterParser.js";
-import type { TimeLiteralContext } from "./OpraFilterParser.js";
-import type { StringLiteralContext } from "./OpraFilterParser.js";
-import type { QualifiedIdentifierContext } from "./OpraFilterParser.js";
-import type { ExternalConstantContext } from "./OpraFilterParser.js";
-import type { IdentifierContext } from "./OpraFilterParser.js";
-import type { ArrayValueContext } from "./OpraFilterParser.js";
-import type { BooleanContext } from "./OpraFilterParser.js";
-import type { NullContext } from "./OpraFilterParser.js";
-import type { InfinityContext } from "./OpraFilterParser.js";
-import type { ArithmeticOperatorContext } from "./OpraFilterParser.js";
-import type { ComparisonOperatorContext } from "./OpraFilterParser.js";
-import type { LogicalOperatorContext } from "./OpraFilterParser.js";
-import type { PolarityOperatorContext } from "./OpraFilterParser.js";
+import type { RootContext } from './OpraFilterParser.js';
+import type { ParenthesizedExpressionContext } from './OpraFilterParser.js';
+import type { NegativeExpressionContext } from './OpraFilterParser.js';
+import type { ComparisonExpressionContext } from './OpraFilterParser.js';
+import type { LogicalExpressionContext } from './OpraFilterParser.js';
+import type { ComparisonLeftContext } from './OpraFilterParser.js';
+import type { ComparisonRightContext } from './OpraFilterParser.js';
+import type { ParenthesizedItemContext } from './OpraFilterParser.js';
+import type { NumberLiteralContext } from './OpraFilterParser.js';
+import type { InfinityLiteralContext } from './OpraFilterParser.js';
+import type { BooleanLiteralContext } from './OpraFilterParser.js';
+import type { NullLiteralContext } from './OpraFilterParser.js';
+import type { DateTimeLiteralContext } from './OpraFilterParser.js';
+import type { DateLiteralContext } from './OpraFilterParser.js';
+import type { TimeLiteralContext } from './OpraFilterParser.js';
+import type { StringLiteralContext } from './OpraFilterParser.js';
+import type { QualifiedIdentifierContext } from './OpraFilterParser.js';
+import type { ExternalConstantContext } from './OpraFilterParser.js';
+import type { IdentifierContext } from './OpraFilterParser.js';
+import type { ArrayValueContext } from './OpraFilterParser.js';
+import type { BooleanContext } from './OpraFilterParser.js';
+import type { NullContext } from './OpraFilterParser.js';
+import type { InfinityContext } from './OpraFilterParser.js';
+import type { ArithmeticOperatorContext } from './OpraFilterParser.js';
+import type { ComparisonOperatorContext } from './OpraFilterParser.js';
+import type { LogicalOperatorContext } from './OpraFilterParser.js';
+import type { PolarityOperatorContext } from './OpraFilterParser.js';
 /**
  * This interface defines a complete generic visitor for a parse tree produced
  * by `OpraFilterParser`.

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

@@ -1,16 +1,8 @@
 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 { RpcController } from './rpc/rpc-controller.interface.js';
-export type Transport = 
-/** Custom **/
-'custom'
-/** HTTP **/
- | 'http'
-/** WebSocket*/
- | 'ws'
-/** Remote Procedure Call (Kafka, RabbitMQ, MQTT etc) */
- | 'rpc';
+import type { HttpApi } from './http/http-api.interface.js';
+import type { MQApi } from './mq/mq-api.interface.js';
+import type { WSApi } from './ws/ws-api.interface.js';
 /**
  * @interface ApiDocument
  */
@@ -20,7 +12,7 @@ export interface ApiDocument extends DataTypeContainer {
     url?: string;
     info?: DocumentInfo;
     references?: Record<string, DocumentReference>;
-    api?: HttpApi | RpcApi;
+    api?: HttpApi | MQApi | WSApi;
 }
 /**
  * @interface DocumentInfo
@@ -54,37 +46,3 @@ export interface LicenseInfo {
  */
 export interface DocumentReference extends Pick<ApiDocument, 'id' | 'url' | 'info'> {
 }
-/**
- * @interface Api
- */
-export interface Api extends DataTypeContainer {
-    transport: Transport;
-    /**
-     * Name of the api. Should be a computer friendly name
-     */
-    name: string;
-    description?: string;
-}
-/**
- * HTTP Api
- * @interface HttpApi
- */
-export interface HttpApi extends Api {
-    transport: 'http';
-    description?: string;
-    url?: string;
-    controllers: Record<string, HttpController>;
-}
-/**
- * Message Api (Kafka, RabbitMQ, MQTT etc)
- * @interface RpcApi
- */
-export interface RpcApi extends Api {
-    transport: 'rpc';
-    /**
-     * Name of the platform. (Kafka, RabbitMQ, etc.)
-     */
-    platform: string;
-    description?: string;
-    controllers: Record<string, RpcController>;
-}

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

@@ -0,0 +1,13 @@
+import { DataTypeContainer } from './data-type-container.interface.js';
+import { Transport } from './types.js';
+/**
+ * @interface Api
+ */
+export interface Api extends DataTypeContainer {
+    transport: Transport;
+    /**
+     * Name of the api. Should be a computer-friendly name
+     */
+    name: string;
+    description?: string;
+}

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

@@ -0,0 +1,12 @@
+import type { Api } from '../api.interface.js';
+import type { HttpController } from './http-controller.interface.js';
+/**
+ * HTTP Api
+ * @interface HttpApi
+ */
+export interface HttpApi extends Api {
+    transport: 'http';
+    description?: string;
+    url?: string;
+    controllers: Record<string, HttpController>;
+}

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

@@ -0,0 +1,15 @@
+import type { Api } from '../api.interface.js';
+import type { MQController } from './mq-controller.interface.js';
+/**
+ * Message Queue Api
+ * @interface MQApi
+ */
+export interface MQApi extends Api {
+    transport: 'mq';
+    /**
+     * Name of the platform. (Kafka, RabbitMQ, etc.)
+     */
+    platform: string;
+    description?: string;
+    controllers: Record<string, MQController>;
+}

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

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

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

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

package/types/schema/{rpc/rpc-operation.interface.d.ts → mq/mq-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 { RpcHeader } from './rpc-header.interface.js';
+import type { MQHeader } from './mq-header.interface.js';
 /**
- * @interface RpcOperation
+ * @interface MQOperation
  */
-export interface RpcOperation extends DataTypeContainer {
-    kind: RpcOperation.Kind;
+export interface MQOperation extends DataTypeContainer {
+    kind: MQOperation.Kind;
     description?: string;
     channel: string | RegExp | (string | RegExp)[];
     payloadType: string | DataType;
     keyType?: string | DataType;
-    headers?: RpcHeader[];
-    response?: RpcOperationResponse;
+    headers?: MQHeader[];
+    response?: MQOperationResponse;
 }
-export interface RpcOperationResponse {
+export interface MQOperationResponse {
     description?: string;
     channel?: string | RegExp | (string | RegExp)[];
     payloadType: string | DataType;
     keyType?: string | DataType;
-    headers?: RpcHeader[];
+    headers?: MQHeader[];
 }
-export declare namespace RpcOperation {
-    const Kind = "RpcOperation";
-    type Kind = 'RpcOperation';
+export declare namespace MQOperation {
+    const Kind = "MQOperation";
+    type Kind = 'MQOperation';
 }

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

@@ -1,3 +1,4 @@
+export * from './api.interface.js';
 export * from './api-document.interface.js';
 export * from './constants.js';
 export * from './data-type/complex-type.interface.js';
@@ -9,6 +10,7 @@ export * from './data-type/mixin-type.interface.js';
 export * from './data-type/simple-type.interface.js';
 export * from './data-type/union-type.interface.js';
 export * from './data-type-container.interface.js';
+export * from './http/http-api.interface.js';
 export * from './http/http-controller.interface.js';
 export * from './http/http-media-type.interface.js';
 export * from './http/http-multipart-field.interface.js';
@@ -17,9 +19,13 @@ 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 './rpc/rpc-controller.interface.js';
-export * from './rpc/rpc-header.interface.js';
-export * from './rpc/rpc-operation.interface.js';
+export * from './mq/mq-api.interface.js';
+export * from './mq/mq-controller.interface.js';
+export * from './mq/mq-header.interface.js';
+export * from './mq/mq-operation.interface.js';
 export * from './type-guards.js';
 export * from './types.js';
 export * from './value.interface.js';
+export * from './ws/ws-api.interface.js';
+export * from './ws/ws-controller.interface.js';
+export * from './ws/ws-operation.interface.js';

package/types/schema/types.d.ts

@@ -1,3 +1,14 @@
 export type HttpMethod = 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'POST' | 'PUT' | 'PATCH' | 'SEARCH';
 export type HttpParameterLocation = 'cookie' | 'header' | 'query' | 'path';
 export type HttpMultipartFieldType = 'field' | 'file';
+export type Transport = 
+/** Custom **/
+'custom'
+/** HTTP **/
+ | 'http'
+/** WebSocket*/
+ | 'ws'
+/** Message Queue (Kafka, RabbitMQ, MQTT etc) */
+ | 'mq'
+/** Remote Procedure Call (gRPC etc) */
+ | 'rpc';

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

@@ -0,0 +1,11 @@
+import type { Api } from '../api.interface.js';
+import { WSController } from './ws-controller.interface.js';
+/**
+ * WebSocket Api
+ * @interface WSApi
+ */
+export interface WSApi extends Api {
+    transport: 'ws';
+    description?: string;
+    controllers: Record<string, WSController>;
+}

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

@@ -0,0 +1,20 @@
+import type { DataTypeContainer } from '../data-type-container.interface.js';
+import type { WSOperation } from './ws-operation.interface.js';
+/**
+ * WebSocket Controller
+ * @interface WSController
+ */
+export interface WSController extends DataTypeContainer {
+    kind: WSController.Kind;
+    description?: string;
+    operations?: Record<string, WSOperation>;
+}
+/**
+ *
+ * @namespace WSController
+ */
+export declare namespace WSController {
+    type Name = string;
+    const Kind = "WSController";
+    type Kind = 'WSController';
+}

package/types/schema/ws/ws-operation.interface.d.ts

@@ -0,0 +1,15 @@
+import { DataType } from '../data-type/data-type.interface.js';
+import type { DataTypeContainer } from '../data-type-container.interface.js';
+/**
+ * @interface WSOperation
+ */
+export interface WSOperation extends DataTypeContainer {
+    kind: WSOperation.Kind;
+    description?: string;
+    channel: string | RegExp | (string | RegExp)[];
+    payloadType: string | DataType;
+}
+export declare namespace WSOperation {
+    const Kind = "WSOperation";
+    type Kind = 'WSOperation';
+}

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

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

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

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

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

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

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

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

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

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

@@ -1,32 +0,0 @@
-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/rpc-api.factory.d.ts

@@ -1,40 +0,0 @@
-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/rpc/rpc-api.d.ts

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

@@ -1,83 +0,0 @@
-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[];
-    }
-    interface Options extends Partial<Pick<OpraSchema.RpcController, 'description'>> {
-        name?: string;
-    }
-    interface InitArguments extends Combine<{
-        instance?: object;
-        ctor?: Type;
-    }, Pick<Metadata, 'name' | 'description'>> {
-    }
-}
-/**
- * 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;
-}
-/**
- * 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;
-    findHeader(paramName: string, location?: OpraSchema.HttpParameterLocation): RpcHeader | undefined;
-    /**
-     *
-     */
-    toString(): string;
-    /**
-     *
-     */
-    toJSON(): OpraSchema.RpcController;
-    /**
-     *
-     */
-    protected [nodeInspectCustom](): string;
-}
-export {};

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

@@ -1,22 +0,0 @@
-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';
-}