@opra/common 0.33.13 → 1.0.0-alpha.2

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

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexTypeBase = exports.FIELD_PATH_PATTERN = void 0;
+const ts_gems_1 = require("ts-gems");
+const valgen_1 = require("valgen");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../i18n/index.js");
+const data_type_js_1 = require("./data-type.js");
+exports.FIELD_PATH_PATTERN = /^([+-])?([a-z$_][\w.]*)$/i;
+/**
+ *
+ * @constructor
+ */
+exports.ComplexTypeBase = function (...args) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    // 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.fields = new index_js_1.ResponsiveMap();
+};
+/**
+ *
+ */
+class ComplexTypeBaseClass extends data_type_js_1.DataType {
+    /**
+     *
+     */
+    findField(nameOrPath) {
+        if (nameOrPath.includes('.')) {
+            const fieldPath = this.parseFieldPath(nameOrPath);
+            const lastItem = fieldPath.pop();
+            return lastItem?.field;
+        }
+        return this.fields.get(nameOrPath);
+    }
+    /**
+     *
+     */
+    getField(nameOrPath) {
+        const field = this.findField(nameOrPath);
+        if (!field)
+            throw new Error((0, index_js_2.translate)('error:UNKNOWN_FIELD', { field: nameOrPath }));
+        return field;
+    }
+    /**
+     *
+     */
+    parseFieldPath(fieldPath, options) {
+        let dataType = this;
+        let field;
+        const arr = fieldPath.split('.');
+        const len = arr.length;
+        const out = [];
+        const objectType = this.owner.node.getDataType('object');
+        const allowSigns = options?.allowSigns;
+        const getStrPath = () => out.map(x => x.fieldName).join('.');
+        for (let i = 0; i < len; i++) {
+            const item = {
+                fieldName: arr[i],
+                dataType: objectType,
+            };
+            out.push(item);
+            const m = exports.FIELD_PATH_PATTERN.exec(arr[i]);
+            if (!m)
+                throw new TypeError(`Invalid field name (${getStrPath()})`);
+            if (m[1]) {
+                if ((i === 0 && allowSigns === 'first') || allowSigns === 'each')
+                    item.sign = m[1];
+                item.fieldName = m[2];
+            }
+            if (dataType) {
+                if (dataType instanceof exports.ComplexTypeBase) {
+                    field = dataType.fields.get(item.fieldName);
+                    if (field) {
+                        item.fieldName = field.name;
+                        item.field = field;
+                        item.dataType = field.type;
+                        dataType = field.type;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === true) {
+                        item.additionalField = true;
+                        item.dataType = objectType;
+                        dataType = undefined;
+                        continue;
+                    }
+                    if (dataType.additionalFields?.[0] === 'type' && dataType.additionalFields?.[1] instanceof data_type_js_1.DataType) {
+                        item.additionalField = true;
+                        item.dataType = dataType.additionalFields[1];
+                        dataType = dataType.additionalFields[1];
+                        continue;
+                    }
+                    throw new Error(`Unknown field (${out.map(x => x.fieldName).join('.')})`);
+                }
+                throw new TypeError(`"${out.map(x => x.fieldName).join('.')}" field is not a complex type and has no child fields`);
+            }
+            item.additionalField = true;
+            item.dataType = objectType;
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    normalizeFieldPath(fieldPath, options) {
+        return this.parseFieldPath(fieldPath, options)
+            .map(x => (x.sign || '') + x.fieldName)
+            .join('.');
+    }
+    /**
+     *
+     */
+    generateCodec(codec, options) {
+        const projection = Array.isArray(options?.projection)
+            ? (0, index_js_1.parseFieldsProjection)(options.projection)
+            : options?.projection;
+        const schema = this._generateSchema(codec, { ...options, projection, currentPath: '' });
+        let additionalFields;
+        if (this.additionalFields instanceof data_type_js_1.DataType)
+            additionalFields = this.additionalFields.generateCodec(codec, options);
+        else if (typeof this.additionalFields === 'boolean')
+            additionalFields = this.additionalFields;
+        else if (Array.isArray(this.additionalFields)) {
+            if (this.additionalFields.length < 2)
+                additionalFields = 'error';
+            else {
+                const message = additionalFields[1];
+                additionalFields = (0, valgen_1.validator)((input, context, _this) => context.fail(_this, message, input));
+            }
+        }
+        return valgen_1.vg.isObject(schema, {
+            ctor: this.ctor,
+            additionalFields,
+            name: this.name,
+            coerce: true,
+            caseInSensitive: options?.caseInSensitive,
+            onFail: options?.onFail,
+        });
+    }
+    _generateSchema(codec, context) {
+        const schema = {};
+        const { currentPath, projection } = context;
+        const pickList = !!(projection && Object.values(projection).find(p => !p.sign));
+        // Process fields
+        let fieldName;
+        for (const field of this.fields.values()) {
+            fieldName = field.name;
+            let p;
+            if (projection !== '*') {
+                p = projection?.[fieldName.toLowerCase()];
+                if (
+                /** Ignore if field is omitted */
+                p?.sign === '-' ||
+                    /** Ignore if default fields ignored and field is not in projection */
+                    (pickList && !p) ||
+                    /** Ignore if default fields enabled and fields is exclusive */
+                    (!pickList && field.exclusive && !p)) {
+                    schema[field.name] = valgen_1.vg.isUndefined({ coerce: true });
+                    continue;
+                }
+            }
+            const fn = this._generateFieldCodec(codec, field, {
+                ...context,
+                partial: context.partial === 'deep' ? context.partial : undefined,
+                projection: projection !== '*' ? projection : p?.projection,
+                currentPath: currentPath + (currentPath ? '.' : '') + fieldName,
+            });
+            schema[fieldName] = context.partial || !field.required ? valgen_1.vg.optional(fn) : valgen_1.vg.required(fn);
+        }
+        return schema;
+    }
+    _generateFieldCodec(codec, field, context) {
+        let fn = field.type.generateCodec(codec, context);
+        if (field.fixed)
+            fn = valgen_1.vg.isEnum([field.fixed]);
+        if (field.isArray)
+            fn = valgen_1.vg.isArray(fn);
+        return fn;
+    }
+}
+exports.ComplexTypeBase.prototype = ComplexTypeBaseClass.prototype;

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

@@ -1,26 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComplexType = void 0;
-const tslib_1 = require("tslib");
 require("reflect-metadata");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const document_init_context_js_1 = require("../common/document-init-context.js");
 const constants_js_1 = require("../constants.js");
-const complex_type_decorator_js_1 = require("./complex-type.decorator.js");
-const complex_type_class_js_1 = require("./complex-type-class.js");
+const complex_type_decorator_js_1 = require("../decorators/complex-type.decorator.js");
+const api_field_js_1 = require("./api-field.js");
+const complex_type_base_js_1 = require("./complex-type-base.js");
+const data_type_js_1 = require("./data-type.js");
 /**
- * @class ComplexType
- * @decorator ComplexType
+ * ComplexType constructor
  */
 exports.ComplexType = function (...args) {
     // Decorator
-    if (!this) {
-        const [options] = args;
-        return exports.ComplexType[constants_js_1.DECORATOR](options);
-    }
+    if (!this)
+        return exports.ComplexType[constants_js_1.DECORATOR].apply(undefined, args);
     // Constructor
-    const [document, init] = args;
-    (0, putil_merge_1.default)(this, new complex_type_class_js_1.ComplexTypeClass(document, init), { descriptor: true });
+    const [owner, initArgs] = args;
+    const context = args[2] || new document_init_context_js_1.DocumentInitContext({ maxErrors: 0 });
+    complex_type_base_js_1.ComplexTypeBase.call(this, owner, initArgs, context);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = index_js_2.OpraSchema.ComplexType.Kind;
+    _this.additionalFields = initArgs.additionalFields;
+    _this.keyField = initArgs.keyField;
+    if (initArgs.base) {
+        context.enter('.base', () => {
+            // noinspection SuspiciousTypeOfGuard
+            if (!(initArgs.base instanceof complex_type_base_js_1.ComplexTypeBase))
+                throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+            _this.base = initArgs.base;
+            if (_this.additionalFields == null && _this.base.additionalFields)
+                _this.additionalFields = _this.base.additionalFields;
+            /** Copy fields from base */
+            for (const v of _this.base.fields.values()) {
+                this.fields.set(v.name, new api_field_js_1.ApiField(this, v));
+            }
+        });
+    }
+    _this.ctor = initArgs.ctor || _this.base?.ctor;
+    /** Add own fields */
+    if (initArgs.fields) {
+        context.enter('.fields', () => {
+            for (const [k, v] of Object.entries(initArgs.fields)) {
+                const field = new api_field_js_1.ApiField(this, {
+                    ...v,
+                    name: k,
+                });
+                this.fields.set(field.name, field);
+            }
+        });
+    }
 };
-exports.ComplexType.prototype = complex_type_class_js_1.ComplexTypeClass.prototype;
+/**
+ *
+ * @class ComplexType
+ */
+class ComplexTypeClass extends complex_type_base_js_1.ComplexTypeBase {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof complex_type_base_js_1.ComplexTypeBase))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
+    }
+    toJSON() {
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        const out = (0, index_js_1.omitUndefined)({
+            ...complex_type_base_js_1.ComplexTypeBase.prototype.toJSON.call(this),
+            kind: this.kind,
+            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
+        });
+        if (this.additionalFields) {
+            if (this.additionalFields instanceof data_type_js_1.DataType) {
+                out.additionalFields = this.additionalFields[1].name
+                    ? this.additionalFields[1].name
+                    : this.additionalFields[1].toJSON();
+            }
+            else
+                out.additionalFields = this.additionalFields;
+        }
+        if (this.fields.size) {
+            const fields = {};
+            let i = 0;
+            for (const field of this.fields.values()) {
+                if (field.origin === this) {
+                    fields[field.name] = field.toJSON();
+                    i++;
+                }
+            }
+            if (i)
+                out.fields = fields;
+        }
+        return (0, index_js_1.omitUndefined)(out);
+    }
+}
+exports.ComplexType.prototype = ComplexTypeClass.prototype;
 Object.assign(exports.ComplexType, complex_type_decorator_js_1.ComplexTypeDecorator);
 exports.ComplexType[constants_js_1.DECORATOR] = complex_type_decorator_js_1.ComplexTypeDecorator;

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

