@opra/common 1.13.0 → 1.15.0

package/cjs/document/common/document-node.js

@@ -119,5 +119,16 @@ class DocumentNode {
             return t;
         throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);
     }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a UnionType
+     */
+    getUnionType(nameOrCtor, scope) {
+        const t = this.getDataType(nameOrCtor, scope);
+        if (t.kind === index_js_1.OpraSchema.UnionType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);
+    }
 }
 exports.DocumentNode = DocumentNode;

package/cjs/document/data-type/complex-type-base.js

@@ -285,7 +285,7 @@ class ComplexTypeBaseClass extends data_type_js_1.DataType {
     _generateFieldCodec(codec, field, context) {
         let fn = field.type.generateCodec(codec, context);
         if (field.fixed)
-            fn = valgen_1.vg.isEnum([field.fixed]);
+            fn = valgen_1.vg.isEqual(field.fixed);
         if (field.isArray)
             fn = valgen_1.vg.isArray(fn);
         return fn;

package/cjs/document/data-type/complex-type.js

@@ -24,6 +24,8 @@ exports.ComplexType = function (...args) {
     complex_type_base_js_1.ComplexTypeBase.call(this, owner, initArgs, context);
     const _this = (0, ts_gems_1.asMutable)(this);
     _this.kind = index_js_1.OpraSchema.ComplexType.Kind;
+    _this.discriminatorField = initArgs.discriminatorField;
+    _this.discriminatorValue = initArgs.discriminatorValue;
     if (initArgs.base) {
         context.enter('.base', () => {
             // noinspection SuspiciousTypeOfGuard
@@ -84,6 +86,8 @@ class ComplexTypeClass extends complex_type_base_js_1.ComplexTypeBase {
                     ? baseName
                     : this.base.toJSON(options)
                 : undefined,
+            discriminatorField: this.discriminatorField,
+            discriminatorValue: this.discriminatorValue,
         };
         if (this.additionalFields) {
             if (this.additionalFields instanceof data_type_js_1.DataType) {

package/cjs/document/data-type/mapped-type.js

@@ -72,6 +72,8 @@ exports.MappedType = function (...args) {
         }
         if (initArgs.base.keyField && isInheritedPredicate(initArgs.base.keyField))
             _this.keyField = initArgs.base.keyField;
+        _this.discriminatorField = initArgs.base.discriminatorField;
+        _this.discriminatorValue = initArgs.base.discriminatorValue;
     }
 };
 /**
@@ -101,6 +103,8 @@ class MappedTypeClass extends complex_type_base_js_1.ComplexTypeBase {
             omit: this.omit,
             partial: this.partial,
             required: this.required,
+            discriminatorField: this.discriminatorField,
+            discriminatorValue: this.discriminatorValue,
         });
     }
     _locateBase(callback) {

package/cjs/document/data-type/mixin-type.js

@@ -15,8 +15,9 @@ const data_type_js_1 = require("./data-type.js");
  */
 exports.MixinType = function (...args) {
     // MixinType factory
-    if (!this)
+    if (!this) {
         return exports.MixinType[constants_js_1.DECORATOR].apply(undefined, args);
+    }
     // Constructor
     const [owner, initArgs, context] = args;
     complex_type_base_js_1.ComplexTypeBase.call(this, owner, initArgs, context);
@@ -85,12 +86,9 @@ exports.MixinType[constants_js_1.DECORATOR] = MixinTypeFactory;
 /**
  *
  */
-function MixinTypeFactory(...args) {
+function MixinTypeFactory(clasRefs, options) {
     // Filter undefined items
-    const clasRefs = args.filter(x => typeof x === 'function');
-    const options = typeof args[args.length - 1] === 'object'
-        ? args[args.length - 1]
-        : undefined;
+    clasRefs = clasRefs.filter(x => typeof x === 'function');
     if (!clasRefs.length)
         throw new TypeError('No Class has been provided');
     if (clasRefs.length === 1)

package/cjs/document/data-type/union-type.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionType = void 0;
+require("reflect-metadata");
+const objects_1 = require("@jsopen/objects");
+const ts_gems_1 = require("ts-gems");
+const valgen_1 = require("valgen");
+const index_js_1 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const data_type_js_1 = require("./data-type.js");
+/**
+ * @class UnionType
+ */
+exports.UnionType = function (...args) {
+    // UnionType factory
+    if (!this) {
+        return exports.UnionType[constants_js_1.DECORATOR].apply(undefined, args);
+    }
+    // Constructor
+    const [owner, initArgs, context] = args;
+    data_type_js_1.DataType.call(this, owner, initArgs, context);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = index_js_1.OpraSchema.UnionType.Kind;
+    _this.discriminator = initArgs.discriminator;
+    _this.types = [];
+    for (const base of initArgs.types) {
+        _this.types.push(base);
+    }
+};
+/**
+ *
+ * @class UnionType
+ */
+class UnionTypeClass extends data_type_js_1.DataType {
+    toJSON(options) {
+        const superJson = super.toJSON(options);
+        return (0, objects_1.omitUndefined)({
+            ...superJson,
+            kind: this.kind,
+            discriminator: this.discriminator,
+            types: this.types.map(base => {
+                const baseName = this.node.getDataTypeNameWithNs(base);
+                return baseName ? baseName : base.toJSON(options);
+            }),
+        });
+    }
+    generateCodec(codec, options) {
+        const codecs = this.types.map(t => {
+            const fn = t.generateCodec(codec, options);
+            if ((t.kind === index_js_1.OpraSchema.ComplexType.Kind ||
+                t.kind === index_js_1.OpraSchema.MappedType.Kind) &&
+                t.discriminatorField) {
+                return [
+                    fn,
+                    { [t.discriminatorField]: valgen_1.vg.isEqual(t.discriminatorValue) },
+                ];
+            }
+            return fn;
+        });
+        return valgen_1.vg.oneOf(codecs);
+    }
+    extendsFrom() {
+        return false;
+    }
+    _locateBase() {
+        return;
+    }
+}
+exports.UnionType.prototype = UnionTypeClass.prototype;
+exports.UnionType[constants_js_1.DECORATOR] = UnionTypeFactory;
+/**
+ *
+ */
+function UnionTypeFactory(clasRefs, options) {
+    class UnionClass {
+    }
+    const metadata = {
+        ...options,
+        kind: index_js_1.OpraSchema.UnionType.Kind,
+        types: clasRefs,
+    };
+    Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, UnionClass);
+    return UnionClass;
+}

package/cjs/document/factory/data-type.factory.js

@@ -12,6 +12,7 @@ const enum_type_js_1 = require("../data-type/enum-type.js");
 const mapped_type_js_1 = require("../data-type/mapped-type.js");
 const mixin_type_js_1 = require("../data-type/mixin-type.js");
 const simple_type_js_1 = require("../data-type/simple-type.js");
+const union_type_js_1 = require("../data-type/union-type.js");
 const initializingSymbol = Symbol('initializing');
 /**
  *
@@ -266,6 +267,9 @@ class DataTypeFactory {
                         out.ctor = ctor;
                         await this._prepareSimpleTypeArgs(context, owner, out, metadata);
                         break;
+                    case index_js_2.OpraSchema.UnionType.Kind:
+                        await this._prepareUnionTypeArgs(context, owner, out, metadata);
+                        break;
                     default:
                         /** istanbul ignore next */
                         return context.addError(`Invalid data type kind ${metadata.kind}`);
@@ -288,6 +292,8 @@ class DataTypeFactory {
     static async _prepareComplexTypeArgs(context, owner, initArgs, metadata) {
         await this._prepareDataTypeArgs(context, initArgs, metadata);
         initArgs.keyField = metadata.keyField;
+        initArgs.discriminatorField = metadata.discriminatorField;
+        initArgs.discriminatorValue = metadata.discriminatorValue;
         await context.enterAsync('.base', async () => {
             let baseArgs;
             if (metadata.base) {
@@ -384,6 +390,8 @@ class DataTypeFactory {
     }
     static async _prepareMappedTypeArgs(context, owner, initArgs, metadata) {
         await this._prepareDataTypeArgs(context, initArgs, metadata);
+        initArgs.discriminatorField = metadata.discriminatorField;
+        initArgs.discriminatorValue = metadata.discriminatorValue;
         await context.enterAsync('.base', async () => {
             let baseArgs;
             if (metadata.base) {
@@ -431,6 +439,22 @@ class DataTypeFactory {
             }
         });
     }
+    static async _prepareUnionTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        initArgs.types = [];
+        await context.enterAsync('.types', async () => {
+            const _initTypes = metadata.types;
+            let i = 0;
+            for (const t of _initTypes) {
+                await context.enterAsync(`[${i++}]`, async () => {
+                    const baseArgs = await this._importDataTypeArgs(context, owner, t);
+                    if (!baseArgs)
+                        return;
+                    initArgs.types.push(preferName(baseArgs));
+                });
+            }
+        });
+    }
     static _createDataType(context, owner, args) {
         let dataType = owner.node.findDataType(typeof args === 'string' ? args : args.name || '');
         if (dataType instanceof data_type_js_1.DataType)
@@ -455,6 +479,8 @@ class DataTypeFactory {
                     return this._createMixinType(context, owner, initArgs);
                 case index_js_2.OpraSchema.SimpleType.Kind:
                     return this._createSimpleType(context, owner, initArgs);
+                case index_js_2.OpraSchema.UnionType.Kind:
+                    return this._createUnionType(context, owner, initArgs);
                 default:
                     break;
             }
@@ -562,6 +588,25 @@ class DataTypeFactory {
         simple_type_js_1.SimpleType.apply(dataType, [owner, initArgs]);
         return dataType;
     }
+    static _createUnionType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, union_type_js_1.UnionType.prototype);
+        const initArgs = (0, index_js_1.cloneObject)(args);
+        if (args.types) {
+            context.enter('.types', () => {
+                initArgs.types = [];
+                let i = 0;
+                for (const t of args.types) {
+                    context.enter(`[${i++}]`, () => {
+                        const base = this._createDataType(context, owner, t);
+                        initArgs.types.push(base);
+                    });
+                }
+            });
+        }
+        union_type_js_1.UnionType.apply(dataType, [owner, initArgs]);
+        return dataType;
+    }
 }
 exports.DataTypeFactory = DataTypeFactory;
 function preferName(initArgs) {

package/cjs/document/index.js

@@ -37,6 +37,7 @@ tslib_1.__exportStar(require("./data-type/pick-type.js"), exports);
 tslib_1.__exportStar(require("./data-type/primitive-types/index.js"), exports);
 tslib_1.__exportStar(require("./data-type/required-type.js"), exports);
 tslib_1.__exportStar(require("./data-type/simple-type.js"), exports);
+tslib_1.__exportStar(require("./data-type/union-type.js"), exports);
 tslib_1.__exportStar(require("./factory/api-document.factory.js"), exports);
 tslib_1.__exportStar(require("./http/http-api.js"), exports);
 tslib_1.__exportStar(require("./http/http-controller.js"), exports);

package/cjs/schema/data-type/union-type.interface.js

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

package/cjs/schema/opra-schema.js

@@ -10,6 +10,7 @@ tslib_1.__exportStar(require("./data-type/field.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type/mapped-type.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type/mixin-type.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type/simple-type.interface.js"), exports);
+tslib_1.__exportStar(require("./data-type/union-type.interface.js"), exports);
 tslib_1.__exportStar(require("./data-type-container.interface.js"), exports);
 tslib_1.__exportStar(require("./http/http-controller.interface.js"), exports);
 tslib_1.__exportStar(require("./http/http-media-type.interface.js"), exports);

package/cjs/schema/type-guards.js

@@ -6,12 +6,14 @@ exports.isSimpleType = isSimpleType;
 exports.isMixinType = isMixinType;
 exports.isMappedType = isMappedType;
 exports.isEnumType = isEnumType;
+exports.isUnionType = isUnionType;
 exports.isHttpController = isHttpController;
 const complex_type_interface_js_1 = require("./data-type/complex-type.interface.js");
 const enum_type_interface_js_1 = require("./data-type/enum-type.interface.js");
 const mapped_type_interface_js_1 = require("./data-type/mapped-type.interface.js");
 const mixin_type_interface_js_1 = require("./data-type/mixin-type.interface.js");
 const simple_type_interface_js_1 = require("./data-type/simple-type.interface.js");
+const union_type_interface_js_1 = require("./data-type/union-type.interface.js");
 const http_controller_interface_js_1 = require("./http/http-controller.interface.js");
 function isDataType(obj) {
     return (obj &&
@@ -20,7 +22,8 @@ function isDataType(obj) {
             obj.kind === enum_type_interface_js_1.EnumType.Kind ||
             obj.kind === mapped_type_interface_js_1.MappedType.Kind ||
             obj.kind === simple_type_interface_js_1.SimpleType.Kind ||
-            obj.kind === mixin_type_interface_js_1.MixinType.Kind));
+            obj.kind === mixin_type_interface_js_1.MixinType.Kind ||
+            obj.kind === union_type_interface_js_1.UnionType.Kind));
 }
 function isComplexType(obj) {
     return obj && typeof obj === 'object' && obj.kind === complex_type_interface_js_1.ComplexType.Kind;
@@ -37,6 +40,9 @@ function isMappedType(obj) {
 function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === enum_type_interface_js_1.EnumType.Kind;
 }
+function isUnionType(obj) {
+    return obj && typeof obj === 'object' && obj.kind === union_type_interface_js_1.UnionType.Kind;
+}
 function isHttpController(obj) {
     return obj && typeof obj === 'object' && obj.kind === http_controller_interface_js_1.HttpController.Kind;
 }

package/esm/document/common/document-node.js

@@ -116,4 +116,15 @@ export class DocumentNode {
             return t;
         throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);
     }
+    /**
+     * Returns EnumType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a UnionType
+     */
+    getUnionType(nameOrCtor, scope) {
+        const t = this.getDataType(nameOrCtor, scope);
+        if (t.kind === OpraSchema.UnionType.Kind)
+            return t;
+        throw new TypeError(`Data type "${t.name || t}" is not a MixinType`);
+    }
 }

package/esm/document/data-type/complex-type-base.js

@@ -282,7 +282,7 @@ class ComplexTypeBaseClass extends DataType {
     _generateFieldCodec(codec, field, context) {
         let fn = field.type.generateCodec(codec, context);
         if (field.fixed)
-            fn = vg.isEnum([field.fixed]);
+            fn = vg.isEqual(field.fixed);
         if (field.isArray)
             fn = vg.isArray(fn);
         return fn;

package/esm/document/data-type/complex-type.js

@@ -21,6 +21,8 @@ export const ComplexType = function (...args) {
     ComplexTypeBase.call(this, owner, initArgs, context);
     const _this = asMutable(this);
     _this.kind = OpraSchema.ComplexType.Kind;
+    _this.discriminatorField = initArgs.discriminatorField;
+    _this.discriminatorValue = initArgs.discriminatorValue;
     if (initArgs.base) {
         context.enter('.base', () => {
             // noinspection SuspiciousTypeOfGuard
@@ -81,6 +83,8 @@ class ComplexTypeClass extends ComplexTypeBase {
                     ? baseName
                     : this.base.toJSON(options)
                 : undefined,
+            discriminatorField: this.discriminatorField,
+            discriminatorValue: this.discriminatorValue,
         };
         if (this.additionalFields) {
             if (this.additionalFields instanceof DataType) {

package/esm/document/data-type/mapped-type.js

@@ -69,6 +69,8 @@ export const MappedType = function (...args) {
         }
         if (initArgs.base.keyField && isInheritedPredicate(initArgs.base.keyField))
             _this.keyField = initArgs.base.keyField;
+        _this.discriminatorField = initArgs.base.discriminatorField;
+        _this.discriminatorValue = initArgs.base.discriminatorValue;
     }
 };
 /**
@@ -98,6 +100,8 @@ class MappedTypeClass extends ComplexTypeBase {
             omit: this.omit,
             partial: this.partial,
             required: this.required,
+            discriminatorField: this.discriminatorField,
+            discriminatorValue: this.discriminatorValue,
         });
     }
     _locateBase(callback) {

package/esm/document/data-type/mixin-type.js

@@ -12,8 +12,9 @@ import { DataType } from './data-type.js';
  */
 export const MixinType = function (...args) {
     // MixinType factory
-    if (!this)
+    if (!this) {
         return MixinType[DECORATOR].apply(undefined, args);
+    }
     // Constructor
     const [owner, initArgs, context] = args;
     ComplexTypeBase.call(this, owner, initArgs, context);
@@ -82,12 +83,9 @@ MixinType[DECORATOR] = MixinTypeFactory;
 /**
  *
  */
-function MixinTypeFactory(...args) {
+function MixinTypeFactory(clasRefs, options) {
     // Filter undefined items
-    const clasRefs = args.filter(x => typeof x === 'function');
-    const options = typeof args[args.length - 1] === 'object'
-        ? args[args.length - 1]
-        : undefined;
+    clasRefs = clasRefs.filter(x => typeof x === 'function');
     if (!clasRefs.length)
         throw new TypeError('No Class has been provided');
     if (clasRefs.length === 1)

package/esm/document/data-type/union-type.js

@@ -0,0 +1,81 @@
+import 'reflect-metadata';
+import { omitUndefined } from '@jsopen/objects';
+import { asMutable } from 'ts-gems';
+import { vg } from 'valgen';
+import { OpraSchema } from '../../schema/index.js';
+import { DATATYPE_METADATA, DECORATOR } from '../constants.js';
+import { DataType } from './data-type.js';
+/**
+ * @class UnionType
+ */
+export const UnionType = function (...args) {
+    // UnionType factory
+    if (!this) {
+        return UnionType[DECORATOR].apply(undefined, args);
+    }
+    // Constructor
+    const [owner, initArgs, context] = args;
+    DataType.call(this, owner, initArgs, context);
+    const _this = asMutable(this);
+    _this.kind = OpraSchema.UnionType.Kind;
+    _this.discriminator = initArgs.discriminator;
+    _this.types = [];
+    for (const base of initArgs.types) {
+        _this.types.push(base);
+    }
+};
+/**
+ *
+ * @class UnionType
+ */
+class UnionTypeClass extends DataType {
+    toJSON(options) {
+        const superJson = super.toJSON(options);
+        return omitUndefined({
+            ...superJson,
+            kind: this.kind,
+            discriminator: this.discriminator,
+            types: this.types.map(base => {
+                const baseName = this.node.getDataTypeNameWithNs(base);
+                return baseName ? baseName : base.toJSON(options);
+            }),
+        });
+    }
+    generateCodec(codec, options) {
+        const codecs = this.types.map(t => {
+            const fn = t.generateCodec(codec, options);
+            if ((t.kind === OpraSchema.ComplexType.Kind ||
+                t.kind === OpraSchema.MappedType.Kind) &&
+                t.discriminatorField) {
+                return [
+                    fn,
+                    { [t.discriminatorField]: vg.isEqual(t.discriminatorValue) },
+                ];
+            }
+            return fn;
+        });
+        return vg.oneOf(codecs);
+    }
+    extendsFrom() {
+        return false;
+    }
+    _locateBase() {
+        return;
+    }
+}
+UnionType.prototype = UnionTypeClass.prototype;
+UnionType[DECORATOR] = UnionTypeFactory;
+/**
+ *
+ */
+function UnionTypeFactory(clasRefs, options) {
+    class UnionClass {
+    }
+    const metadata = {
+        ...options,
+        kind: OpraSchema.UnionType.Kind,
+        types: clasRefs,
+    };
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, UnionClass);
+    return UnionClass;
+}

package/esm/document/factory/data-type.factory.js

@@ -9,6 +9,7 @@ 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';
+import { UnionType } from '../data-type/union-type.js';
 const initializingSymbol = Symbol('initializing');
 /**
  *
@@ -263,6 +264,9 @@ export class DataTypeFactory {
                         out.ctor = ctor;
                         await this._prepareSimpleTypeArgs(context, owner, out, metadata);
                         break;
+                    case OpraSchema.UnionType.Kind:
+                        await this._prepareUnionTypeArgs(context, owner, out, metadata);
+                        break;
                     default:
                         /** istanbul ignore next */
                         return context.addError(`Invalid data type kind ${metadata.kind}`);
@@ -285,6 +289,8 @@ export class DataTypeFactory {
     static async _prepareComplexTypeArgs(context, owner, initArgs, metadata) {
         await this._prepareDataTypeArgs(context, initArgs, metadata);
         initArgs.keyField = metadata.keyField;
+        initArgs.discriminatorField = metadata.discriminatorField;
+        initArgs.discriminatorValue = metadata.discriminatorValue;
         await context.enterAsync('.base', async () => {
             let baseArgs;
             if (metadata.base) {
@@ -381,6 +387,8 @@ export class DataTypeFactory {
     }
     static async _prepareMappedTypeArgs(context, owner, initArgs, metadata) {
         await this._prepareDataTypeArgs(context, initArgs, metadata);
+        initArgs.discriminatorField = metadata.discriminatorField;
+        initArgs.discriminatorValue = metadata.discriminatorValue;
         await context.enterAsync('.base', async () => {
             let baseArgs;
             if (metadata.base) {
@@ -428,6 +436,22 @@ export class DataTypeFactory {
             }
         });
     }
+    static async _prepareUnionTypeArgs(context, owner, initArgs, metadata) {
+        await this._prepareDataTypeArgs(context, initArgs, metadata);
+        initArgs.types = [];
+        await context.enterAsync('.types', async () => {
+            const _initTypes = metadata.types;
+            let i = 0;
+            for (const t of _initTypes) {
+                await context.enterAsync(`[${i++}]`, async () => {
+                    const baseArgs = await this._importDataTypeArgs(context, owner, t);
+                    if (!baseArgs)
+                        return;
+                    initArgs.types.push(preferName(baseArgs));
+                });
+            }
+        });
+    }
     static _createDataType(context, owner, args) {
         let dataType = owner.node.findDataType(typeof args === 'string' ? args : args.name || '');
         if (dataType instanceof DataType)
@@ -452,6 +476,8 @@ export class DataTypeFactory {
                     return this._createMixinType(context, owner, initArgs);
                 case OpraSchema.SimpleType.Kind:
                     return this._createSimpleType(context, owner, initArgs);
+                case OpraSchema.UnionType.Kind:
+                    return this._createUnionType(context, owner, initArgs);
                 default:
                     break;
             }
@@ -559,6 +585,25 @@ export class DataTypeFactory {
         SimpleType.apply(dataType, [owner, initArgs]);
         return dataType;
     }
+    static _createUnionType(context, owner, args) {
+        const dataType = args._instance || {};
+        Object.setPrototypeOf(dataType, UnionType.prototype);
+        const initArgs = cloneObject(args);
+        if (args.types) {
+            context.enter('.types', () => {
+                initArgs.types = [];
+                let i = 0;
+                for (const t of args.types) {
+                    context.enter(`[${i++}]`, () => {
+                        const base = this._createDataType(context, owner, t);
+                        initArgs.types.push(base);
+                    });
+                }
+            });
+        }
+        UnionType.apply(dataType, [owner, initArgs]);
+        return dataType;
+    }
 }
 function preferName(initArgs) {
     return typeof initArgs === 'object'

package/esm/document/index.js

@@ -33,6 +33,7 @@ export * from './data-type/pick-type.js';
 export * from './data-type/primitive-types/index.js';
 export * from './data-type/required-type.js';
 export * from './data-type/simple-type.js';
+export * from './data-type/union-type.js';
 export * from './factory/api-document.factory.js';
 export * from './http/http-api.js';
 export * from './http/http-controller.js';

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

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

package/esm/schema/opra-schema.js

@@ -7,6 +7,7 @@ export * from './data-type/field.interface.js';
 export * from './data-type/mapped-type.interface.js';
 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-controller.interface.js';
 export * from './http/http-media-type.interface.js';

package/esm/schema/type-guards.js

@@ -3,6 +3,7 @@ import { EnumType } from './data-type/enum-type.interface.js';
 import { MappedType } from './data-type/mapped-type.interface.js';
 import { MixinType } from './data-type/mixin-type.interface.js';
 import { SimpleType } from './data-type/simple-type.interface.js';
+import { UnionType } from './data-type/union-type.interface.js';
 import { HttpController } from './http/http-controller.interface.js';
 export function isDataType(obj) {
     return (obj &&
@@ -11,7 +12,8 @@ export function isDataType(obj) {
             obj.kind === EnumType.Kind ||
             obj.kind === MappedType.Kind ||
             obj.kind === SimpleType.Kind ||
-            obj.kind === MixinType.Kind));
+            obj.kind === MixinType.Kind ||
+            obj.kind === UnionType.Kind));
 }
 export function isComplexType(obj) {
     return obj && typeof obj === 'object' && obj.kind === ComplexType.Kind;
@@ -28,6 +30,9 @@ export function isMappedType(obj) {
 export function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === EnumType.Kind;
 }
+export function isUnionType(obj) {
+    return obj && typeof obj === 'object' && obj.kind === UnionType.Kind;
+}
 export function isHttpController(obj) {
     return obj && typeof obj === 'object' && obj.kind === HttpController.Kind;
 }