@opra/common 0.15.0 → 0.16.0

package/esm/document/data-type/builtin/number.type.js

@@ -1,11 +1,14 @@
-import { __decorate } from "tslib";
-import { toNumber } from 'putil-varhelpers';
-import { SimpleType } from '../simple-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
 let NumberType = class NumberType {
     decode(v) {
         if (v == null)
             return v;
-        const x = toNumber(v);
+        const x = (0, putil_varhelpers_1.toNumber)(v);
         if (x)
             this.validate(x);
         return x;
@@ -21,10 +24,10 @@ let NumberType = class NumberType {
             throw new TypeError(`Invalid number value "${v}"`);
     }
 };
-NumberType = __decorate([
-    SimpleType({
+NumberType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'Both Integer as well as Floating-Point numbers',
         ctor: Number
     })
 ], NumberType);
-export { NumberType };
+exports.NumberType = NumberType;

package/esm/document/data-type/builtin/object.type.js

@@ -1,5 +1,8 @@
-import { __decorate } from "tslib";
-import { ComplexType } from '../complex-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectType = void 0;
+const tslib_1 = require("tslib");
+const complex_type_js_1 = require("../complex-type.js");
 let ObjectType = class ObjectType {
     coerce(v) {
         if (v == null)
@@ -7,11 +10,11 @@ let ObjectType = class ObjectType {
         return typeof v === 'object' ? v : {};
     }
 };
-ObjectType = __decorate([
-    ComplexType({
+ObjectType = tslib_1.__decorate([
+    (0, complex_type_js_1.ComplexType)({
         name: 'object',
         description: 'A non modelled object',
         additionalFields: true
     })
 ], ObjectType);
-export { ObjectType };
+exports.ObjectType = ObjectType;

package/esm/document/data-type/builtin/string.type.js

@@ -1,21 +1,24 @@
-import { __decorate } from "tslib";
-import { toString } from 'putil-varhelpers';
-import { SimpleType } from '../simple-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = void 0;
+const tslib_1 = require("tslib");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const simple_type_js_1 = require("../simple-type.js");
 let StringType = class StringType {
     decode(v) {
-        return toString(v);
+        return (0, putil_varhelpers_1.toString)(v);
     }
     encode(v) {
-        return toString(v);
+        return (0, putil_varhelpers_1.toString)(v);
     }
     coerce(v) {
         return this.decode(v);
     }
 };
-StringType = __decorate([
-    SimpleType({
+StringType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'A sequence of characters',
         ctor: String
     })
 ], StringType);
-export { StringType };
+exports.StringType = StringType;

package/esm/document/data-type/builtin/time.type.js

@@ -1,8 +1,11 @@
-import { __decorate } from "tslib";
-import { SimpleType } from '../simple-type.js';
-import { StringType } from './string.type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeType = void 0;
+const tslib_1 = require("tslib");
+const simple_type_js_1 = require("../simple-type.js");
+const string_type_js_1 = require("./string.type.js");
 const TIME_PATTERN = /^([01][0-9]|2[0-3]):?([0-5][0-9]):?([0-5][0-9])?(?:\.(\d+))?$/;
-let TimeType = class TimeType extends StringType {
+let TimeType = class TimeType extends string_type_js_1.StringType {
     decode(v) {
         if (v == null)
             return v;
@@ -21,9 +24,9 @@ let TimeType = class TimeType extends StringType {
             throw new TypeError(`Invalid Time value "${v}"`);
     }
 };
-TimeType = __decorate([
-    SimpleType({
+TimeType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'Time formatted string',
     })
 ], TimeType);
-export { TimeType };
+exports.TimeType = TimeType;

package/esm/document/data-type/builtin/timestamp.type.js

@@ -1,26 +1,29 @@
-import { __decorate } from "tslib";
-import dayjs from 'dayjs';
-import { SimpleType } from '../simple-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampType = void 0;
+const tslib_1 = require("tslib");
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+const simple_type_js_1 = require("../simple-type.js");
 let TimestampType = class TimestampType {
     constructor() {
         this.format = 'YYYY-MM-DDTHH:mm:ss';
     }
     decode(v) {
-        return dayjs(v).toDate();
+        return (0, dayjs_1.default)(v).toDate();
     }
     encode(v) {
         if (!v)
             return undefined;
-        const d = dayjs(v);
+        const d = (0, dayjs_1.default)(v);
         if (!d.isValid())
             throw new TypeError(`Invalid date value ${v}`);
-        return dayjs(v).format(this.format);
+        return (0, dayjs_1.default)(v).format(this.format);
     }
 };
-TimestampType = __decorate([
-    SimpleType({
+TimestampType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
         description: 'date-time notation as defined by RFC 3339, section 5.6, for example, 2021-04-18T09:12:53',
         ctor: Date
     })
 ], TimestampType);
-export { TimestampType };
+exports.TimestampType = TimestampType;

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

@@ -1,62 +1,66 @@
-import omit from 'lodash.omit';
-import { omitUndefined, pathToObjectTree, ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY, TYPENAME_PATTERN } from '../constants.js';
-import { ApiField } from './api-field.js';
-import { DataType } from './data-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexType = void 0;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const api_field_js_1 = require("./api-field.js");
+const data_type_js_1 = require("./data-type.js");
 /**
  * @class ComplexType
  */
-export const ComplexType = function (...args) {
+exports.ComplexType = function (...args) {
     // ClassDecorator
     if (!this) {
         const [options] = args;
         return function (target) {
-            const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-            let metadata = Reflect.getOwnMetadata(METADATA_KEY, target);
+            const name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
+            let metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target);
             if (!metadata) {
                 metadata = {};
-                Reflect.defineMetadata(METADATA_KEY, metadata, target);
+                Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
             }
-            metadata.kind = OpraSchema.ComplexType.Kind;
+            metadata.kind = index_js_2.OpraSchema.ComplexType.Kind;
             metadata.name = name;
             // Merge options
             if (options)
-                Object.assign(metadata, omit(options, ['kind', 'name', 'base', 'ctor', 'fields']));
+                Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name', 'base', 'ctor', 'fields']));
         };
     }
     // Constructor
     // call super()
-    DataType.apply(this, args);
+    data_type_js_1.DataType.apply(this, args);
     const [, init] = args;
     const _this = this;
     const own = _this.own;
     own.ctor = init?.ctor;
-    own.fields = new ResponsiveMap();
+    own.fields = new index_js_1.ResponsiveMap();
     own.abstract = init?.abstract;
     own.additionalFields = init?.additionalFields;
-    _this.kind = OpraSchema.ComplexType.Kind;
+    _this.kind = index_js_2.OpraSchema.ComplexType.Kind;
     _this.base = init?.base;
     _this.ctor = own.ctor || Object;
     _this.abstract = own.abstract;
     _this.additionalFields = own.additionalFields;
-    _this.fields = new ResponsiveMap();
+    _this.fields = new index_js_1.ResponsiveMap();
     if (_this.base) {
         if (_this.additionalFields == null)
             _this.additionalFields = _this.base.additionalFields;
-        if (own.ctor == null && _this.base instanceof ComplexType)
+        if (own.ctor == null && _this.base instanceof exports.ComplexType)
             _this.ctor = _this.base.ctor;
         if (_this.base.fields)
             for (const [k, el] of _this.base.fields.entries()) {
-                const newEl = new ApiField(_this, el);
+                const newEl = new api_field_js_1.ApiField(_this, el);
                 _this.fields.set(k, newEl);
             }
     }
 };
-Object.setPrototypeOf(ComplexType.prototype, DataType.prototype);
+Object.setPrototypeOf(exports.ComplexType.prototype, data_type_js_1.DataType.prototype);
 const proto = {
     extendsFrom(t) {
-        const base = t instanceof DataType ? t : this.document.getDataType(t);
+        const base = t instanceof data_type_js_1.DataType ? t : this.document.getDataType(t);
         if (this.base) {
             if (this.base === base)
                 return true;
@@ -65,8 +69,8 @@ const proto = {
         return false;
     },
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
+        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
+        Object.assign(out, (0, index_js_1.omitUndefined)({
             base: this.base ?
                 (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
             abstract: this.own.abstract,
@@ -78,10 +82,10 @@ const proto = {
                 fields[field.name] = field.exportSchema();
             }
         }
-        return omitUndefined(out);
+        return (0, index_js_1.omitUndefined)(out);
     },
     addField(init) {
-        const field = new ApiField(this, init);
+        const field = new api_field_js_1.ApiField(this, init);
         this.own.fields.set(field.name, field);
         this.fields.set(field.name, field);
         return field;
@@ -93,8 +97,8 @@ const proto = {
             const l = arr.length;
             let field;
             for (let i = 0; i < l; i++) {
-                if (!(dt instanceof ComplexType))
-                    throw new TypeError(`"${arr.slice(0, i - 1)}" field is not a ${OpraSchema.ComplexType.Kind} and has no child fields`);
+                if (!(dt instanceof exports.ComplexType))
+                    throw new TypeError(`"${arr.slice(0, i - 1)}" field is not a ${index_js_2.OpraSchema.ComplexType.Kind} and has no child fields`);
                 field = dt.getField(arr[i]);
                 dt = field.type;
             }
@@ -107,13 +111,13 @@ const proto = {
         return t;
     },
     normalizeFieldNames(fields) {
-        const fieldsTree = (fields && pathToObjectTree(Array.isArray(fields) ? fields : [fields])) || {};
+        const fieldsTree = (fields && (0, index_js_1.pathToObjectTree)(Array.isArray(fields) ? fields : [fields])) || {};
         const out = _normalizeFieldsNames([], this.document, this, fieldsTree, '', '');
         return out.length ? out : undefined;
     }
 };
-Object.assign(ComplexType.prototype, proto);
-Object.setPrototypeOf(ComplexType.prototype, DataType.prototype);
+Object.assign(exports.ComplexType.prototype, proto);
+Object.setPrototypeOf(exports.ComplexType.prototype, data_type_js_1.DataType.prototype);
 /**
  * Normalizes field names
  */
@@ -134,7 +138,7 @@ function _normalizeFieldsNames(target, document, dataType, node, parentPath = ''
         }
         curPath = parentPath ? parentPath + '.' + field.name : field.name;
         if (typeof nodeVal === 'object') {
-            if (!(field.type instanceof ComplexType))
+            if (!(field.type instanceof exports.ComplexType))
                 throw new TypeError(`"${(actualPath ? actualPath + '.' + curPath : curPath)}" is not a complex type and has no sub fields`);
             if (target.findIndex(x => x === parentPath) >= 0)
                 continue;

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

@@ -1,7 +1,10 @@
-import { omitUndefined } from '../../helpers/index.js';
-import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/inspect.util.js';
-export const DataType = function (document, init) {
-    if (!(this instanceof DataType)) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const inspect_util_js_1 = require("../utils/inspect.util.js");
+exports.DataType = function (document, init) {
+    if (!(this instanceof exports.DataType)) {
         throw new TypeError(`Class constructor must be called with "new" keyword`);
         // noinspection UnreachableCodeJS
         return;
@@ -27,7 +30,7 @@ const proto = {
         return false;
     },
     exportSchema() {
-        return omitUndefined({
+        return (0, index_js_1.omitUndefined)({
             kind: this.kind,
             description: this.own.description
         });
@@ -35,9 +38,9 @@ const proto = {
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#anonymous'}]`;
     },
-    [nodeInspectCustom]() {
-        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
-            ` ${colorFgMagenta + this.name + colorReset}]`;
+    [inspect_util_js_1.nodeInspectCustom]() {
+        return `[${inspect_util_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + inspect_util_js_1.colorReset}` +
+            ` ${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
     }
 };
-Object.assign(DataType.prototype, proto);
+Object.assign(exports.DataType.prototype, proto);

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

@@ -1,12 +1,16 @@
-import omit from 'lodash.omit';
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-import { DataType } from './data-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumType = void 0;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const data_type_js_1 = require("./data-type.js");
 /**
  * @class EnumType
  */
-export const EnumType = function (...args) {
+exports.EnumType = function (...args) {
     // Injector
     if (!this) {
         const [source, options] = args;
@@ -17,20 +21,20 @@ export const EnumType = function (...args) {
             }, {})
             : source;
         const metadata = {
-            kind: OpraSchema.EnumType.Kind,
+            kind: index_js_2.OpraSchema.EnumType.Kind,
             values
         };
         if (options)
-            Object.assign(metadata, omit(options, ['kind', 'values']));
-        Reflect.defineMetadata(METADATA_KEY, metadata, source);
+            Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'values']));
+        Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, source);
         return values;
     }
     // Constructor
     const [, init] = args;
     // call super()
-    DataType.apply(this, args);
+    data_type_js_1.DataType.apply(this, args);
     const _this = this;
-    _this.kind = OpraSchema.EnumType.Kind;
+    _this.kind = index_js_2.OpraSchema.EnumType.Kind;
     _this.base = init.base;
     const own = _this.own;
     own.values = init.values;
@@ -40,8 +44,8 @@ export const EnumType = function (...args) {
 };
 const proto = {
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
+        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
+        Object.assign(out, (0, index_js_1.omitUndefined)({
             base: this.base ?
                 (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
             values: this.own.values,
@@ -54,5 +58,5 @@ const proto = {
             throw new Error(`'${v}' is not a valid'${this.name ? ' ' + this.name : ''}' value`);
     }
 };
-Object.assign(EnumType.prototype, proto);
-Object.setPrototypeOf(EnumType.prototype, DataType.prototype);
+Object.assign(exports.EnumType.prototype, proto);
+Object.setPrototypeOf(exports.EnumType.prototype, data_type_js_1.DataType.prototype);

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

@@ -1,11 +1,14 @@
-import { applyMixins, inheritPropertyInitializers, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-import { DataType } from './data-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitType = exports.PickType = exports.MappedType = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const data_type_js_1 = require("./data-type.js");
 /**
  * @class MappedType
  */
-export const MappedType = function (...args) {
+exports.MappedType = function (...args) {
     let pickKeys;
     let omitKeys;
     const isInheritedPredicate = (propertyName) => {
@@ -22,16 +25,16 @@ export const MappedType = function (...args) {
         omitKeys = options.omit && options.omit.map(x => String(x).toLowerCase());
         class MappedClass {
             constructor() {
-                inheritPropertyInitializers(this, source, isInheritedPredicate);
+                (0, index_js_1.inheritPropertyInitializers)(this, source, isInheritedPredicate);
             }
         }
-        applyMixins(MappedClass, source);
+        (0, index_js_1.applyMixins)(MappedClass, source);
         // const mappedTypeMetadata: MappedType.TypeMapping[] = [];
-        const m = Reflect.getOwnMetadata(METADATA_KEY, source);
+        const m = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, source);
         if (!m)
             throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
-        if (!(m.kind === OpraSchema.ComplexType.Kind))
-            throw new TypeError(`Class "${source}" is not a ${OpraSchema.ComplexType.Kind}`);
+        if (!(m.kind === index_js_2.OpraSchema.ComplexType.Kind))
+            throw new TypeError(`Class "${source}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}`);
         const metadata = {
             kind: 'MappedType',
             type: source
@@ -40,8 +43,8 @@ export const MappedType = function (...args) {
             metadata.pick = options.pick;
         if (options.omit)
             metadata.omit = options.omit;
-        Reflect.defineMetadata(METADATA_KEY, metadata, MappedClass);
-        MappedType._applyMixin(MappedClass, source, {
+        Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, MappedClass);
+        exports.MappedType._applyMixin(MappedClass, source, {
             ...options,
             isInheritedPredicate
         });
@@ -49,7 +52,7 @@ export const MappedType = function (...args) {
     }
     // Constructor
     // call super()
-    DataType.apply(this, args);
+    data_type_js_1.DataType.apply(this, args);
     const [, init] = args;
     pickKeys = init.pick && init.pick.map(x => String(x).toLowerCase());
     omitKeys = init.omit && init.omit.map(x => String(x).toLowerCase());
@@ -58,22 +61,22 @@ export const MappedType = function (...args) {
     own.type = init.type;
     own.pick = init.pick;
     own.omit = init.omit;
-    _this.kind = OpraSchema.MappedType.Kind;
+    _this.kind = index_js_2.OpraSchema.MappedType.Kind;
     _this.type = own.type;
     _this.pick = own.pick;
     _this.omit = own.omit;
-    _this.fields = new ResponsiveMap();
+    _this.fields = new index_js_1.ResponsiveMap();
     _this.additionalFields = _this.type.additionalFields;
     for (const [elemName, elem] of own.type.fields.entries()) {
         if (isInheritedPredicate(elemName))
             _this.fields.set(elemName, elem);
     }
 };
-MappedType._applyMixin = () => void 0;
+exports.MappedType._applyMixin = () => void 0;
 const proto = {
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
+        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
+        Object.assign(out, (0, index_js_1.omitUndefined)({
             type: this.own.type.name ? this.own.type.name : this.own.type.exportSchema(),
             pick: this.own.pick,
             omit: this.own.omit,
@@ -81,11 +84,13 @@ const proto = {
         return out;
     }
 };
-Object.assign(MappedType.prototype, proto);
-Object.setPrototypeOf(MappedType.prototype, DataType.prototype);
-export function PickType(classRef, keys) {
-    return MappedType(classRef, { pick: keys });
+Object.assign(exports.MappedType.prototype, proto);
+Object.setPrototypeOf(exports.MappedType.prototype, data_type_js_1.DataType.prototype);
+function PickType(classRef, keys) {
+    return (0, exports.MappedType)(classRef, { pick: keys });
 }
-export function OmitType(classRef, keys) {
-    return MappedType(classRef, { omit: keys });
+exports.PickType = PickType;
+function OmitType(classRef, keys) {
+    return (0, exports.MappedType)(classRef, { omit: keys });
 }
+exports.OmitType = OmitType;

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

@@ -1,32 +1,36 @@
-import omit from 'lodash.omit';
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY, TYPENAME_PATTERN } from '../constants.js';
-import { DataType } from './data-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleType = void 0;
+const tslib_1 = require("tslib");
+const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const data_type_js_1 = require("./data-type.js");
 /**
  * @class SimpleType
  */
-export const SimpleType = function (...args) {
+exports.SimpleType = function (...args) {
     // ClassDecorator
     if (!this) {
         const [options] = args;
         return function (target) {
-            let name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
+            let name = options?.name || target.name.match(constants_js_1.TYPENAME_PATTERN)?.[1] || target.name;
             name = name.charAt(0).toLowerCase() + name.substring(1);
-            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-            metadata.kind = OpraSchema.SimpleType.Kind;
+            const metadata = Reflect.getOwnMetadata(constants_js_1.METADATA_KEY, target) || {};
+            metadata.kind = index_js_2.OpraSchema.SimpleType.Kind;
             metadata.name = name;
             if (options)
-                Object.assign(metadata, omit(options, ['kind', 'name', 'base']));
-            Reflect.defineMetadata(METADATA_KEY, metadata, target);
+                Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'name', 'base']));
+            Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, target);
         };
     }
     // Constructor
     const [, options] = args;
     // call super()
-    DataType.apply(this, args);
+    data_type_js_1.DataType.apply(this, args);
     const _this = this;
-    _this.kind = OpraSchema.SimpleType.Kind;
+    _this.kind = index_js_2.OpraSchema.SimpleType.Kind;
     _this.base = options?.base;
     const own = _this.own;
     own.codec = options?.codec;
@@ -43,8 +47,8 @@ export const SimpleType = function (...args) {
 };
 const proto = {
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
+        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
+        Object.assign(out, (0, index_js_1.omitUndefined)({
             base: this.base ?
                 (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
             codec: this.own.codec,
@@ -53,5 +57,5 @@ const proto = {
         return out;
     }
 };
-Object.assign(SimpleType.prototype, proto);
-Object.setPrototypeOf(SimpleType.prototype, DataType.prototype);
+Object.assign(exports.SimpleType.prototype, proto);
+Object.setPrototypeOf(exports.SimpleType.prototype, data_type_js_1.DataType.prototype);