@opra/common 0.33.13 → 1.0.0-alpha.2

package/types/schema/data-type/field.interface.d.ts

@@ -4,7 +4,7 @@ export declare namespace Field {
     type QualifiedName = string;
 }
 export type Field = {
-    type: DataType.Name | DataType;
+    type?: DataType.Name | DataType;
     /**
      * Defines the description of the field
      */
@@ -20,7 +20,7 @@ export type Field = {
     /**
      * Indicates the fixed value of the field. The value of the field can not be any other value.
      */
-    fixed?: string | number | boolean;
+    fixed?: any;
     /**
      * Indicates if field value required in create operation
      */
@@ -50,12 +50,4 @@ export type Field = {
      * Indicates if the field is deprecated and can be removed in the next
      */
     deprecated?: boolean | string;
-    /**
-     * Defines RegExp pattern for the field. A String type is required for this option
-     */
-    pattern?: string;
-    /**
-     * Indicates if partial update enabled for this field
-     */
-    partialUpdate?: boolean;
 };

package/types/schema/data-type/mapped-type.interface.d.ts

@@ -1,11 +1,15 @@
 import { StrictOmit } from 'ts-gems';
-import { ComplexType } from './complex-type.interface.js';
-import { Field } from './field.interface.js';
-export interface MappedType extends StrictOmit<ComplexType, 'kind'> {
+import type { ComplexType } from './complex-type.interface';
+import type { DataType, DataTypeBase } from './data-type.interface';
+import type { Field } from './field.interface.js';
+import type { MixinType } from './mixin-type.interface.js';
+export interface MappedType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: MappedType.Kind;
+    base: DataType.Name | ComplexType | MixinType | MappedType;
     omit?: Field.Name[];
     pick?: Field.Name[];
     partial?: Field.Name[] | boolean;
+    required?: Field.Name[] | boolean;
 }
 export declare namespace MappedType {
     const Kind = "MappedType";

package/types/schema/data-type/mixin-type.interface.d.ts

@@ -1,8 +1,8 @@
 import { StrictOmit } from 'ts-gems';
 import type { ComplexType } from './complex-type.interface.js';
-import type { DataType } from './data-type.interface.js';
+import type { DataType, DataTypeBase } from './data-type.interface.js';
 import type { MappedType } from './mapped-type.interface.js';
-export interface MixinType extends StrictOmit<ComplexType, 'kind'> {
+export interface MixinType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: MixinType.Kind;
     types: (DataType.Name | ComplexType | MixinType | MappedType)[];
 }

package/types/schema/data-type/simple-type.interface.d.ts

@@ -1,14 +1,42 @@
-import { StrictOmit } from 'ts-gems';
-import { Validator } from 'valgen';
-import type { DataTypeBase } from './data-type.interface.js';
-import { DataType } from './data-type.interface.js';
+import type { StrictOmit } from 'ts-gems';
+import type { DataType, DataTypeBase } from './data-type.interface.js';
+/**
+ *
+ * @interface SimpleType
+ */
 export interface SimpleType extends StrictOmit<DataTypeBase, 'kind'> {
     kind: SimpleType.Kind;
-    base?: DataType.Name | SimpleType;
-    decoder?: Validator;
-    encoder?: Validator;
+    base?: DataType.Name;
+    attributes?: Record<string, Attribute>;
+    properties?: Record<string, any>;
 }
 export declare namespace SimpleType {
     const Kind = "SimpleType";
     type Kind = 'SimpleType';
 }
+/**
+ *
+ * @interface Attribute
+ */
+export interface Attribute {
+    /**
+     * Data format of the attribute
+     */
+    format?: string;
+    /**
+     * Defines the description of the attribute
+     */
+    description?: string;
+    /**
+     * Defines the description of the attribute
+     */
+    default?: any;
+    /**
+     * Indicates if the attribute is sealed or not. A sealed attribute cannot be extended/modified through inheritance.
+     */
+    sealed?: boolean;
+    /**
+     * Indicates if the attribute is deprecated and can be removed in the next
+     */
+    deprecated?: boolean | string;
+}

package/types/schema/data-type-container.interface.d.ts

@@ -0,0 +1,7 @@
+import type { DataType } from './data-type/data-type.interface';
+/**
+ * @interface DataTypeContainer
+ */
+export interface DataTypeContainer {
+    types?: Record<DataType.Name, DataType>;
+}

package/types/schema/document.interface.d.ts

@@ -0,0 +1,55 @@
+import type { SpecVersion } from './constants.js';
+import type { DataTypeContainer } from './data-type-container.interface.js';
+import type { HttpController } from './http/http-controller.interface';
+export type Protocol = 'http' | 'ws' | 'rpc';
+/**
+ * @interface Document
+ */
+export interface Document extends DataTypeContainer {
+    spec: SpecVersion;
+    url?: string;
+    info?: DocumentInfo;
+    references?: Record<string, string | Document>;
+    api?: HttpApi;
+}
+/**
+ * @interface DocumentInfo
+ */
+export interface DocumentInfo {
+    title?: string;
+    version?: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactPerson[];
+    license?: LicenseInfo;
+}
+/**
+ * @interface ContactPerson
+ */
+export interface ContactPerson {
+    name?: string;
+    email?: string;
+    url?: string;
+}
+/**
+ * @interface LicenseInfo
+ */
+export interface LicenseInfo {
+    name: string;
+    url?: string;
+    content?: string;
+}
+export interface Api extends DataTypeContainer {
+    protocol: Protocol;
+    /**
+     * Name of the api. Should be a computer friendly name
+     */
+    name: string;
+    description?: string;
+}
+export interface HttpApi extends Api {
+    protocol: 'http';
+    description?: string;
+    url?: string;
+    controllers: Record<string, HttpController>;
+}

package/types/schema/http/http-controller.interface.d.ts

@@ -0,0 +1,24 @@
+import type { DataTypeContainer } from '../data-type-container.interface.js';
+import type { HttpOperation } from './http-operation.interface';
+import type { HttpParameter } from './http-parameter.interface';
+/**
+ *
+ * @interface HttpController
+ */
+export interface HttpController extends DataTypeContainer {
+    kind: HttpController.Kind;
+    description?: string;
+    path?: string;
+    operations?: Record<string, HttpOperation>;
+    controllers?: Record<string, HttpController>;
+    parameters?: HttpParameter[];
+}
+/**
+ *
+ * @namespace HttpController
+ */
+export declare namespace HttpController {
+    type Name = string;
+    const Kind = "HttpController";
+    type Kind = 'HttpController';
+}

package/types/schema/http/http-media-type.interface.d.ts

@@ -0,0 +1,65 @@
+import type { DataType } from '../data-type/data-type.interface';
+import type { HttpMultipartField } from './http-multipart-field.interface.js';
+/**
+ *
+ * @interface HttpMediaType
+ */
+export interface HttpMediaType {
+    /**
+     * A brief description.
+     * [CommonMark](https://commonmark.org/) syntax MAY be used for rich text representation
+     */
+    description?: string;
+    /**
+     * Media type (MIME) or [range of media types](https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2)
+     */
+    contentType?: string | string[];
+    /**
+     * Determines encoding of the content.
+     */
+    contentEncoding?: string;
+    /**
+     * DataType to be used for decoding.
+     */
+    type?: DataType.Name | DataType;
+    /**
+     * Determines if content is array
+     */
+    isArray?: boolean;
+    /**
+     * Example of the content data. The `example` field is mutually exclusive of the `examples` field.
+     */
+    example?: string;
+    /**
+     * Examples of the content data. The `examples` field is mutually exclusive of the `example` field.
+     */
+    examples?: Record<string, string>;
+    /**
+     * Content info for each field for multipart contents
+     */
+    multipartFields?: HttpMultipartField[];
+    /**
+     * Determines maximum number of multipart fields
+     */
+    maxFields?: number;
+    /**
+     * Determines maximum size of each multipart field
+     */
+    maxFieldsSize?: number;
+    /**
+     * Determines maximum number of multipart files
+     */
+    maxFiles?: number;
+    /**
+     * Determines maximum size of each multipart file
+     */
+    maxFileSize?: number;
+    /**
+     * Determines maximum size of all multipart files
+     */
+    maxTotalFileSize?: number;
+    /**
+     * Determines minimum size of each multipart file
+     */
+    minFileSize?: number;
+}

package/types/schema/http/http-multipart-field.interface.d.ts

@@ -0,0 +1,7 @@
+import type { HttpMultipartFieldType } from '../types.js';
+import type { HttpMediaType } from './http-media-type.interface.js';
+export interface HttpMultipartField extends HttpMediaType {
+    fieldName: string | RegExp;
+    fieldType: HttpMultipartFieldType;
+    required?: boolean;
+}

package/types/schema/http/http-operation-response.interface.d.ts

@@ -0,0 +1,24 @@
+import type { HttpMediaType } from './http-media-type.interface.js';
+import type { HttpParameter } from './http-parameter.interface';
+import type { HttpStatusRange } from './http-status-range.interface';
+/**
+ *
+ * @interface HttpOperationResponse
+ */
+export interface HttpOperationResponse extends HttpMediaType {
+    /**
+     * Http status code or code range.
+     * @example 200
+     * @example [401,402,403]
+     * @example {start: 400, end: 403}
+     */
+    statusCode: number | HttpStatusRange | (number | HttpStatusRange)[];
+    /**
+     * Returned parameters for this response. etc. headers or cookies
+     */
+    parameters?: HttpParameter[];
+    /**
+     * Determines if the response object is partial
+     */
+    partial?: boolean | 'deep';
+}

package/types/schema/http/http-operation.interface.d.ts

@@ -0,0 +1,23 @@
+import type { DataTypeContainer } from '../data-type-container.interface';
+import type { HttpMethod } from '../types.js';
+import type { HttpOperationResponse } from './http-operation-response.interface';
+import type { HttpParameter } from './http-parameter.interface';
+import type { HttpRequestBody } from './http-request-body.interface';
+/**
+ * @interface HttpOperation
+ */
+export interface HttpOperation extends DataTypeContainer {
+    kind: HttpOperation.Kind;
+    method: HttpMethod;
+    description?: string;
+    path?: string;
+    parameters?: HttpParameter[];
+    responses?: HttpOperationResponse[];
+    requestBody?: HttpRequestBody;
+    composition?: string;
+    compositionOptions?: Record<string, any>;
+}
+export declare namespace HttpOperation {
+    const Kind = "HttpOperation";
+    type Kind = 'HttpOperation';
+}

package/types/schema/http/http-parameter.interface.d.ts

@@ -0,0 +1,28 @@
+import { HttpParameterLocation } from '../types.js';
+import type { Value } from '../value.interface';
+/**
+ *
+ * @interface HttpParameter
+ */
+export interface HttpParameter extends Value {
+    /**
+     * Defines the location of the parameter
+     */
+    location: HttpParameterLocation;
+    /**
+     * Name of the parameter. RegExp pattern can be used matching parameter name
+     */
+    name: string | RegExp;
+    /**
+     * Defines array separator
+     */
+    arraySeparator?: string;
+    /**
+     * Indicates if parameter value required
+     */
+    required?: boolean;
+    /**
+     * Indicates if the parameter is deprecated and can be removed in the next
+     */
+    deprecated?: boolean | string;
+}

package/types/schema/http/http-request-body.interface.d.ts

@@ -0,0 +1,29 @@
+import type { HttpMediaType } from './http-media-type.interface.js';
+/**
+ *
+ * @interface HttpRequestBody
+ */
+export interface HttpRequestBody {
+    /**
+     * A brief description.
+     * [CommonMark](https://commonmark.org/) syntax MAY be used for rich text representation
+     */
+    description?: string;
+    /**
+     * Alternatives of media types
+     */
+    content: HttpMediaType[];
+    /**
+     * Determines if the request body is required.
+     * Default `true` for POST and PATCH operations, `false` for other methods
+     */
+    required?: boolean;
+    /**
+     * Maximum accepted content size in bytes.
+     */
+    maxContentSize?: number;
+    /**
+     * Determines if the request body object is partial
+     */
+    partial?: boolean | 'deep';
+}

package/types/schema/http/http-status-range.interface.d.ts

@@ -0,0 +1,4 @@
+export interface HttpStatusRange {
+    start: number;
+    end: number;
+}

package/types/schema/index.d.ts

@@ -1,2 +1,61 @@
-import * as OpraSchema from './opra-schema.ns.js';
-export { OpraSchema };
+import * as constants_ from './constants.js';
+import * as complexType_ from './data-type/complex-type.interface.js';
+import * as dataType_ from './data-type/data-type.interface.js';
+import * as enumType_ from './data-type/enum-type.interface.js';
+import * as field_ from './data-type/field.interface.js';
+import * as mappedType_ from './data-type/mapped-type.interface.js';
+import * as mixinType_ from './data-type/mixin-type.interface.js';
+import * as simpleType_ from './data-type/simple-type.interface.js';
+import * as dataTypeContainer_ from './data-type-container.interface.js';
+import * as apiDocument_ from './document.interface.js';
+import * as controller_ from './http/http-controller.interface.js';
+import * as mediaType_ from './http/http-media-type.interface.js';
+import * as multipartField_ from './http/http-multipart-field.interface.js';
+import * as operation_ from './http/http-operation.interface.js';
+import * as response_ from './http/http-operation-response.interface.js';
+import * as parameter_ from './http/http-parameter.interface.js';
+import * as requestBody_ from './http/http-request-body.interface.js';
+import * as httpStatusRange_ from './http/http-status-range.interface.js';
+import * as typeGuards_ from './type-guards.js';
+import * as types_ from './types.js';
+import * as value_ from './value.interface.js';
+export declare namespace OpraSchema {
+    export import SpecVersion = constants_.SpecVersion;
+    export import Protocol = apiDocument_.Protocol;
+    export import ApiDocument = apiDocument_.Document;
+    export import DocumentInfo = apiDocument_.DocumentInfo;
+    export import ContactPerson = apiDocument_.ContactPerson;
+    export import LicenseInfo = apiDocument_.LicenseInfo;
+    export import HttpApi = apiDocument_.HttpApi;
+    export import Api = apiDocument_.Api;
+    export import HttpMethod = types_.HttpMethod;
+    export import HttpParameterLocation = types_.HttpParameterLocation;
+    export import HttpMultipartFieldType = types_.HttpMultipartFieldType;
+    export import Value = value_.Value;
+    export import ComplexType = complexType_.ComplexType;
+    export import DataType = dataType_.DataType;
+    export import DataTypeBase = dataType_.DataTypeBase;
+    export import DataTypeExample = dataType_.DataTypeExample;
+    export import EnumType = enumType_.EnumType;
+    export import Field = field_.Field;
+    export import MappedType = mappedType_.MappedType;
+    export import MixinType = mixinType_.MixinType;
+    export import SimpleType = simpleType_.SimpleType;
+    export import Attribute = simpleType_.Attribute;
+    export import DataTypeContainer = dataTypeContainer_.DataTypeContainer;
+    export import HttpController = controller_.HttpController;
+    export import HttpMediaType = mediaType_.HttpMediaType;
+    export import HttpMultipartField = multipartField_.HttpMultipartField;
+    export import HttpOperation = operation_.HttpOperation;
+    export import HttpParameter = parameter_.HttpParameter;
+    export import HttpRequestBody = requestBody_.HttpRequestBody;
+    export import HttpStatusRange = httpStatusRange_.HttpStatusRange;
+    export import HttpOperationResponse = response_.HttpOperationResponse;
+    export import isComplexType = typeGuards_.isComplexType;
+    export import isDataType = typeGuards_.isDataType;
+    export import isSimpleType = typeGuards_.isSimpleType;
+    export import isMixinType = typeGuards_.isMixinType;
+    export import isMappedType = typeGuards_.isMappedType;
+    export import isEnumType = typeGuards_.isEnumType;
+    export import isHttpController = typeGuards_.isHttpController;
+}

package/types/schema/type-guards.d.ts

@@ -4,19 +4,11 @@ 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 { Collection } from './resource/collection.interface.js';
-import { Container } from './resource/container.interface.js';
-import { Resource } from './resource/resource.interface.js';
-import { Singleton } from './resource/singleton.interface.js';
-import { Storage } from './resource/storage.interface.js';
+import { HttpController } from './http/http-controller.interface.js';
 export declare function isDataType(obj: any): obj is DataType;
 export declare function isComplexType(obj: any): obj is ComplexType;
 export declare function isSimpleType(obj: any): obj is SimpleType;
 export declare function isMixinType(obj: any): obj is MixinType;
 export declare function isMappedType(obj: any): obj is MappedType;
 export declare function isEnumType(obj: any): obj is EnumType;
-export declare function isResource(obj: any): obj is Resource;
-export declare function isCollection(obj: any): obj is Collection;
-export declare function isSingleton(obj: any): obj is Singleton;
-export declare function isStorage(obj: any): obj is Storage;
-export declare function isContainer(obj: any): obj is Container;
+export declare function isHttpController(obj: any): obj is HttpController;

package/types/schema/types.d.ts

@@ -0,0 +1,3 @@
+export type HttpMethod = 'DELETE' | 'GET' | 'HEAD' | 'OPTIONS' | 'POST' | 'PUT' | 'PATCH' | 'SEARCH';
+export type HttpParameterLocation = 'cookie' | 'header' | 'query' | 'path';
+export type HttpMultipartFieldType = 'field' | 'file';

package/types/schema/value.interface.d.ts

@@ -0,0 +1,23 @@
+import type { DataType } from './data-type/data-type.interface.js';
+/**
+ *
+ * @interface Value
+ */
+export interface Value {
+    /**
+     * Data type of the value
+     */
+    type?: DataType.Name | DataType;
+    /**
+     * Indicates if the value is an array
+     */
+    isArray?: boolean;
+    /**
+     * Defines the description of the parameter
+     */
+    description?: string;
+    /**
+     * Defines example values for the parameter
+     */
+    examples?: any[] | Record<string, any>;
+}

package/types/types.d.ts

@@ -1,14 +1 @@
-import type { DeeperNullish, DeeperPartial, IfNever, IfNoDeepValue, Type } from 'ts-gems';
-export type Thunk<T> = T | (() => T);
-export type ThunkAsync<T> = Thunk<T> | Thunk<Promise<T>>;
-export type TypeThunk<T = any> = Thunk<Type<T>>;
-export type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
-/**
- * Returns given type as a Data Transfer Object (DTO) interface, Removes symbol keys and function properties.
- * @template T - The type of the data being transferred.
- */
-export type DTO<T> = {
-    [K in keyof T as (IfNever<Exclude<T[K], undefined | Function>, never, K>)]: Exclude<T[K], undefined | null> extends (infer U)[] ? DTO<U>[] : IfNoDeepValue<Exclude<T[K], undefined | null>> extends true ? Exclude<T[K], undefined | null> : DTO<Exclude<T[K], undefined | null>>;
-};
-export type PartialDTO<T> = DeeperPartial<DTO<T>>;
-export type PatchDTO<T> = DeeperNullish<DTO<T>>;
+export type URLSearchParamsInit = string[][] | Record<string, string> | string | URLSearchParams;

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnyType = void 0;
-const tslib_1 = require("tslib");
-const simple_type_js_1 = require("../simple-type.js");
-let AnyType = class AnyType {
-};
-exports.AnyType = AnyType;
-exports.AnyType = AnyType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
-        description: 'Represents any value'
-    })
-], AnyType);

