@opra/common 1.19.7 → 1.20.0

package/esm/document/mq/mq-operation.js

@@ -1,5 +1,6 @@
 import { omitUndefined } from '@jsopen/objects';
 import { asMutable } from 'ts-gems';
+import { vg } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import { DataTypeMap } from '../common/data-type-map.js';
 import { DocumentElement } from '../common/document-element.js';
@@ -12,9 +13,9 @@ import { MQOperationDecoratorFactory, } from '../decorators/mq-operation.decorat
 export const MQOperation = function (...args) {
     // Decorator
     if (!this) {
-        const [payloadType, options] = args;
+        const [type, options] = args;
         const decoratorChain = [];
-        return MQOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
+        return MQOperation[DECORATOR].call(undefined, decoratorChain, type, options);
     }
     // Constructor
     const [resource, initArgs] = args;
@@ -27,11 +28,11 @@ export const MQOperation = function (...args) {
     _this.name = initArgs.name;
     _this.description = initArgs.description;
     _this.channel = initArgs.channel;
-    if (initArgs?.payloadType) {
-        _this.payloadType =
-            initArgs?.payloadType instanceof DataType
-                ? initArgs.payloadType
-                : _this.owner.node.getDataType(initArgs.payloadType);
+    if (initArgs?.type) {
+        _this.type =
+            initArgs?.type instanceof DataType
+                ? initArgs.type
+                : _this.owner.node.getDataType(initArgs.type);
     }
     if (initArgs?.keyType) {
         _this.keyType =
@@ -39,6 +40,8 @@ export const MQOperation = function (...args) {
                 ? initArgs.keyType
                 : _this.owner.node.getDataType(initArgs.keyType);
     }
+    _this.designType = initArgs.designType;
+    _this.keyDesignType = initArgs.keyDesignType;
 };
 /**
  * @class MQOperation
@@ -62,9 +65,7 @@ class MQOperationClass extends DocumentElement {
             kind: OpraSchema.MQOperation.Kind,
             description: this.description,
             channel: this.channel,
-            payloadType: this.payloadType.name
-                ? this.payloadType.name
-                : this.payloadType.toJSON(),
+            type: this.type.name ? this.type.name : this.type.toJSON(),
             keyType: this.keyType
                 ? this.keyType.name
                     ? this.keyType.name
@@ -80,6 +81,18 @@ class MQOperationClass extends DocumentElement {
         }
         return out;
     }
+    generateCodec(codec, options, properties) {
+        return (this.type?.generateCodec(codec, options, {
+            ...properties,
+            designType: this.designType,
+        }) || vg.isAny());
+    }
+    generateKeyCodec(codec, options, properties) {
+        return (this.keyType?.generateCodec(codec, options, {
+            ...properties,
+            designType: this.keyDesignType,
+        }) || vg.isAny());
+    }
 }
 MQOperation.prototype = MQOperationClass.prototype;
 MQOperation[DECORATOR] = MQOperationDecoratorFactory;

package/esm/document/ws/ws-operation.js

@@ -6,15 +6,16 @@ import { DocumentElement } from '../common/document-element.js';
 import { CLASS_NAME_PATTERN, DECORATOR, kDataTypeMap } from '../constants.js';
 import { DataType } from '../data-type/data-type.js';
 import { WSOperationDecoratorFactory, } from '../decorators/ws-operation.decorator.js';
+import { parseRegExp } from '../utils/parse-regexp.util.js';
 /**
  *  WSOperation
  */
 export const WSOperation = function (...args) {
     // Decorator
     if (!this) {
-        const [payloadType, options] = args;
+        const [type, options] = args;
         const decoratorChain = [];
-        return WSOperation[DECORATOR].call(undefined, decoratorChain, payloadType, options);
+        return WSOperation[DECORATOR].call(undefined, decoratorChain, type, options);
     }
     // Constructor
     const [resource, initArgs] = args;
@@ -25,34 +26,35 @@ export const WSOperation = function (...args) {
     _this.types = _this.node[kDataTypeMap] = new DataTypeMap();
     _this.name = initArgs.name;
     _this.description = initArgs.description;
-    _this.channel = initArgs.channel;
-    if (initArgs?.payloadType) {
-        _this.payloadType =
-            initArgs?.payloadType instanceof DataType
-                ? initArgs.payloadType
-                : _this.owner.node.getDataType(initArgs.payloadType);
-    }
-    if (initArgs?.keyType) {
-        _this.keyType =
-            initArgs?.keyType instanceof DataType
-                ? initArgs.keyType
-                : _this.owner.node.getDataType(initArgs.keyType);
+    if (initArgs.event)
+        this.event =
+            initArgs.event instanceof RegExp
+                ? initArgs.event
+                : initArgs.event.startsWith('/')
+                    ? parseRegExp(initArgs.event)
+                    : initArgs.event;
+    else
+        _this.event = this.name;
+    if (initArgs?.arguments) {
+        _this.arguments = initArgs.arguments.map(arg => arg instanceof DataType ? arg : _this.owner.node.getDataType(arg));
     }
+    if (initArgs?.response)
+        _this.response =
+            initArgs.response instanceof DataType
+                ? initArgs.response
+                : _this.owner.node.getDataType(initArgs.response);
 };
 /**
  * @class WSOperation
  */
 class WSOperationClass extends DocumentElement {
     toJSON() {
-        const out = omitUndefined({
+        return omitUndefined({
             kind: OpraSchema.WSOperation.Kind,
             description: this.description,
-            channel: this.channel,
-            payloadType: this.payloadType.name
-                ? this.payloadType.name
-                : this.payloadType.toJSON(),
+            event: this.event,
+            arguments: this.arguments?.map(arg => arg.name ? arg.name : arg.toJSON()),
         });
-        return out;
     }
 }
 WSOperation.prototype = WSOperationClass.prototype;

package/esm/filter/filter-rules.js

@@ -122,10 +122,10 @@ export class FilterRules {
                         else
                             decoder = this._decoderCache.get(comp.left.field);
                         if (!decoder) {
-                            decoder = comp.left.field.type.generateCodec('decode', {
+                            decoder = comp.left.field.generateCodec('decode', {
                                 scope,
                                 projection: '*',
-                                ignoreWriteonlyFields: true,
+                                ignoreReadonlyFields: true,
                                 coerce: true,
                             });
                             this._decoderCache.set(comp.left.field, decoder);

package/esm/schema/data-type/array-type.interface.js

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

package/esm/schema/opra-schema.js

@@ -1,6 +1,7 @@
 export * from './api.interface.js';
 export * from './api-document.interface.js';
 export * from './constants.js';
+export * from './data-type/array-type.interface.js';
 export * from './data-type/complex-type.interface.js';
 export * from './data-type/data-type.interface.js';
 export * from './data-type/enum-type.interface.js';

package/esm/schema/type-guards.js

@@ -1,3 +1,4 @@
+import { ArrayType } from './data-type/array-type.interface.js';
 import { ComplexType } from './data-type/complex-type.interface.js';
 import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
@@ -8,7 +9,8 @@ import { HttpController } from './http/http-controller.interface.js';
 export function isDataType(obj) {
     return (obj &&
         typeof obj === 'object' &&
-        (obj.kind === ComplexType.Kind ||
+        (obj.kind === ArrayType.Kind ||
+            obj.kind === ComplexType.Kind ||
             obj.kind === EnumType.Kind ||
             obj.kind === MappedType.Kind ||
             obj.kind === SimpleType.Kind ||
@@ -33,6 +35,9 @@ export function isEnumType(obj) {
 export function isUnionType(obj) {
     return obj && typeof obj === 'object' && obj.kind === UnionType.Kind;
 }
+export function isArrayType(obj) {
+    return obj && typeof obj === 'object' && obj.kind === ArrayType.Kind;
+}
 export function isHttpController(obj) {
     return obj && typeof obj === 'object' && obj.kind === HttpController.Kind;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.19.7",
+  "version": "1.20.0",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",

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

@@ -28,9 +28,12 @@ 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 mqApi(): MQApi;
-    get wsApi(): WSApi;
+    get httpApi(): HttpApi | undefined;
+    get mqApi(): MQApi | undefined;
+    get wsApi(): WSApi | undefined;
+    getHttpApi(): HttpApi;
+    getMqApi(): MQApi;
+    getWsApi(): WSApi;
     toJSON(): OpraSchema.ApiDocument;
     /**
      * Export as Opra schema definition object

package/types/document/common/document-node.d.ts

@@ -1,6 +1,7 @@
 import type { Type } from 'ts-gems';
 import type { ApiDocument } from '../api-document.js';
 import { kDataTypeMap } from '../constants.js';
+import type { ArrayType } from '../data-type/array-type.js';
 import type { ComplexType } from '../data-type/complex-type.js';
 import type { DataType } from '../data-type/data-type.js';
 import type { EnumType } from '../data-type/enum-type.js';
@@ -27,6 +28,12 @@ export declare class DocumentNode {
      */
     getDataType(nameOrCtor: string | Type | Function | object | any[], scope?: string | '*'): DataType;
     getDataTypeNameWithNs(dataType: DataType): string | undefined;
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a UnionType
+     */
+    getArrayType(nameOrCtor: string | object | any[], scope?: string | '*'): ArrayType;
     /**
      * Returns ComplexType instance by name or Constructor.
      * Returns undefined if not found

package/types/document/constants.d.ts

@@ -2,6 +2,7 @@ export declare const DATATYPE_METADATA: unique symbol;
 export declare const HTTP_CONTROLLER_METADATA: unique symbol;
 export declare const MQ_CONTROLLER_METADATA: unique symbol;
 export declare const WS_CONTROLLER_METADATA: unique symbol;
+export declare const WS_PARAM_METADATA: unique symbol;
 export declare const RPC_CONTROLLER_METADATA: unique symbol;
 export declare const DECODER: unique symbol;
 export declare const ENCODER: unique symbol;

package/types/document/data-type/api-field.d.ts

@@ -1,4 +1,5 @@
-import type { Combine, StrictOmit, TypeThunkAsync } from 'ts-gems';
+import type { Combine, StrictOmit, Type, TypeThunkAsync } from 'ts-gems';
+import type { Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { DocumentElement } from '../common/document-element.js';
@@ -39,10 +40,11 @@ declare class ApiFieldClass extends DocumentElement {
     readonly owner: ComplexType | MappedType | MixinType;
     readonly origin?: ComplexType | MappedType | MixinType;
     readonly scopePattern?: (string | RegExp)[];
-    readonly convertToNative?: boolean;
+    readonly designType?: Type;
     readonly name: string;
     readonly type: DataType;
     readonly description?: string;
+    /** @deprecated */
     readonly isArray?: boolean;
     readonly isNestedEntity?: boolean;
     readonly default?: any;
@@ -59,6 +61,7 @@ declare class ApiFieldClass extends DocumentElement {
     inScope(scope?: string | '*'): boolean;
     forScope(scope?: string): this;
     toJSON(options?: ApiDocument.ExportOptions): OpraSchema.Field;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: any): Validator;
 }
 /**
  * @namespace ApiField
@@ -68,9 +71,8 @@ export declare namespace ApiField {
         type?: string | OpraSchema.DataType | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
     }, OpraSchema.Field> {
         scopePattern?: (string | RegExp) | (string | RegExp)[];
-        convertToNative?: boolean;
         override?: StrictOmit<Metadata, 'override' | 'type' | 'isArray' | 'isNestedEntity'>[];
-        designType?: Function;
+        designType?: Type;
     }
     interface Options extends Partial<StrictOmit<Metadata, 'override' | 'scopePattern'>> {
         /**
@@ -81,11 +83,6 @@ export declare namespace ApiField {
          * - If an array is provided, each element within the array is used as a valid scope pattern.
          */
         scopePattern?: (string | RegExp) | (string | RegExp)[];
-        /**
-         * Convert values to native objects. If enabled, some simple types
-         * like "date" will be decoded as Date instances
-         */
-        convertToNative?: boolean;
     }
     interface InitArguments extends Combine<{
         name: string;

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

@@ -0,0 +1,76 @@
+import 'reflect-metadata';
+import type { Combine, Type } from 'ts-gems';
+import { Validator } from 'valgen';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import type { DocumentElement } from '../common/document-element.js';
+import type { ComplexType } from './complex-type.js';
+import { DataType } from './data-type.js';
+import { EnumType } from './enum-type.js';
+import type { MappedType } from './mapped-type.js';
+import type { MixinType } from './mixin-type.js';
+import type { SimpleType } from './simple-type.js';
+import type { UnionType } from './union-type.js';
+/**
+ * @namespace ArrayType
+ */
+export declare namespace ArrayType {
+    interface Metadata extends Combine<{
+        kind: OpraSchema.ArrayType.Kind;
+        name?: string;
+        type: Type;
+    }, DataType.Metadata, OpraSchema.ArrayType> {
+    }
+    interface InitArguments extends Combine<{
+        kind: OpraSchema.ArrayType.Kind;
+        type: ArrayType | ComplexType | EnumType | MappedType | MixinType | SimpleType | UnionType;
+        ctor?: Type;
+    }, DataType.InitArguments, ArrayType.Metadata> {
+    }
+    interface Options extends Combine<Pick<OpraSchema.ArrayType, 'minOccurs' | 'maxOccurs'>, DataType.Options> {
+    }
+}
+/**
+ * Type definition for ArrayType
+ * @class ArrayType
+ */
+export interface ArrayTypeStatic {
+    /**
+     * Class constructor of ArrayType
+     *
+     * @param owner
+     * @param args
+     * @constructor
+     */
+    new (owner: DocumentElement, args: ArrayType.InitArguments): ArrayType;
+    /**
+     * Create a new mixin type from the given data type
+     */
+    (type: string | Type, options?: ArrayType.Options): Type;
+    prototype: ArrayType;
+}
+/**
+ * Type definition of ArrayType prototype
+ * @interface
+ */
+export interface ArrayType extends ArrayTypeClass {
+}
+/**
+ * @class ArrayType
+ */
+export declare const ArrayType: ArrayTypeStatic;
+/**
+ *
+ * @class ArrayType
+ */
+declare class ArrayTypeClass extends DataType {
+    readonly kind: OpraSchema.ArrayType.Kind;
+    readonly type: ComplexType | MixinType | MappedType | SimpleType | UnionType | EnumType | ArrayType;
+    readonly minOccurs?: number;
+    readonly maxOccurs?: number;
+    toJSON(options?: ApiDocument.ExportOptions): OpraSchema.ArrayType;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: object): Validator;
+    extendsFrom(): boolean;
+    protected _locateBase(): ArrayType | undefined;
+}
+export {};

package/types/document/data-type/extended-types/base64.type.d.ts

@@ -1,7 +1,8 @@
+import { Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class Base64Type {
-    convertToNative?: boolean;
+    designType?: Type;
     constructor(attributes?: Partial<Base64Type>);
     protected [DECODER](properties: Partial<this>): Validator;
     protected [ENCODER](): Validator;

package/types/document/data-type/extended-types/date-time.type.d.ts

@@ -1,7 +1,8 @@
+import { Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class DateTimeType {
-    convertToNative?: boolean;
+    designType?: Type;
     constructor(attributes?: Partial<DateTimeType>);
     protected [DECODER](properties: Partial<this>): Validator;
     protected [ENCODER](properties: Partial<this>): Validator;

package/types/document/data-type/extended-types/date.type.d.ts

@@ -1,7 +1,8 @@
+import { Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class DateType {
-    convertToNative?: boolean;
+    designType?: Type;
     constructor(attributes?: Partial<DateType>);
     protected [DECODER](properties: Partial<this>): Validator;
     protected [ENCODER](properties: Partial<this>): Validator;

package/types/document/data-type/extended-types/field-path.type.d.ts

@@ -7,8 +7,11 @@ export declare class FieldPathType {
     constructor(attributes?: Partial<FieldPathType>);
     dataType?: Type | string;
     allowSigns?: 'first' | 'each';
-    [DECODER](properties: Partial<this>, element: DocumentElement, scope?: string): Validator;
-    [ENCODER](properties: Partial<this>, element: DocumentElement, scope?: string): Validator;
+    [DECODER](properties: Partial<this>, { element, scope, }: {
+        element: DocumentElement;
+        scope?: string;
+    }): Validator;
+    [ENCODER](properties: Partial<this>, args: any): Validator;
     toJSON(properties: Partial<FieldPathType>, element: DocumentElement, options?: ApiDocument.ExportOptions): {
         dataType: string | import("../../../schema/opra-schema.js").ComplexType;
         allowSigns: "first" | "each" | undefined;

package/types/document/data-type/extended-types/filter.type.d.ts

@@ -8,7 +8,9 @@ export declare class FilterType {
     constructor(attributes?: Partial<FilterType>);
     dataType?: Type | string;
     rules?: Record<string, FilterRules.Rule>;
-    protected [DECODER](properties: Partial<this>, element: DocumentElement): Validator;
+    protected [DECODER](properties: Partial<this>, { element }: {
+        element: DocumentElement;
+    }): Validator;
     protected [ENCODER](): Validator;
     toJSON(properties: Partial<FilterType>, element: DocumentElement, options?: ApiDocument.ExportOptions): {
         dataType: string | import("../../../schema/opra-schema.js").ComplexType;

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

@@ -22,14 +22,18 @@ export declare namespace SimpleType {
         base?: SimpleType;
         ctor?: Type;
         properties?: object;
-        convertToNative?: boolean;
+        designType?: boolean;
         generateDecoder?: SimpleType.ValidatorGenerator;
         generateEncoder?: SimpleType.ValidatorGenerator;
     }, DataType.InitArguments, SimpleType.Metadata> {
     }
     interface Attribute extends OpraSchema.Attribute {
     }
-    type ValidatorGenerator = (properties: Record<string, any>, element: DocumentElement, scope?: string) => Validator;
+    type ValidatorGenerator = (properties: Record<string, any>, args: {
+        dataType: SimpleType;
+        element: DocumentElement;
+        scope?: string;
+    }) => Validator;
 }
 /**
  * Type definition for MixinType

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

@@ -5,7 +5,7 @@ import type { MQOperationResponse } from '../mq/mq-operation-response.js';
 export interface MQOperationDecorator {
     (target: Object, propertyKey: string): void;
     Header(name: string | RegExp, optionsOrType?: MQHeader.Options | string | TypeThunkAsync): this;
-    Response(payloadType: TypeThunkAsync | string, options?: MQOperationResponse.Options): MQOperationResponseDecorator;
+    Response(type: TypeThunkAsync | string, options?: MQOperationResponse.Options): MQOperationResponseDecorator;
     UseType(...type: Type[]): this;
 }
 export interface MQOperationResponseDecorator {
@@ -19,14 +19,14 @@ export interface MQOperationDecoratorFactory {
     /**
      * Property decorator
      * @param decoratorChain
-     * @param payloadType
+     * @param type
      * @param options
-     */ <T extends MQOperation.Options>(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: T): MQOperationDecorator;
+     */ <T extends MQOperation.Options>(decoratorChain: Function[], type: ThunkAsync<Type> | string, options?: T): MQOperationDecorator;
 }
 export declare namespace MQOperationDecoratorFactory {
-    type AugmentationFunction = (decorator: MQOperationDecorator, decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: MQOperation.Options) => void;
+    type AugmentationFunction = (decorator: MQOperationDecorator, decoratorChain: Function[], type: ThunkAsync<Type> | string, options?: MQOperation.Options) => void;
 }
-export declare function MQOperationDecoratorFactory(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string | TypeThunkAsync, options?: MQOperation.Options): MQOperationDecorator;
+export declare function MQOperationDecoratorFactory(decoratorChain: Function[], type: ThunkAsync<Type> | string | TypeThunkAsync, options?: MQOperation.Options): MQOperationDecorator;
 export declare namespace MQOperationDecoratorFactory {
     var augment: (fn: MQOperationDecoratorFactory.AugmentationFunction) => void;
 }

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

@@ -1,8 +1,6 @@
 import type { TypeThunkAsync } from 'ts-gems';
-import type { MQHeader } from '../mq/mq-header';
 import type { WSController } from '../ws/ws-controller.js';
 export interface WSControllerDecorator<T extends WSControllerDecorator<any> = WSControllerDecorator<any>> extends ClassDecorator {
-    Header(name: string | RegExp, optionsOrType?: MQHeader.Options | string | TypeThunkAsync | false): T;
     UseType(...type: TypeThunkAsync[]): T;
 }
 export interface WSControllerDecoratorFactory {

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

@@ -1,4 +1,4 @@
-import type { ThunkAsync, Type, TypeThunkAsync } from 'ts-gems';
+import type { ThunkAsync, Type } from 'ts-gems';
 import type { WSOperation } from '../ws/ws-operation.js';
 export interface WSOperationDecorator {
     (target: Object, propertyKey: string): void;
@@ -11,14 +11,14 @@ export interface WSOperationDecoratorFactory {
     /**
      * Property decorator
      * @param decoratorChain
-     * @param payloadType
+     * @param type
      * @param options
-     */ <T extends WSOperation.Options>(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: T): WSOperationDecorator;
+     */ <T extends WSOperation.Options>(decoratorChain: Function[], type: ThunkAsync<Type> | string, options?: T): WSOperationDecorator;
 }
 export declare namespace WSOperationDecoratorFactory {
-    type AugmentationFunction = (decorator: WSOperationDecorator, decoratorChain: Function[], payloadType: ThunkAsync<Type> | string, options?: WSOperation.Options) => void;
+    type AugmentationFunction = (decorator: WSOperationDecorator, decoratorChain: Function[], options?: WSOperation.Options) => void;
 }
-export declare function WSOperationDecoratorFactory(decoratorChain: Function[], payloadType: ThunkAsync<Type> | string | TypeThunkAsync, options?: WSOperation.Options): WSOperationDecorator;
+export declare function WSOperationDecoratorFactory(decoratorChain: Function[], options?: WSOperation.Options): WSOperationDecorator;
 export declare namespace WSOperationDecoratorFactory {
     var augment: (fn: WSOperationDecoratorFactory.AugmentationFunction) => void;
 }

package/types/document/decorators/ws-param.decorator.d.ts

@@ -0,0 +1,2 @@
+import { TypeThunkAsync } from 'ts-gems';
+export declare function WsParam(type?: TypeThunkAsync | string): ParameterDecorator;

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

@@ -4,6 +4,7 @@ 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 { ArrayType } from '../data-type/array-type.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';
@@ -18,6 +19,11 @@ import { UnionType } from '../data-type/union-type.js';
 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 ArrayTypeInit extends Combine<{
+        _instance?: ArrayType;
+        type: (string | SimpleTypeInit | ComplexTypeInit | MappedTypeInit | MixinTypeInit | UnionTypeInit | ArrayTypeInit)[];
+    }, ArrayType.InitArguments> {
+    }
     interface ComplexTypeInit extends Combine<{
         _instance?: ComplexType;
         base?: string | ComplexTypeInit | MappedTypeInit | MixinTypeInit;
@@ -54,7 +60,7 @@ export declare namespace DataTypeFactory {
         type: string | DataTypeInitArguments;
     }, ApiField.InitArguments> {
     }
-    type DataTypeInitArguments = ComplexTypeInit | EnumTypeInit | MappedTypeInit | MixinTypeInit | SimpleTypeInit | UnionTypeInit;
+    type DataTypeInitArguments = ComplexTypeInit | EnumTypeInit | MappedTypeInit | MixinTypeInit | SimpleTypeInit | UnionTypeInit | ArrayTypeInit;
     interface Context extends DocumentInitContext {
         importQueue?: ResponsiveMap<any>;
         initArgsMap?: ResponsiveMap<DataTypeInitArguments>;
@@ -98,6 +104,9 @@ export declare class DataTypeFactory {
      */
     protected static _importDataTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, thunk: string | Type | OpraSchema.DataType | object, checkCircularDeps?: boolean): Promise<DataTypeFactory.DataTypeInitArguments | string | void>;
     protected static _prepareDataTypeArgs(context: DataTypeFactory.Context, initArgs: DataTypeFactory.DataTypeInitArguments, metadata: OpraSchema.DataTypeBase | DataType.Metadata): Promise<void>;
+    protected static _prepareArrayTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, initArgs: DataTypeFactory.ArrayTypeInit, metadata: (ArrayType.Metadata | OpraSchema.ArrayType) & {
+        ctor?: Type;
+    }): 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>;
@@ -110,7 +119,8 @@ export declare class DataTypeFactory {
     }): Promise<void>;
     protected static _createDataType(context: DocumentInitContext & {
         initArgsMap?: ResponsiveMap<DataTypeFactory.DataTypeInitArguments>;
-    }, owner: DocumentElement, args: DataTypeFactory.DataTypeInitArguments | string): ComplexType | EnumType | MappedType | MixinType | SimpleType | UnionType | undefined;
+    }, owner: DocumentElement, args: DataTypeFactory.DataTypeInitArguments | string): ArrayType | ComplexType | EnumType | MappedType | MixinType | SimpleType | UnionType | undefined;
+    protected static _createArrayType(context: DocumentInitContext, owner: DocumentElement, args: DataTypeFactory.ArrayTypeInit): ArrayType;
     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;

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

@@ -12,6 +12,7 @@ export declare namespace HttpMediaType {
     interface Metadata extends Partial<StrictOmit<OpraSchema.HttpMediaType, 'type' | 'multipartFields'>> {
         type?: Type | string;
         multipartFields?: HttpMultipartField.Metadata[];
+        designType?: Type;
     }
     interface Options extends Partial<StrictOmit<OpraSchema.HttpMediaType, 'type' | 'multipartFields'>> {
         type?: Type | string;
@@ -54,8 +55,9 @@ declare class HttpMediaTypeClass extends DocumentElement {
     maxFiles?: number;
     maxFileSize?: number;
     maxTotalFileSize?: number;
+    designType?: Type;
     findMultipartField(fieldName: string, fieldType?: OpraSchema.HttpMultipartFieldType): HttpMultipartField | undefined;
     toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpMediaType;
-    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: object): Validator;
 }
 export {};

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

@@ -1,4 +1,5 @@
-import { type Combine, type StrictOmit, type TypeThunkAsync } from 'ts-gems';
+import { type Combine, type StrictOmit, Type, type TypeThunkAsync } from 'ts-gems';
+import { Validator } from 'valgen';
 import type { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document';
 import { DocumentElement } from '../common/document-element.js';
@@ -13,6 +14,7 @@ export declare namespace HttpParameter {
         name: string | RegExp;
         type?: string | TypeThunkAsync | EnumType.EnumObject | EnumType.EnumArray | object;
         keyParam?: boolean;
+        designType?: Type;
     }
     interface Options extends Partial<StrictOmit<Metadata, 'type'>> {
         type?: string | TypeThunkAsync | object;
@@ -50,6 +52,8 @@ declare class HttpParameterClass extends Value {
     required?: boolean;
     arraySeparator?: string;
     parser?: (v: any) => any;
+    designType?: Type;
     toJSON(options?: ApiDocument.ExportOptions): OpraSchema.HttpParameter;
+    generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: any): Validator;
 }
 export {};