@opra/common 1.17.7 → 1.19.1

package/esm/document/data-type/extended-types/date.type.js

@@ -1,41 +1,48 @@
 import { __decorate, __metadata } from "tslib";
-import { isDateString, toString, vg } from 'valgen';
+import { vg } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 import { SimpleType } from '../simple-type.js';
+const _isDateString = vg.isDateString({
+    precisionMin: 'day',
+    trim: 'day',
+    coerce: true,
+});
+const _isDate = vg.isDate({
+    trim: 'day',
+    coerce: true,
+});
 let DateType = class DateType {
     constructor(attributes) {
         if (attributes)
             Object.assign(this, attributes);
     }
     [DECODER](properties) {
-        const fn = vg.isDate({ precision: 'date', coerce: true });
-        const x = [];
+        let fn;
+        if (properties.convertToNative) {
+            fn = _isDate;
+        }
+        else {
+            fn = _isDateString;
+        }
+        const x = [fn];
         if (properties.minValue != null) {
-            isDateString(properties.minValue);
-            x.push(toString, vg.isGte(properties.minValue));
+            x.push(vg.isGte(fn(properties.minValue)));
         }
         if (properties.maxValue != null) {
-            isDateString(properties.maxValue);
-            x.push(toString, vg.isLte(properties.maxValue));
+            x.push(vg.isLte(fn(properties.maxValue)));
         }
-        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+        return x.length > 0 ? vg.pipe(x, { returnIndex: 0 }) : fn;
     }
     [ENCODER](properties) {
-        const fn = vg.isDateString({
-            precision: 'date',
-            trim: 'date',
-            coerce: true,
-        });
-        const x = [];
+        const fn = _isDateString;
+        const x = [fn];
         if (properties.minValue != null) {
-            isDateString(properties.minValue);
-            x.push(vg.isGte(properties.minValue));
+            x.push(vg.isGte(fn(properties.minValue)));
         }
         if (properties.maxValue != null) {
-            isDateString(properties.maxValue);
-            x.push(vg.isLte(properties.maxValue));
+            x.push(vg.isLte(fn(properties.maxValue)));
         }
-        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+        return x.length > 0 ? vg.pipe(x, { returnIndex: 0 }) : fn;
     }
 };
 __decorate([

package/esm/document/data-type/extended-types/index.js

@@ -1,13 +1,13 @@
 export * from './base64.type.js';
 export * from './date.type.js';
-export * from './date-string.type.js';
 export * from './date-time.type.js';
-export * from './date-time-string.type.js';
+export * from './date-time-tz.type.js';
 export * from './email.type.js';
 export * from './field-path.type.js';
 export * from './filter.type.js';
 export * from './object-id.type.js';
 export * from './operation-result.type.js';
+export * from './partial-date.type.js';
 export * from './time.type.js';
 export * from './url.type.js';
 export * from './uuid.type.js';

package/esm/document/data-type/extended-types/partial-date.type.js

@@ -0,0 +1,82 @@
+import { __decorate, __metadata } from "tslib";
+import { isDateString, toString, validator, vg } from 'valgen';
+import { DECODER, ENCODER } from '../../constants.js';
+import { SimpleType } from '../simple-type.js';
+let PartialDateType = class PartialDateType {
+    constructor(attributes) {
+        if (attributes)
+            Object.assign(this, attributes);
+    }
+    [DECODER](properties) {
+        const fn = toPartialDate;
+        const x = [];
+        if (properties.minValue != null) {
+            isDateString(properties.minValue);
+            x.push(toString, vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            isDateString(properties.maxValue);
+            x.push(toString, vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+    [ENCODER](properties) {
+        const fn = toPartialDate;
+        const x = [];
+        if (properties.minValue != null) {
+            isDateString(properties.minValue);
+            x.push(vg.isGte(properties.minValue));
+        }
+        if (properties.maxValue != null) {
+            isDateString(properties.maxValue);
+            x.push(vg.isLte(properties.maxValue));
+        }
+        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
+    }
+};
+__decorate([
+    SimpleType.Attribute({
+        description: 'Minimum value',
+    }),
+    __metadata("design:type", String)
+], PartialDateType.prototype, "minValue", void 0);
+__decorate([
+    SimpleType.Attribute({
+        description: 'Maximum value',
+    }),
+    __metadata("design:type", String)
+], PartialDateType.prototype, "maxValue", void 0);
+PartialDateType = __decorate([
+    (SimpleType({
+        name: 'partialdate',
+        description: 'Specifies a point in time using a 24-hour clock notation.\rFormat: YYYY-[MM-[DD-[T?HH:[MM:[SS[.S[S[S[S]]]]]]]]][+/-ZZ:ZZ].',
+        nameMappings: {
+            js: 'string',
+            json: 'string',
+        },
+    })
+        .Example('2021-04-18T22:30:15:22+03:00')
+        .Example('2021-04-18 22:30')
+        .Example('2021-04-18')
+        .Example('2021')),
+    __metadata("design:paramtypes", [Object])
+], PartialDateType);
+export { PartialDateType };
+const _isDateString = vg.isDateString({
+    precisionMin: 'year',
+});
+const toPartialDate = validator((input) => {
+    if (input instanceof Date) {
+        let s = _isDateString(input, { coerce: true });
+        if (s.endsWith('Z'))
+            s = s.substring(0, s.length - 1);
+        if (s.endsWith('.000'))
+            s = s.substring(0, s.length - 4);
+        if (s.endsWith(':00'))
+            s = s.substring(0, s.length - 3);
+        if (s.endsWith('00:00'))
+            s = s.substring(0, s.length - 6);
+        return s;
+    }
+    return _isDateString(input, { coerce: false });
+});

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

@@ -49,6 +49,10 @@ export const SimpleType = function (...args) {
  * @class SimpleType
  */
 class SimpleTypeClass extends DataType {
+    extend(properties) {
+        Object.setPrototypeOf(properties, this);
+        return properties;
+    }
     extendsFrom(baseType) {
         if (!(baseType instanceof DataType))
             baseType = this.node.getDataType(baseType);

package/esm/document/decorators/api-field-decorator.js

@@ -16,6 +16,7 @@ export function ApiFieldDecoratorFactory(options) {
         const designType = Reflect.getMetadata('design:type', target, propertyKey);
         const elemMeta = (metadata.fields[propertyKey] = {
             ...options,
+            designType,
         });
         if (designType === Array) {
             elemMeta.isArray = true;

package/esm/document/factory/api-document.factory.js

@@ -4,8 +4,8 @@ import { ApiDocument } from '../api-document.js';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { OpraDocumentError } from '../common/opra-document-error.js';
 import { BUILTIN, CLASS_NAME_PATTERN, kCtorMap } from '../constants.js';
-import { Base64Type, DateStringType, DateTimeStringType, DateTimeType, DateType, EmailType, FieldPathType, FilterType, ObjectIdType, OperationResult, TimeType, UrlType, UuidType, } from '../data-type/extended-types/index.js';
-import { AnyType, BigintType, BooleanType, IntegerType, NullType, NumberType, ObjectType, StringType, } from '../data-type/primitive-types/index.js';
+import * as extendedTypes from '../data-type/extended-types/index.js';
+import * as primitiveTypes from '../data-type/primitive-types/index.js';
 import { DataTypeFactory } from './data-type.factory.js';
 import { HttpApiFactory } from './http-api.factory.js';
 import { RpcApiFactory } from './rpc-api.factory.js';
@@ -154,29 +154,8 @@ export class ApiDocumentFactory {
                 },
             },
             types: [
-                // Primitive types
-                AnyType,
-                BigintType,
-                BooleanType,
-                IntegerType,
-                NullType,
-                NumberType,
-                ObjectType,
-                StringType,
-                // Extended types
-                Base64Type,
-                DateType,
-                DateStringType,
-                DateTimeType,
-                DateTimeStringType,
-                EmailType,
-                FieldPathType,
-                FilterType,
-                ObjectIdType,
-                OperationResult,
-                TimeType,
-                UrlType,
-                UuidType,
+                ...Object.values(primitiveTypes),
+                ...Object.values(extendedTypes),
             ],
         };
         const document = new ApiDocument();

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

@@ -147,6 +147,7 @@ export class DataTypeFactory {
      * @param context
      * @param owner
      * @param thunk
+     * @param checkCircularDeps
      * @protected
      */
     static async _importDataTypeArgs(context, owner, thunk, checkCircularDeps) {

package/esm/filter/filter-rules.js

@@ -130,7 +130,7 @@ export class FilterRules {
                             });
                             this._decoderCache.set(comp.left.field, decoder);
                         }
-                        ast.value = decoder(ast.value);
+                        ast.value = decoder(ast.value, { coerce: true });
                     }
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "1.17.7",
+  "version": "1.19.1",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",
@@ -10,7 +10,7 @@
     "@browsery/http-parser": "^0.5.9-r4",
     "@browsery/i18next": "^24.2.2",
     "@browsery/type-is": "^1.6.18-r8",
-    "@jsopen/objects": "^1.6.2",
+    "@jsopen/objects": "^1.6.3",
     "fast-tokenizer": "^1.7.0",
     "object-hash": "^3.0.0",
     "putil-promisify": "^1.10.1",
@@ -19,7 +19,7 @@
     "super-fast-md5": "^1.0.3",
     "tslib": "^2.8.1",
     "uid": "^2.0.2",
-    "valgen": "^5.15.2"
+    "valgen": "^5.17.2"
   },
   "type": "module",
   "exports": {

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

@@ -39,6 +39,7 @@ declare class ApiFieldClass extends DocumentElement {
     readonly owner: ComplexType | MappedType | MixinType;
     readonly origin?: ComplexType | MappedType | MixinType;
     readonly scopePattern?: (string | RegExp)[];
+    readonly convertToNative?: boolean;
     readonly name: string;
     readonly type: DataType;
     readonly description?: string;
@@ -67,7 +68,9 @@ 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;
     }
     interface Options extends Partial<StrictOmit<Metadata, 'override' | 'scopePattern'>> {
         /**
@@ -78,6 +81,11 @@ 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/data-type.d.ts

@@ -60,7 +60,7 @@ declare abstract class DataTypeClass extends DocumentElement {
     readonly description?: string;
     readonly abstract?: boolean;
     readonly examples?: OpraSchema.DataTypeExample[];
-    abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions): Validator;
+    abstract generateCodec(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions, properties?: any): Validator;
     get embedded(): any;
     abstract extendsFrom(baseType: DataType | string | Type | object): boolean;
     inScope(scope?: string | '*'): boolean;

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

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

package/types/document/data-type/extended-types/{date-string.type.d.ts → date-time-tz.type.d.ts}

@@ -1,7 +1,7 @@
 import { type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
-export declare class DateStringType {
-    constructor(attributes?: Partial<DateStringType>);
+export declare class DateTimeTypeTz {
+    constructor(attributes?: Partial<DateTimeTypeTz>);
     protected [DECODER](properties: Partial<this>): Validator;
     protected [ENCODER](properties: Partial<this>): Validator;
     minValue?: string;

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

@@ -1,6 +1,7 @@
 import { type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class DateTimeType {
+    convertToNative?: boolean;
     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,6 +1,7 @@
 import { type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
 export declare class DateType {
+    convertToNative?: boolean;
     constructor(attributes?: Partial<DateType>);
     protected [DECODER](properties: Partial<this>): Validator;
     protected [ENCODER](properties: Partial<this>): Validator;

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

@@ -1,13 +1,13 @@
 export * from './base64.type.js';
 export * from './date.type.js';
-export * from './date-string.type.js';
 export * from './date-time.type.js';
-export * from './date-time-string.type.js';
+export * from './date-time-tz.type.js';
 export * from './email.type.js';
 export * from './field-path.type.js';
 export * from './filter.type.js';
 export * from './object-id.type.js';
 export * from './operation-result.type.js';
+export * from './partial-date.type.js';
 export * from './time.type.js';
 export * from './url.type.js';
 export * from './uuid.type.js';

package/types/document/data-type/extended-types/{date-time-string.type.d.ts → partial-date.type.d.ts}

@@ -1,7 +1,7 @@
 import { type Validator } from 'valgen';
 import { DECODER, ENCODER } from '../../constants.js';
-export declare class DateTimeStringType {
-    constructor(attributes?: Partial<DateTimeStringType>);
+export declare class PartialDateType {
+    constructor(attributes?: Partial<PartialDateType>);
     protected [DECODER](properties: Partial<this>): Validator;
     protected [ENCODER](properties: Partial<this>): Validator;
     minValue?: string;

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

@@ -3,7 +3,7 @@ import type { Combine, Type } from 'ts-gems';
 import { type Validator } from 'valgen';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
-import type { DocumentElement } from '../common/document-element';
+import type { DocumentElement } from '../common/document-element.js';
 import { DocumentInitContext } from '../common/document-init-context.js';
 import { AttributeDecoratorFactory, SimpleTypeDecoratorFactory } from '../decorators/simple-type.decorator.js';
 import { DataType } from './data-type.js';
@@ -22,6 +22,7 @@ export declare namespace SimpleType {
         base?: SimpleType;
         ctor?: Type;
         properties?: object;
+        convertToNative?: boolean;
         generateDecoder?: SimpleType.ValidatorGenerator;
         generateEncoder?: SimpleType.ValidatorGenerator;
     }, DataType.InitArguments, SimpleType.Metadata> {
@@ -71,6 +72,7 @@ declare abstract class SimpleTypeClass extends DataType {
     protected _generateDecoder?: SimpleType.ValidatorGenerator;
     protected _generateEncoder?: SimpleType.ValidatorGenerator;
     properties?: any;
+    extend<T>(properties: Partial<T>): SimpleType & T;
     extendsFrom(baseType: DataType | string | Type | object): boolean;
     generateCodec<T extends Record<string, any> | object = object>(codec: 'encode' | 'decode', options?: DataType.GenerateCodecOptions | null, properties?: Partial<T>): Validator;
     toJSON(options?: ApiDocument.ExportOptions): OpraSchema.SimpleType;

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

@@ -93,6 +93,7 @@ export declare class DataTypeFactory {
      * @param context
      * @param owner
      * @param thunk
+     * @param checkCircularDeps
      * @protected
      */
     protected static _importDataTypeArgs(context: DataTypeFactory.Context, owner: DocumentElement, thunk: string | Type | OpraSchema.DataType | object, checkCircularDeps?: boolean): Promise<DataTypeFactory.DataTypeInitArguments | string | void>;

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

@@ -1,52 +0,0 @@
-"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 != null)
-            x.push(valgen_1.vg.isGte(properties.minValue));
-        if (properties.maxValue != null)
-            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',
-    }),
-    tslib_1.__metadata("design:type", String)
-], DateStringType.prototype, "minValue", void 0);
-tslib_1.__decorate([
-    simple_type_js_1.SimpleType.Attribute({
-        description: 'Maximum value',
-    }),
-    tslib_1.__metadata("design:type", String)
-], DateStringType.prototype, "maxValue", void 0);
-exports.DateStringType = DateStringType = tslib_1.__decorate([
-    ((0, simple_type_js_1.SimpleType)({
-        name: 'datestring',
-        description: 'Date string value',
-        nameMappings: {
-            js: 'string',
-            json: 'string',
-        },
-    })
-        .Example('2021-04-18', 'Full date value')
-        .Example('2021-04', 'Date value without day')
-        .Example('2021', 'Year only value')),
-    tslib_1.__metadata("design:paramtypes", [Object])
-], DateStringType);

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

@@ -1,55 +0,0 @@
-"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 != null)
-            x.push(valgen_1.vg.isGte(properties.minValue));
-        if (properties.maxValue != null)
-            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',
-    }),
-    tslib_1.__metadata("design:type", String)
-], DateTimeStringType.prototype, "minValue", void 0);
-tslib_1.__decorate([
-    simple_type_js_1.SimpleType.Attribute({
-        description: 'Maximum value',
-    }),
-    tslib_1.__metadata("design:type", String)
-], DateTimeStringType.prototype, "maxValue", void 0);
-exports.DateTimeStringType = DateTimeStringType = tslib_1.__decorate([
-    ((0, simple_type_js_1.SimpleType)({
-        name: 'datetimestring',
-        description: 'DateTime string value',
-        nameMappings: {
-            js: 'string',
-            json: 'string',
-        },
-    })
-        .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')),
-    tslib_1.__metadata("design:paramtypes", [Object])
-], DateTimeStringType);

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

@@ -1,49 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { vg } from 'valgen';
-import { DECODER, ENCODER } from '../../constants.js';
-import { SimpleType } from '../simple-type.js';
-let DateStringType = class DateStringType {
-    constructor(attributes) {
-        if (attributes)
-            Object.assign(this, attributes);
-    }
-    [DECODER](properties) {
-        const fn = vg.isDateString({ trim: 'date', coerce: true });
-        const x = [];
-        if (properties.minValue != null)
-            x.push(vg.isGte(properties.minValue));
-        if (properties.maxValue != null)
-            x.push(vg.isLte(properties.maxValue));
-        return x.length > 0 ? vg.pipe([fn, ...x], { returnIndex: 0 }) : fn;
-    }
-    [ENCODER](properties) {
-        return this[DECODER](properties);
-    }
-};
-__decorate([
-    SimpleType.Attribute({
-        description: 'Minimum value',
-    }),
-    __metadata("design:type", String)
-], DateStringType.prototype, "minValue", void 0);
-__decorate([
-    SimpleType.Attribute({
-        description: 'Maximum value',
-    }),
-    __metadata("design:type", String)
-], DateStringType.prototype, "maxValue", void 0);
-DateStringType = __decorate([
-    (SimpleType({
-        name: 'datestring',
-        description: 'Date string value',
-        nameMappings: {
-            js: 'string',
-            json: 'string',
-        },
-    })
-        .Example('2021-04-18', 'Full date value')
-        .Example('2021-04', 'Date value without day')
-        .Example('2021', 'Year only value')),
-    __metadata("design:paramtypes", [Object])
-], DateStringType);
-export { DateStringType };

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

@@ -1,52 +0,0 @@
-import { __decorate, __metadata } from "tslib";
-import { vg } from 'valgen';
-import { DECODER, ENCODER } from '../../constants.js';
-import { SimpleType } from '../simple-type.js';
-let DateTimeStringType = class DateTimeStringType {
-    constructor(attributes) {
-        if (attributes)
-            Object.assign(this, attributes);
-    }
-    [DECODER](properties) {
-        const fn = vg.isDateString({ coerce: true });
-        const x = [];
-        if (properties.minValue != null)
-            x.push(vg.isGte(properties.minValue));
-        if (properties.maxValue != null)
-            x.push(vg.isLte(properties.maxValue));
-        return x.length > 0 ? vg.pipe([fn, ...x]) : fn;
-    }
-    [ENCODER](properties) {
-        return this[DECODER](properties);
-    }
-};
-__decorate([
-    SimpleType.Attribute({
-        description: 'Minimum value',
-    }),
-    __metadata("design:type", String)
-], DateTimeStringType.prototype, "minValue", void 0);
-__decorate([
-    SimpleType.Attribute({
-        description: 'Maximum value',
-    }),
-    __metadata("design:type", String)
-], DateTimeStringType.prototype, "maxValue", void 0);
-DateTimeStringType = __decorate([
-    (SimpleType({
-        name: 'datetimestring',
-        description: 'DateTime string value',
-        nameMappings: {
-            js: 'string',
-            json: 'string',
-        },
-    })
-        .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')),
-    __metadata("design:paramtypes", [Object])
-], DateTimeStringType);
-export { DateTimeStringType };