@@ -1,44 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataType = void 0;
+const ts_gems_1 = require("ts-gems");
 const index_js_1 = require("../../helpers/index.js");
+const document_element_js_1 = require("../common/document-element.js");
+const constants_js_1 = require("../constants.js");
 const inspect_util_js_1 = require("../utils/inspect.util.js");
 /**
+ * DataType constructor
+ */
+exports.DataType = function (owner, initArgs, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+context) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    if (initArgs?.name && !constants_js_1.CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`"${initArgs.name}" is not a valid DataType name`);
+    document_element_js_1.DocumentElement.call(this, owner);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = initArgs.kind;
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.abstract = initArgs.abstract;
+    _this.examples = initArgs.examples;
+};
+/**
+ *
  * @class DataType
- * @abstract
  */
-class DataType {
-    constructor(document, init) {
-        this.document = document;
-        this.name = init?.name;
-        this.own = {};
-        this.description = init?.description;
-        if (!this.name)
-            this.isEmbedded = true;
+class DataTypeClass extends document_element_js_1.DocumentElement {
+    get embedded() {
+        return !this.name;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    exportSchema(options) {
+    toJSON() {
         return (0, index_js_1.omitUndefined)({
             kind: this.kind,
-            description: this.description
+            description: this.description,
+            abstract: this.abstract,
+            examples: this.examples,
         });
     }
-    extendsFrom(type) {
-        const dataType = type instanceof DataType ? type : this.document.getDataType(type);
-        let t = this;
-        while (t) {
-            if (t === dataType)
-                return true;
-            t = t.base;
-        }
-        return false;
-    }
     toString() {
         return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || '#Embedded'}]`;
     }
     [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}]`;
+        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}]`);
     }
 }
-exports.DataType = DataType;
+exports.DataType.prototype = DataTypeClass.prototype;

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

@@ -1,52 +1,108 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumType = void 0;
-const tslib_1 = require("tslib");
 require("reflect-metadata");
-const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
+const ts_gems_1 = require("ts-gems");
+const valgen_1 = require("valgen");
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
-const enum_type_class_js_1 = require("./enum-type-class.js");
+const data_type_js_1 = require("./data-type.js");
 /**
  * @class EnumType
  */
 exports.EnumType = function (...args) {
     // Injector
-    if (!this) {
-        const [enumSource, options] = args;
-        let values = {};
-        if (Array.isArray(enumSource)) {
-            values = {};
-            enumSource.forEach(k => {
-                const description = options?.meanings?.[k];
-                values[k] = (0, index_js_1.omitUndefined)({ description });
-            });
+    if (!this)
+        return exports.EnumType[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_2.OpraSchema.EnumType.Kind;
+    if (initArgs.base) {
+        // noinspection SuspiciousTypeOfGuard
+        if (!(initArgs.base instanceof exports.EnumType))
+            throw new TypeError(`"${initArgs.base.kind}" can't be set as base for a "${this.kind}"`);
+        _this.base = initArgs.base;
+    }
+    _this.instance = initArgs.instance;
+    _this.ownAttributes = (0, index_js_1.cloneObject)(initArgs.attributes || {});
+    _this.attributes = _this.base ? (0, index_js_1.cloneObject)(_this.base.attributes) : {};
+    for (const [k, el] of Object.entries(_this.ownAttributes)) {
+        _this.attributes[k] = el;
+    }
+};
+/**
+ * @class EnumType
+ */
+class EnumTypeClass extends data_type_js_1.DataType {
+    extendsFrom(baseType) {
+        if (!(baseType instanceof exports.EnumType))
+            return false;
+        if (baseType === this)
+            return true;
+        return !!this.base?.extendsFrom(baseType);
+    }
+    generateCodec() {
+        return valgen_1.vg.isEnum(Object.keys(this.attributes));
+    }
+    toJSON() {
+        const baseName = this.base ? this.node.getDataTypeNameWithNs(this.base) : undefined;
+        return (0, index_js_1.omitUndefined)({
+            ...data_type_js_1.DataType.prototype.toJSON.call(this),
+            base: this.base ? (baseName ? baseName : this.base.toJSON()) : undefined,
+            attributes: (0, index_js_1.cloneObject)(this.ownAttributes),
+        });
+    }
+}
+exports.EnumType.prototype = EnumTypeClass.prototype;
+Object.assign(exports.EnumType, EnumTypeClass);
+/**
+ *
+ */
+function EnumTypeFactory(enumSource, ...args) {
+    const base = args.length >= 2 ? args[0] : undefined;
+    const options = args.length >= 2 ? args[1] : args[0];
+    let attributes = {};
+    let out = enumSource;
+    if (Array.isArray(enumSource)) {
+        if (base) {
+            if (!Array.isArray(base))
+                throw new TypeError('Both "target" and "base" arguments should be array');
+            out = [...base, ...enumSource];
         }
-        else {
-            Object.keys(enumSource).forEach(k => {
-                const description = options?.meanings?.[k];
-                values[enumSource[k]] = (0, index_js_1.omitUndefined)({ key: k, description });
-            });
+        attributes = {};
+        enumSource.forEach(k => {
+            const description = options?.meanings?.[k];
+            attributes[k] = (0, index_js_1.omitUndefined)({ description });
+        });
+    }
+    else {
+        if (base) {
+            if (Array.isArray(base))
+                throw new TypeError('Both "target" and "base" arguments should be enum object');
+            out = { ...base, ...enumSource };
         }
-        const metadata = {
-            kind: index_js_2.OpraSchema.EnumType.Kind,
-            values,
-            base: options?.base,
-            name: options?.name,
-            description: options?.description
-        };
-        Object.defineProperty(enumSource, constants_js_1.DATATYPE_METADATA, {
-            value: metadata,
-            enumerable: false,
-            configurable: true,
-            writable: true
+        Object.keys(enumSource).forEach(k => {
+            const description = options?.meanings?.[k];
+            attributes[enumSource[k]] = (0, index_js_1.omitUndefined)({ alias: k, description });
         });
-        return metadata;
     }
-    // Constructor
-    const [document, init] = args;
-    (0, putil_merge_1.default)(this, new enum_type_class_js_1.EnumTypeClass(document, init), { descriptor: true });
-    return;
-};
-exports.EnumType.prototype = enum_type_class_js_1.EnumTypeClass.prototype;
+    const metadata = {
+        kind: index_js_2.OpraSchema.EnumType.Kind,
+        attributes,
+        base: options.base,
+        name: options.name,
+        description: options?.description,
+    };
+    Object.defineProperty(enumSource, constants_js_1.DATATYPE_METADATA, {
+        value: metadata,
+        enumerable: false,
+        configurable: true,
+        writable: true,
+    });
+    return out;
+}
+exports.EnumType.prototype = EnumTypeClass.prototype;
+exports.EnumType[constants_js_1.DECORATOR] = EnumTypeFactory;

package/cjs/document/data-type/{builtin → extended-types}/base64.type.js

@@ -3,14 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Base64Type = void 0;
 const tslib_1 = require("tslib");
 const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
 const simple_type_js_1 = require("../simple-type.js");
 let Base64Type = class Base64Type {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [constants_js_1.DECODER]() {
+        return valgen_1.vg.isBase64({ coerce: true });
+    }
+    [constants_js_1.ENCODER]() {
+        return valgen_1.vg.isBase64({ coerce: true });
+    }
 };
 exports.Base64Type = Base64Type;
 exports.Base64Type = Base64Type = tslib_1.__decorate([
     (0, simple_type_js_1.SimpleType)({
         description: 'A stream of bytes, base64 encoded',
-        decoder: valgen_1.isBase64,
-        encoder: valgen_1.isBase64,
     })
 ], Base64Type);

package/cjs/document/data-type/extended-types/date-string.type.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateStringType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+let DateStringType = class DateStringType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [constants_js_1.DECODER](properties) {
+        const fn = valgen_1.vg.isDateString({ trim: 'date', coerce: true });
+        const x = [];
+        if (properties.minValue)
+            x.push(valgen_1.vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(valgen_1.vg.isLte(properties.maxValue));
+        return x.length > 0 ? valgen_1.vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+    [constants_js_1.ENCODER](properties) {
+        return this[constants_js_1.DECODER](properties);
+    }
+};
+exports.DateStringType = DateStringType;
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Minimum value',
+    })
+], DateStringType.prototype, "minValue", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Maximum value',
+    })
+], DateStringType.prototype, "maxValue", void 0);
+exports.DateStringType = DateStringType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'Date string value',
+    })
+        .Example('2021-04-18', 'Full date value')
+        .Example('2021-04', 'Date value without day')
+        .Example('2021', 'Year only value')
+], DateStringType);