package/cjs/document/data-type/builtin/approx-date.type.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApproxDateType = void 0;
-const tslib_1 = require("tslib");
-const valgen_1 = require("valgen");
-const simple_type_js_1 = require("../simple-type.js");
-let ApproxDateType = class ApproxDateType {
-};
-exports.ApproxDateType = ApproxDateType;
-exports.ApproxDateType = ApproxDateType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
-        description: 'An approximate date value',
-        example: [
-            '2021-04-18',
-            '2021-04',
-            '2021',
-        ],
-        decoder: valgen_1.vg.isDateString({ trim: 'date' }),
-        encoder: valgen_1.vg.isDateString({ trim: 'date' })
-    })
-], ApproxDateType);

package/cjs/document/data-type/builtin/approx-datetime.type.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApproxDatetimeType = void 0;
-const tslib_1 = require("tslib");
-const valgen_1 = require("valgen");
-const simple_type_js_1 = require("../simple-type.js");
-let ApproxDatetimeType = class ApproxDatetimeType {
-};
-exports.ApproxDatetimeType = ApproxDatetimeType;
-exports.ApproxDatetimeType = ApproxDatetimeType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
-        description: 'An approximate datetime value.',
-        example: [
-            '2021-04-18T22:30:15+01:00',
-            '2021-04-18T22:30:15',
-            '2021-04-18 22:30',
-            '2021-04-18',
-            '2021-04',
-            '2021',
-        ],
-        decoder: valgen_1.isDateString,
-        encoder: valgen_1.isDateString
-    })
-], ApproxDatetimeType);

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BigintType = void 0;
-const tslib_1 = require("tslib");
-const valgen_1 = require("valgen");
-const simple_type_js_1 = require("../simple-type.js");
-let BigintType = class BigintType {
-};
-exports.BigintType = BigintType;
-exports.BigintType = BigintType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
-        description: 'BigInt number',
-        decoder: valgen_1.isBigint,
-        encoder: valgen_1.vg.pipe(valgen_1.isBigint, valgen_1.isString)
-    })
-], BigintType);

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DateType = void 0;
-const tslib_1 = require("tslib");
-const valgen_1 = require("valgen");
-const simple_type_js_1 = require("../simple-type.js");
-let DateType = class DateType {
-};
-exports.DateType = DateType;
-exports.DateType = DateType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
-        description: 'A date without time',
-        example: ['2021-04-18'],
-        decoder: valgen_1.vg.isDate({ precision: 'date' }),
-        encoder: valgen_1.vg.isDateString({ precision: 'date', trim: 'date' })
-    })
-], DateType);

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

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatetimeType = void 0;
-const tslib_1 = require("tslib");
-const valgen_1 = require("valgen");
-const simple_type_js_1 = require("../simple-type.js");
-let DatetimeType = class DatetimeType {
-};
-exports.DatetimeType = DatetimeType;
-exports.DatetimeType = DatetimeType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
-        description: 'A full datetime value',
-        example: [
-            '2021-04-18T22:30:15',
-            '2021-04-18 22:30:15',
-            '2021-04-18 22:30'
-        ],
-        decoder: valgen_1.vg.isDate({ precision: 'time' }),
-        encoder: valgen_1.vg.isDateString({ precision: 'time', trim: 'time' })
-    })
-], DatetimeType);

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

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmailType = void 0;
-const tslib_1 = require("tslib");
-const valgen_1 = require("valgen");
-const simple_type_js_1 = require("../simple-type.js");
-let EmailType = class EmailType {
-};
-exports.EmailType = EmailType;
-exports.EmailType = EmailType = tslib_1.__decorate([
-    (0, simple_type_js_1.SimpleType)({
-        description: 'An email value',
-        decoder: valgen_1.vg.isEmail(),
-        encoder: valgen_1.vg.isEmail()
-    })
-], EmailType);