@opra/common 0.33.13 → 1.0.0-alpha.1

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

@@ -0,0 +1,30 @@
+import { 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';
+export interface HttpOperationDecorator {
+    (target: Object, propertyKey: string): void;
+    Cookie(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | Type): this;
+    Header(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+    QueryParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+    PathParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+    RequestContent(type: string | Type): this;
+    RequestContent(options: HttpMediaType.Options): this;
+    MultipartContent(options?: HttpMediaType.Options, subInit?: (content: MultipartContentScope) => void): this;
+    Response(status: number | string | (number | string)[], options?: HttpOperationResponse.Options): this;
+    UseType(...type: Type[]): this;
+}
+export interface MultipartContentScope {
+    Field(fieldName: string | RegExp, options?: StrictOmit<HttpMultipartField.Options, 'fieldName' | 'fieldType'>): MultipartContentScope;
+    File(fieldName: string | RegExp, options?: StrictOmit<HttpMultipartField.Options, 'fieldName' | 'fieldType'>): MultipartContentScope;
+}
+export interface HttpOperationDecoratorFactory {
+    /**
+     * Property decorator
+     * @param decoratorChain
+     * @param options
+     */ <T extends HttpOperation.Options>(decoratorChain: Function[], options?: T): HttpOperationDecorator;
+}
+export declare function HttpOperationDecoratorFactory(decoratorChain: Function[], options?: HttpOperation.Options & Pick<HttpOperation.Metadata, 'composition' | 'compositionOptions'>): HttpOperationDecorator;

package/types/document/decorators/simple-type.decorator.d.ts

@@ -0,0 +1,20 @@
+import { OpraSchema } from '../../schema/index.js';
+import type { SimpleType } from '../data-type/simple-type';
+export interface SimpleTypeDecorator extends ClassDecorator {
+    Example(value: any, description?: string): SimpleTypeDecorator;
+}
+export interface SimpleTypeDecoratorFactory {
+    /**
+     * Class decorator method for SimpleType
+     * @param options
+     */
+    (options?: SimpleType.Options): SimpleTypeDecorator;
+}
+export declare function SimpleTypeDecoratorFactory(options?: SimpleType.Options): SimpleTypeDecorator;
+export interface AttributeDecorator extends PropertyDecorator {
+    Example(options?: Partial<OpraSchema.Attribute>): SimpleTypeDecorator;
+}
+export interface AttributeDecoratorFactory {
+    (options?: Partial<OpraSchema.Attribute>): PropertyDecorator;
+}
+export declare function AttributeDecoratorFactory(options?: Partial<OpraSchema.Attribute>): PropertyDecorator;

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

@@ -0,0 +1,35 @@
+import { PartialSome, StrictOmit, ThunkAsync } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+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';
+export declare namespace ApiDocumentFactory {
+    interface InitArguments extends PartialSome<StrictOmit<OpraSchema.ApiDocument, 'references' | 'types' | 'api'>, 'spec'> {
+        references?: Record<string, ReferenceThunk>;
+        types?: DataTypeInitSources;
+        api?: HttpApiFactory.InitArguments;
+    }
+    type ReferenceSource = string | OpraSchema.ApiDocument | InitArguments | ApiDocument;
+    type ReferenceThunk = ThunkAsync<ReferenceSource>;
+    type DataTypeInitSources = DataTypeFactory.DataTypeSources;
+}
+/**
+ * @class ApiDocumentFactory
+ */
+export declare class ApiDocumentFactory {
+    /**
+     * Creates ApiDocument instance from given schema object
+     */
+    static createDocument(schemaOrUrl: string | PartialSome<OpraSchema.ApiDocument, 'spec'> | ApiDocumentFactory.InitArguments, options?: Partial<Pick<DocumentInitContext, 'maxErrors' | 'showErrorDetails'>> | DocumentInitContext): Promise<ApiDocument>;
+    /**
+     * Downloads schema from the given URL and creates the document instance   * @param url
+     */
+    protected initDocument(document: ApiDocument, context: DocumentInitContext, schemaOrUrl: ApiDocumentFactory.InitArguments | string): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected createBuiltinDocument(context: DocumentInitContext): Promise<ApiDocument>;
+}

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

@@ -0,0 +1,103 @@
+import { Combine, ThunkAsync, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DocumentInitContext } from '../common/document-init-context.js';
+import { ApiField } from '../data-type/api-field.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import { DataType } from '../data-type/data-type.js';
+import { EnumType } from '../data-type/enum-type.js';
+import { MappedType } from '../data-type/mapped-type.js';
+import { MixinType } from '../data-type/mixin-type.js';
+import { SimpleType } from '../data-type/simple-type.js';
+/**
+ *
+ * @namespace DataTypeFactory
+ */
+export declare namespace DataTypeFactory {
+    type DataTypeSources = ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray | object>[] | Record<string, OpraSchema.DataType>;
+    type DataTypeThunk = Type | EnumType.EnumObject | EnumType.EnumArray | object;
+    interface ComplexTypeInit extends Combine<{
+        base?: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
+        fields?: Record<string, ApiFieldInit>;
+        additionalFields?: boolean | string | DataTypeFactory.DataTypeInitArguments | ['error'] | ['error', string];
+    }, ComplexType.InitArguments> {
+    }
+    interface EnumTypeInit extends Combine<{
+        base?: string | EnumTypeInit;
+    }, EnumType.InitArguments> {
+    }
+    interface MappedTypeInit extends Combine<{
+        base: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
+    }, MappedType.InitArguments> {
+    }
+    interface MixinTypeInit extends Combine<{
+        types: (string | ComplexTypeInit | MappedTypeInit | MixinTypeInit)[];
+    }, MixinType.InitArguments> {
+    }
+    interface SimpleTypeInit extends Combine<{
+        base?: string | SimpleTypeInit;
+    }, SimpleType.InitArguments> {
+    }
+    interface ApiFieldInit extends Combine<{
+        type: string | DataTypeInitArguments;
+    }, ApiField.InitArguments> {
+    }
+    type DataTypeInitArguments = ComplexTypeInit | EnumTypeInit | MappedTypeInit | MixinTypeInit | SimpleTypeInit;
+    interface Context extends DocumentInitContext {
+        importQueue?: ResponsiveMap<any>;
+        initArgsMap?: ResponsiveMap<DataTypeInitArguments>;
+    }
+}
+/**
+ *
+ * @class DataTypeFactory
+ */
+export declare class DataTypeFactory {
+    static createDataType(context: DocumentInitContext | undefined, owner: DocumentElement, thunk: DataTypeFactory.DataTypeThunk): Promise<DataType | undefined>;
+    /**
+     *
+     * @param context
+     * @param target
+     * @param types
+     */
+    static addDataTypes(context: DocumentInitContext | undefined, target: DocumentElement, types: DataTypeFactory.DataTypeSources): Promise<void>;
+    /**
+     *
+     * @param context
+     * @param owner
+     * @param types
+     */
+    static createAllDataTypes(context: DocumentInitContext | undefined, owner: DocumentElement, types: DataTypeFactory.DataTypeSources): Promise<DataType[] | undefined>;
+    /**
+     *
+     * @param ctx
+     * @param owner
+     * @param types
+     */
+    protected static _prepareAllInitArgs(ctx: DocumentInitContext, owner: DocumentElement, types: DataTypeFactory.DataTypeSources): Promise<DataTypeFactory.DataTypeInitArguments[] | void>;
+    /**
+     *
+     * @param context
+     * @param owner
+     * @param thunk
+     * @protected
+     */
+    protected static _importDataTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, thunk: string | Type | OpraSchema.DataType | object): Promise<DataTypeFactory.DataTypeInitArguments | string | void>;
+    protected static _prepareDataTypeArgs(context: DataTypeFactory.Context, initArgs: DataTypeFactory.DataTypeInitArguments, metadata: OpraSchema.DataTypeBase): Promise<void>;
+    protected static _prepareComplexTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.ComplexTypeInit, metadata: ComplexType.Metadata | OpraSchema.ComplexType): Promise<void>;
+    protected static _prepareEnumTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.EnumTypeInit, metadata: EnumType.Metadata | OpraSchema.EnumType): Promise<void>;
+    protected static _prepareSimpleTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.SimpleTypeInit, metadata: SimpleType.Metadata | OpraSchema.SimpleType): Promise<void>;
+    protected static _prepareMappedTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.MappedTypeInit, metadata: DataTypeFactory.MappedTypeInit | OpraSchema.MappedType): Promise<void>;
+    protected static _prepareMixinTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.MixinTypeInit, metadata: (MixinType.Metadata | OpraSchema.MixinType) & {
+        ctor?: Type;
+    }): Promise<void>;
+    protected static _createDataType(context: DocumentInitContext & {
+        initArgsMap?: ResponsiveMap<DataTypeFactory.DataTypeInitArguments>;
+    }, owner: DocumentElement, args: DataTypeFactory.DataTypeInitArguments | string): ComplexType | EnumType | MappedType | MixinType | SimpleType | undefined;
+    protected static _createComplexType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.ComplexTypeInit): ComplexType;
+    protected static _createEnumType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.EnumTypeInit): EnumType;
+    protected static _createMappedType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.MappedTypeInit): MappedType;
+    protected static _createMixinType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.MixinTypeInit): MixinType;
+    protected static _createSimpleType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.SimpleTypeInit): SimpleType;
+}

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