package/cjs/document/data-type/extended-types/date-time-string.type.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeStringType = void 0;
+const tslib_1 = require("tslib");
+const valgen_1 = require("valgen");
+const constants_js_1 = require("../../constants.js");
+const simple_type_js_1 = require("../simple-type.js");
+let DateTimeStringType = class DateTimeStringType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [constants_js_1.DECODER](properties) {
+        const fn = valgen_1.vg.isDateString({ coerce: true });
+        const x = [];
+        if (properties.minValue)
+            x.push(valgen_1.vg.isGte(properties.minValue));
+        if (properties.maxValue)
+            x.push(valgen_1.vg.isLte(properties.maxValue));
+        return x.length > 0 ? valgen_1.vg.pipe([fn, ...x]) : fn;
+    }
+    [constants_js_1.ENCODER](properties) {
+        return this[constants_js_1.DECODER](properties);
+    }
+};
+exports.DateTimeStringType = DateTimeStringType;
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Minimum value',
+    })
+], DateTimeStringType.prototype, "minValue", void 0);
+tslib_1.__decorate([
+    simple_type_js_1.SimpleType.Attribute({
+        description: 'Maximum value',
+    })
+], DateTimeStringType.prototype, "maxValue", void 0);
+exports.DateTimeStringType = DateTimeStringType = tslib_1.__decorate([
+    (0, simple_type_js_1.SimpleType)({
+        description: 'DateTime string value',
+    })
+        .Example('2021-04-18T22:30:15+01:00', 'Full date-time value with timezone')
+        .Example('2021-04-18T22:30:15', 'Full date-time value without timezone')
+        .Example('2021-04-18 22:30', 'Date-time value')
+        .Example('2021-04-18', 'Date value')
+        .Example('2021-04', 'Date value without day')
+        .Example('2021', 'Year only value')
+], DateTimeStringType);