@@ -0,0 +1,60 @@
+import { StrictOmit, 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';
+import { HttpMediaType } from '../http/http-media-type.js';
+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'> {
+        controllers: Type[] | any[] | ((parent: any) => any) | OpraSchema.HttpApi['controllers'];
+    }
+}
+/**
+ * @class HttpApiFactory
+ */
+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>;
+    /**
+     * Initializes HttpOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    protected static _initHttpOperation(context: DocumentInitContext, operation: HttpOperation, metadata: HttpOperation.Metadata | OpraSchema.HttpOperation): Promise<HttpOperation>;
+    /**
+     * Initializes HttpMediaType
+     * @param context
+     * @param target
+     * @param metadata
+     * @protected
+     */
+    protected static _initHttpMediaType(context: DocumentInitContext, target: HttpMediaType, metadata: HttpMediaType.Metadata | OpraSchema.HttpMediaType): Promise<void>;
+    /**
+     * Initializes HttpOperationResponse
+     * @param context
+     * @param target
+     * @param metadata
+     * @protected
+     */
+    protected static _initHttpOperationResponse(context: DocumentInitContext, target: HttpOperationResponse, metadata: HttpOperationResponse.Metadata | OpraSchema.HttpOperationResponse): Promise<void>;
+    /**
+     * Initializes HttpRequestBody
+     * @param context
+     * @param target
+     * @param metadata
+     * @protected
+     */
+    protected static _initHttpRequestBody(context: DocumentInitContext, target: HttpRequestBody, metadata: HttpRequestBody.Metadata | OpraSchema.HttpRequestBody): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+import { StrictOmit, Type, TypeThunkAsync } from 'ts-gems';
+import type { HttpController } from '../http-controller';
+import type { HttpParameter } from '../http-parameter.js';
+export interface HttpControllerDecorator<T extends HttpControllerDecorator<any> = HttpControllerDecorator<any>> extends ClassDecorator {
+    Cookie(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | Type | false): T;
+    Header(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync | false): T;
+    QueryParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync | false): T;
+    PathParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync | false): T;
+    UseType(...type: TypeThunkAsync[]): T;
+}
+export interface HttpControllerDecoratorFactory {
+    <T extends HttpController.Options>(options?: T): HttpControllerDecorator;
+}
+export declare function HttpControllerDecoratorFactory<O extends HttpController.Options>(options?: O): HttpControllerDecorator;

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

@@ -0,0 +1,100 @@
+import { StrictOmit, Type, TypeThunkAsync } from 'ts-gems';
+import { OpraFilter } from '../../../filter/index.js';
+import { OpraSchema } from '../../../schema/index.js';
+import type { HttpParameter } from '../http-parameter';
+import { HttpRequestBody } from '../http-request-body.js';
+import { HttpOperationDecorator } from './http-operation.decorator.js';
+/** Augmentation **/
+declare module '../http-operation' {
+    /**
+     * HttpOperationConstructor
+     */
+    interface HttpOperationStatic {
+        Entity: HttpOperationEntity;
+    }
+    interface HttpOperationEntity {
+        Create(type: Type | string, options?: StrictOmit<HttpOperation.Entity.CreateArgs, 'type'>): HttpOperation.Entity.CreateDecorator;
+        Create(args: HttpOperation.Entity.CreateArgs): HttpOperation.Entity.CreateDecorator;
+        Delete(type: Type | string, options?: StrictOmit<HttpOperation.Entity.DeleteArgs, 'type'>): HttpOperation.Entity.DeleteDecorator;
+        Delete(args: HttpOperation.Entity.DeleteArgs): HttpOperation.Entity.DeleteDecorator;
+        DeleteMany(type: Type | string, options?: StrictOmit<HttpOperation.Entity.DeleteManyArgs, 'type'>): HttpOperation.Entity.DeleteManyDecorator;
+        DeleteMany(args: HttpOperation.Entity.DeleteManyArgs): HttpOperation.Entity.DeleteManyDecorator;
+        FindMany(type: Type | string, options?: StrictOmit<HttpOperation.Entity.FindManyArgs, 'type'>): HttpOperation.Entity.FindManyDecorator;
+        FindMany(args: HttpOperation.Entity.FindManyArgs): HttpOperation.Entity.FindManyDecorator;
+        Get(type: Type | string, options?: StrictOmit<HttpOperation.Entity.GetArgs, 'type'>): HttpOperation.Entity.GetDecorator;
+        Get(args: HttpOperation.Entity.GetArgs): HttpOperation.Entity.GetDecorator;
+        Update(type: Type | string, options?: StrictOmit<HttpOperation.Entity.UpdateArgs, 'type'>): HttpOperation.Entity.UpdateDecorator;
+        Update(args: HttpOperation.Entity.UpdateArgs): HttpOperation.Entity.UpdateDecorator;
+        UpdateMany(type: Type | string, options?: StrictOmit<HttpOperation.Entity.UpdateManyArgs, 'type'>): HttpOperation.Entity.UpdateManyDecorator;
+        UpdateMany(args: HttpOperation.Entity.UpdateManyArgs): HttpOperation.Entity.UpdateManyDecorator;
+    }
+    namespace HttpOperation {
+        namespace Entity {
+            /** Create */
+            interface CreateDecorator extends HttpOperationDecorator {
+            }
+            interface CreateArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                requestBody?: Pick<HttpRequestBody.Options, 'description' | 'maxContentSize'> & {
+                    type?: Type | string;
+                    immediateFetch?: boolean;
+                };
+            }
+            /** Delete */
+            interface DeleteDecorator extends HttpOperationDecorator {
+                KeyParam(name: string, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+            }
+            interface DeleteArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+            }
+            /** DeleteMany */
+            interface DeleteManyDecorator extends HttpOperationDecorator {
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface DeleteManyArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+            }
+            /** FindMany */
+            interface FindManyDecorator extends HttpOperationDecorator {
+                SortFields(...fields: OpraSchema.Field.QualifiedName[]): FindManyDecorator;
+                DefaultSort(...fields: OpraSchema.Field.QualifiedName[]): FindManyDecorator;
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface FindManyArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                defaultLimit?: number;
+                maxLimit?: number;
+            }
+            /** Get */
+            interface GetDecorator extends HttpOperationDecorator {
+                KeyParam(name: string, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+            }
+            interface GetArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+            }
+            /** Update */
+            interface UpdateDecorator extends HttpOperationDecorator {
+                KeyParam(name: string, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface UpdateArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                requestBody?: Pick<HttpRequestBody.Options, 'description' | 'maxContentSize'> & {
+                    type?: Type | string;
+                    immediateFetch?: boolean;
+                };
+            }
+            /** UpdateMany */
+            interface UpdateManyDecorator extends HttpOperationDecorator {
+                Filter(field: OpraSchema.Field.QualifiedName, operators?: OpraFilter.ComparisonOperator[] | string, notes?: string): this;
+            }
+            interface UpdateManyArgs extends StrictOmit<HttpOperation.Options, 'method' | 'requestBody'> {
+                type: Type | string;
+                requestBody?: Pick<HttpRequestBody.Options, 'description' | 'maxContentSize'> & {
+                    type?: Type | string;
+                    immediateFetch?: boolean;
+                };
+            }
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+import { StrictOmit, Type, TypeThunkAsync } from 'ts-gems';
+import { HttpMediaType } from '../http-media-type.js';
+import { HttpMultipartField } from '../http-multipart-field.js';
+import type { HttpOperation } from '../http-operation';
+import type { HttpOperationResponse } from '../http-operation-response.js';
+import type { HttpParameter } from '../http-parameter';
+export interface HttpOperationDecorator {
+    (target: Object, propertyKey: string): void;
+    Cookie(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | Type): this;
+    Header(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+    QueryParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+    PathParam(name: string | RegExp, optionsOrType?: StrictOmit<HttpParameter.Options, 'location'> | string | TypeThunkAsync): this;
+    RequestContent(type: string | Type): this;
+    RequestContent(options: HttpMediaType.Options): this;
+    MultipartContent(options?: HttpMediaType.Options, subInit?: (content: MultipartContentScope) => void): this;
+    Response(status: number | string | (number | string)[], options?: HttpOperationResponse.Options): this;
+    UseType(...type: Type[]): this;
+}
+export interface MultipartContentScope {
+    Field(fieldName: string | RegExp, options?: StrictOmit<HttpMultipartField.Options, 'fieldName' | 'fieldType'>): MultipartContentScope;
+    File(fieldName: string | RegExp, options?: StrictOmit<HttpMultipartField.Options, 'fieldName' | 'fieldType'>): MultipartContentScope;
+}
+export interface HttpOperationDecoratorFactory {
+    /**
+     * Property decorator
+     * @param decoratorChain
+     * @param options
+     */ <T extends HttpOperation.Options>(decoratorChain: Function[], options?: T): HttpOperationDecorator;
+}
+export declare function HttpOperationDecoratorFactory(decoratorChain: Function[], options?: HttpOperation.Options & Pick<HttpOperation.Metadata, 'composition' | 'compositionOptions'>): HttpOperationDecorator;

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

@@ -0,0 +1,23 @@
+import { 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';
+/**
+ * @class HttpApi
+ */
+export declare class HttpApi extends ApiBase {
+    readonly owner: ApiDocument;
+    protected _controllerReverseMap: WeakMap<Type, HttpController | null>;
+    readonly protocol = "http";
+    controllers: ResponsiveMap<HttpController>;
+    url?: string;
+    constructor(owner: ApiDocument);
+    findController(controller: Type): HttpController | undefined;
+    findController(resourcePath: string): HttpController | undefined;
+    findOperation(controller: Type, operationName: string): HttpOperation | undefined;
+    findOperation(resourcePath: string, operationName: string): HttpOperation | undefined;
+    toJSON(): OpraSchema.HttpApi;
+}

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

@@ -0,0 +1,92 @@
+import { 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 { HttpControllerDecoratorFactory } from '../decorators/http-controller.decorator.js';
+import { nodeInspectCustom } from '../utils/inspect.util.js';
+import type { HttpApi } from './http-api.js';
+import type { HttpOperation } from './http-operation';
+import { HttpParameter } from './http-parameter.js';
+/**
+ * @namespace HttpController
+ */
+export declare namespace HttpController {
+    interface Metadata extends Pick<OpraSchema.HttpController, 'description' | 'path'> {
+        name: string;
+        controllers?: (Type | ((parent: any) => any))[];
+        types?: ThunkAsync<Type | EnumType.EnumObject | EnumType.EnumArray>[];
+        operations?: Record<string, HttpOperation.Metadata>;
+        parameters?: HttpParameter.Metadata[];
+    }
+    interface Options extends Partial<Pick<OpraSchema.HttpController, 'description' | 'path'>> {
+        name?: string;
+        controllers?: (Type | ((parent: any) => any))[];
+    }
+    interface InitArguments extends Combine<{
+        instance?: object;
+        ctor?: Type;
+    }, Pick<Metadata, 'name' | 'description' | 'path'>> {
+    }
+}
+/**
+ * Type definition for HttpOperation
+ * @class HttpController
+ */
+export interface HttpControllerStatic extends HttpControllerDecoratorFactory {
+    /**
+     * Class constructor of HttpController
+     * @param owner
+     * @param args
+     */
+    new (owner: HttpApi | HttpController, args: HttpController.InitArguments): HttpController;
+    prototype: HttpController;
+}
+/**
+ * Type definition of HttpController prototype
+ * @interface HttpController
+ */
+export interface HttpController extends HttpControllerClass {
+}
+/**
+ * HttpController
+ */
+export declare const HttpController: HttpControllerStatic;
+/**
+ *
+ * @class HttpController
+ */
+declare class HttpControllerClass extends DocumentElement {
+    protected _controllerReverseMap: WeakMap<Type, HttpController | null>;
+    readonly kind: OpraSchema.HttpController.Kind;
+    readonly name: string;
+    description?: string;
+    path: string;
+    instance?: any;
+    ctor?: Type;
+    parameters: HttpParameter[];
+    operations: ResponsiveMap<HttpOperation>;
+    controllers: ResponsiveMap<HttpController>;
+    types: DataTypeMap;
+    /**
+     * @property isRoot
+     */
+    get isRoot(): boolean;
+    findController(controller: Type): HttpController | undefined;
+    findController(resourcePath: string): HttpController | undefined;
+    findParameter(paramName: string, location?: OpraSchema.HttpParameterLocation): HttpParameter | undefined;
+    /**
+     *
+     */
+    toString(): string;
+    /**
+     *
+     */
+    toJSON(): OpraSchema.HttpController;
+    /**
+     *
+     */
+    protected [nodeInspectCustom](): string;
+}
+export {};

package/types/document/http/http-media-type.d.ts

@@ -0,0 +1,59 @@
+import { Combine, StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { DocumentElement } from '../common/document-element.js';
+import { DataType } from '../data-type/data-type.js';
+import type { HttpMultipartField } from './http-multipart-field.js';
+/**
+ * @namespace HttpMediaType
+ */
+export declare namespace HttpMediaType {
+    interface Metadata extends Partial<StrictOmit<OpraSchema.HttpMediaType, 'type' | 'multipartFields'>> {
+        type?: Type | string;
+        multipartFields?: HttpMultipartField.Metadata[];
+    }
+    interface Options extends Partial<StrictOmit<OpraSchema.HttpMediaType, 'type' | 'multipartFields'>> {
+        type?: Type | string;
+    }
+    interface InitArguments extends Combine<{
+        type?: DataType | string | Type;
+    }, StrictOmit<Metadata, 'multipartFields'>> {
+    }
+}
+/**
+ * Type definition for HttpMediaType
+ * @class HttpMediaType
+ */
+interface HttpMediaTypeStatic {
+    new (parent: DocumentElement, initArgs: HttpMediaType.InitArguments): HttpMediaType;
+    prototype: HttpMediaType;
+}
+/**
+ * Type definition of HttpMediaType prototype
+ * @interface HttpMediaType
+ */
+export interface HttpMediaType extends HttpMediaTypeClass {
+}
+export declare const HttpMediaType: HttpMediaTypeStatic;
+/**
+ * @class HttpMediaType
+ */
+declare class HttpMediaTypeClass extends DocumentElement {
+    readonly owner: DocumentElement;
+    description?: string;
+    contentType?: string | string[];
+    contentEncoding?: string;
+    type?: DataType;
+    isArray?: boolean;
+    example?: string;
+    examples?: Record<string, string>;
+    multipartFields: HttpMultipartField[];
+    maxFields?: number;
+    maxFieldsSize?: number;
+    maxFiles?: number;
+    maxFileSize?: number;
+    maxTotalFileSize?: number;
+    minFileSize?: number;
+    findMultipartField(fieldName: string, fieldType?: OpraSchema.HttpMultipartFieldType): HttpMultipartField | undefined;
+    toJSON(): OpraSchema.HttpMediaType;
+}
+export {};

package/types/document/http/http-multipart-field.d.ts

@@ -0,0 +1,26 @@
+import { Combine } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { HttpMediaType } from './http-media-type.js';
+/**
+ * @namespace HttpMultipartField
+ */
+export declare namespace HttpMultipartField {
+    interface Metadata extends Combine<Pick<OpraSchema.HttpMultipartField, 'fieldName' | 'fieldType' | 'required'>, HttpMediaType.Metadata> {
+    }
+    interface Options extends Combine<Pick<OpraSchema.HttpMultipartField, 'fieldName' | 'fieldType' | 'required'>, HttpMediaType.Options> {
+    }
+    interface InitArguments extends Combine<Pick<OpraSchema.HttpMultipartField, 'fieldName' | 'fieldType' | 'required'>, HttpMediaType.InitArguments> {
+    }
+}
+/**
+ *
+ * @class HttpMultipartField
+ */
+export declare class HttpMultipartField extends HttpMediaType {
+    readonly owner: HttpMediaType | HttpMultipartField;
+    fieldName: string | RegExp;
+    fieldType: OpraSchema.HttpMultipartFieldType;
+    required?: boolean;
+    constructor(owner: HttpMediaType | HttpMultipartField, initArgs: HttpMultipartField.InitArguments);
+    toJSON(): OpraSchema.HttpMultipartField;
+}

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

@@ -0,0 +1,36 @@
+import { Combine, StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { HttpMediaType } from './http-media-type.js';
+import { HttpOperation } from './http-operation.js';
+import type { HttpParameter } from './http-parameter.js';
+import { HttpStatusRange } from './http-status-range.js';
+/**
+ * @namespace HttpOperationResponse
+ */
+export declare namespace HttpOperationResponse {
+    interface Metadata extends Combine<{
+        statusCode: number | string | (number | string)[];
+        parameters?: HttpParameter.Metadata[];
+        partial?: boolean | 'deep';
+    }, HttpMediaType.Metadata> {
+    }
+    interface Options extends HttpMediaType.Options {
+        partial?: boolean | 'deep';
+    }
+    interface InitArguments extends Combine<{
+        statusCode: number | string | HttpStatusRange | OpraSchema.HttpStatusRange | (number | string | HttpStatusRange | OpraSchema.HttpStatusRange)[];
+    }, HttpMediaType.InitArguments, StrictOmit<Metadata, 'multipartFields'>> {
+    }
+}
+/**
+ * @class HttpOperationResponse
+ */
+export declare class HttpOperationResponse extends HttpMediaType {
+    readonly owner: HttpOperation;
+    statusCode: HttpStatusRange[];
+    parameters: HttpParameter[];
+    partial?: boolean | 'deep';
+    constructor(owner: HttpOperation, init: HttpOperationResponse.InitArguments);
+    findParameter(paramName: string, location?: OpraSchema.HttpParameterLocation): HttpParameter | undefined;
+    toJSON(): OpraSchema.HttpOperationResponse;
+}