@archi-code/domain 1.0.0-alpha.1

package/dist/esm/validator/decorator/json-fotmat-validate.js

@@ -0,0 +1,5 @@
+import { isEmail } from 'class-validator';
+export const JSON_FORMAT_VALIDATES = {
+    email: { type: 'string', validate: isEmail },
+};
+//# sourceMappingURL=json-fotmat-validate.js.map

package/dist/esm/validator/decorator/json-fotmat-validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-fotmat-validate.js","sourceRoot":"","sources":["../../../../src/validator/decorator/json-fotmat-validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE;CAC7C,CAAC"}

package/dist/esm/validator/decorator/type-validator.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { ValidatorMapI } from './validators-map';
+import { ValidationError } from 'class-validator';
+import { ValidatorOptions } from 'class-validator/types/validation/ValidatorOptions';
+export declare function AddValidate(validatorConfigs: ValidatorMapI[], propertyKey?: string): (cls: Function) => void;
+export declare function validateType(object: object, validatorOptions?: ValidatorOptions): ValidationError[];

package/dist/esm/validator/decorator/type-validator.js

@@ -0,0 +1,77 @@
+import 'reflect-metadata';
+import { ValidationStorage } from './validation-storage';
+import { validatorsMap } from './validators-map';
+import { validateSync } from 'class-validator';
+import { ValidatorsDoc } from './validators-doc';
+function registerDecorator(cls, validatorConfigs, propertyKey) {
+    validatorConfigs.forEach((config) => {
+        let validator;
+        if (typeof config.validator === 'string' && validatorsMap[config.validator]) {
+            validator = validatorsMap[config.validator];
+            if (!validator) {
+                throw new Error(`Validator ${config.validator} is not supported.`);
+            }
+        }
+        else {
+            validator = config.validator;
+        }
+        if (config.value) {
+            validator(config.value, config.options)(cls.prototype, propertyKey);
+        }
+        else {
+            validator(config.options)(cls.prototype, propertyKey);
+        }
+    });
+    ValidationStorage.getInstance().addValidations(cls, propertyKey, validatorConfigs);
+}
+function applyParentValidations(cls, propertyKey) {
+    const parentPrototype = Object.getPrototypeOf(cls.prototype);
+    if (parentPrototype && parentPrototype !== Object.prototype) {
+        const parentValidatorConfigs = ValidationStorage.getInstance().getValidations(parentPrototype.constructor, propertyKey);
+        if (parentValidatorConfigs.length > 0) {
+            registerDecorator(cls, parentValidatorConfigs, propertyKey);
+        }
+    }
+}
+export function AddValidate(validatorConfigs, propertyKey = '_value') {
+    return function (cls) {
+        applyParentValidations(cls, propertyKey);
+        registerDecorator(cls, validatorConfigs, propertyKey);
+        const validatorList = ValidationStorage.getInstance().getValidations(cls, propertyKey);
+        const documentation = ValidatorsDoc.instance.generatePropertySchema(validatorList);
+        Reflect.defineMetadata('type:doc', documentation, cls);
+    };
+}
+function replacePropertyWithClassName(errors) {
+    errors.forEach((error) => {
+        if (error.target) {
+            const className = error.target.constructor.name;
+            const property = error.property;
+            if (error.constraints) {
+                Object.keys(error.constraints).forEach((key) => {
+                    error.constraints[key] = error.constraints[key].replace(new RegExp(property, 'g'), className);
+                });
+            }
+        }
+    });
+    return errors;
+}
+function getClassHierarchy(klass) {
+    const hierarchy = [];
+    let currentClass = klass;
+    while (currentClass && currentClass !== Function.prototype) {
+        hierarchy.push(currentClass);
+        currentClass = Object.getPrototypeOf(currentClass);
+    }
+    return hierarchy;
+}
+export function validateType(object, validatorOptions) {
+    const errors = validateSync(object, validatorOptions);
+    if (errors.length === 0) {
+        return errors;
+    }
+    const classHierarchy = getClassHierarchy(object.constructor);
+    const isType = classHierarchy.some((klass) => ValidationStorage.getInstance().hasClassRegister(klass));
+    return isType ? replacePropertyWithClassName(errors) : errors;
+}
+//# sourceMappingURL=type-validator.js.map

package/dist/esm/validator/decorator/type-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-validator.js","sourceRoot":"","sources":["../../../../src/validator/decorator/type-validator.ts"],"names":[],"mappings":"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"}

package/dist/esm/validator/decorator/validation-storage.d.ts

@@ -0,0 +1,14 @@
+import { ValidatorMapI } from './validators-map';
+export declare class ValidationStorage {
+    private static instance;
+    private _validationMap;
+    private _classMap;
+    private constructor();
+    static getInstance(): ValidationStorage;
+    static reset(): void;
+    hasClassRegister(cls: any): boolean;
+    private getClassKey;
+    addValidations(cls: Function, propertyKey: string, validationConfigs: ValidatorMapI[]): void;
+    getValidations(cls: Function, propertyKey: string): ValidatorMapI[];
+    log(): any[];
+}

package/dist/esm/validator/decorator/validation-storage.js

@@ -0,0 +1,52 @@
+export class ValidationStorage {
+    constructor() {
+        this._validationMap = new Map();
+        this._classMap = new WeakMap();
+    }
+    static getInstance() {
+        if (!ValidationStorage.instance) {
+            ValidationStorage.instance = new ValidationStorage();
+        }
+        return ValidationStorage.instance;
+    }
+    static reset() {
+        ValidationStorage.instance = new ValidationStorage();
+    }
+    hasClassRegister(cls) {
+        return this._classMap.has(cls);
+    }
+    getClassKey(cls) {
+        if (!this._classMap.has(cls)) {
+            this._classMap.set(cls, Symbol());
+        }
+        return this._classMap.get(cls);
+    }
+    addValidations(cls, propertyKey, validationConfigs) {
+        const clsKey = this.getClassKey(cls);
+        if (!this._validationMap.has(clsKey)) {
+            this._validationMap.set(clsKey, new Map());
+        }
+        const propertyValidations = this._validationMap.get(clsKey);
+        if (!propertyValidations?.has(propertyKey)) {
+            propertyValidations?.set(propertyKey, []);
+        }
+        const existingValidations = propertyValidations?.get(propertyKey) || [];
+        propertyValidations?.set(propertyKey, existingValidations.concat(validationConfigs));
+    }
+    getValidations(cls, propertyKey) {
+        const clsKey = this.getClassKey(cls);
+        return this._validationMap.get(clsKey)?.get(propertyKey) || [];
+    }
+    log() {
+        const result = [];
+        this._validationMap.forEach((propertiesMap) => {
+            propertiesMap.forEach((validations, propertyKey) => {
+                const objList = {};
+                objList[propertyKey] = validations;
+                result.push(objList);
+            });
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=validation-storage.js.map

package/dist/esm/validator/decorator/validation-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-storage.js","sourceRoot":"","sources":["../../../../src/validator/decorator/validation-storage.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,iBAAiB;IAK5B;QACE,IAAI,CAAC,cAAc,GAAG,IAAI,GAAG,EAAE,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,IAAI,OAAO,EAAE,CAAC;IACjC,CAAC;IAED,MAAM,CAAC,WAAW;QAChB,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC;YAChC,iBAAiB,CAAC,QAAQ,GAAG,IAAI,iBAAiB,EAAE,CAAC;QACvD,CAAC;QACD,OAAO,iBAAiB,CAAC,QAAQ,CAAC;IACpC,CAAC;IAED,MAAM,CAAC,KAAK;QACV,iBAAiB,CAAC,QAAQ,GAAG,IAAI,iBAAiB,EAAE,CAAC;IACvD,CAAC;IAEM,gBAAgB,CAAC,GAAQ;QAC9B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAEO,WAAW,CAAC,GAAa;QAC/B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;IAClC,CAAC;IAED,cAAc,CAAC,GAAa,EAAE,WAAmB,EAAE,iBAAkC;QACnF,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YACrC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QAC7C,CAAC;QACD,MAAM,mBAAmB,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC5D,IAAI,CAAC,mBAAmB,EAAE,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;YAC3C,mBAAmB,EAAE,GAAG,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QAC5C,CAAC;QACD,MAAM,mBAAmB,GAAG,mBAAmB,EAAE,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QACxE,mBAAmB,EAAE,GAAG,CAAC,WAAW,EAAE,mBAAmB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACvF,CAAC;IAED,cAAc,CAAC,GAAa,EAAE,WAAmB;QAC/C,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;IACjE,CAAC;IAED,GAAG;QACD,MAAM,MAAM,GAAQ,EAAE,CAAC;QAEvB,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,EAAE;YAC5C,aAAa,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,WAAW,EAAE,EAAE;gBACjD,MAAM,OAAO,GAAG,EAAE,CAAC;gBACnB,OAAO,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC;gBACnC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACvB,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;CACF"}

package/dist/esm/validator/decorator/validators-doc.d.ts

@@ -0,0 +1,25 @@
+import { ValidatorMapI } from './validators-map';
+import { ValidationMetadata } from 'class-validator/types/metadata/ValidationMetadata';
+export declare class ValidatorsDoc {
+    #private;
+    private constructor();
+    static get instance(): ValidatorsDoc;
+    private static readonly customMappings;
+    private static readonly numericMappings;
+    private static readonly stringMappings;
+    private static readonly dateMappings;
+    private static readonly arrayMappings;
+    private static readonly extendedMappings;
+    private static readonly genericStringMappings;
+    private static readonly allMappings;
+    generateDoc(validators: ValidationMetadata[]): {
+        schema: any;
+        required: boolean;
+    };
+    generatePropertySchema(validators: ValidatorMapI[]): {
+        schema: any;
+        required: boolean;
+    };
+    private mergeSchema;
+    private mapValidator;
+}

package/dist/esm/validator/decorator/validators-doc.js

@@ -0,0 +1,475 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _a, _ValidatorsDoc_instance;
+import { ValidationTypes } from 'class-validator';
+export class ValidatorsDoc {
+    constructor() { }
+    static get instance() {
+        if (!__classPrivateFieldGet(_a, _a, "f", _ValidatorsDoc_instance)) {
+            __classPrivateFieldSet(_a, _a, new _a(), "f", _ValidatorsDoc_instance);
+        }
+        return __classPrivateFieldGet(_a, _a, "f", _ValidatorsDoc_instance);
+    }
+    generateDoc(validators) {
+        const validatorsMap = validators.map((v) => {
+            let validator;
+            let value;
+            if (v.type === ValidationTypes.CONDITIONAL_VALIDATION) {
+                validator = 'IsOptional';
+            }
+            else {
+                validator =
+                    typeof v.name === 'string' ? v.name.charAt(0).toUpperCase() + v.name.slice(1) : v.name;
+                value = v.constraints?.length > 0 ? v.constraints[0] : undefined;
+            }
+            return {
+                validator,
+                value,
+            };
+        });
+        return this.generatePropertySchema(validatorsMap);
+    }
+    generatePropertySchema(validators) {
+        let schema = {};
+        let requiredValue = true;
+        for (let i = 0, len = validators.length; i < len; i++) {
+            const { schema: partSchema, required: isReq } = this.mapValidator(validators[i]);
+            if (!isReq) {
+                requiredValue = false;
+            }
+            schema = this.mergeSchema(schema, partSchema);
+        }
+        if (!schema.type) {
+            schema.type = 'string';
+        }
+        return { schema, required: requiredValue };
+    }
+    mergeSchema(base, addition) {
+        const merged = { ...base, ...addition };
+        if (addition.type) {
+            if (base.type &&
+                base.type !== addition.type &&
+                !((base.type === 'integer' && addition.type === 'number') ||
+                    (base.type === 'number' && addition.type === 'integer'))) {
+                console.warn(`Warning: Type changed from "${base.type}" to "${addition.type}" due to conflicting validators.`);
+            }
+            merged.type = addition.type;
+        }
+        return merged;
+    }
+    mapValidator(vData) {
+        const schema = {};
+        let required = true;
+        let validatorName;
+        if (typeof vData.validator === 'string') {
+            validatorName = vData.validator;
+        }
+        else if (typeof vData.validator === 'function') {
+            validatorName = vData.validator.name;
+        }
+        else {
+            return { schema, required };
+        }
+        if (validatorName === 'IsOptional') {
+            required = false;
+        }
+        else {
+            const mapper = _a.allMappings[validatorName];
+            if (mapper) {
+                mapper(schema, vData.value);
+            }
+            else {
+                schema['x-validate-' + validatorName] = vData.value;
+            }
+        }
+        return { schema, required };
+    }
+}
+_a = ValidatorsDoc;
+_ValidatorsDoc_instance = { value: void 0 };
+ValidatorsDoc.customMappings = {
+    CanBeBooleanValidator: (schema) => {
+        schema.type = 'boolean';
+    },
+    CanBeDate: (schema) => {
+        schema.type = 'string';
+        schema.format = 'date-time';
+    },
+    CanBeJson: (schema) => {
+        schema.type = 'object';
+    },
+    CanBeNumberValidator: (schema) => {
+        schema.type = 'number';
+    },
+    CanBeStringValidator: (schema) => {
+        schema.type = 'string';
+    },
+    JsonSchemaValidator: (schema, value) => {
+        schema.type = 'object';
+        schema.properties = value?.properties ? value.properties : {};
+    },
+};
+ValidatorsDoc.numericMappings = {
+    Min: (schema, value) => {
+        schema.type = 'number';
+        schema.minimum = value;
+    },
+    Max: (schema, value) => {
+        schema.type = 'number';
+        schema.maximum = value;
+    },
+    IsPositive: (schema) => {
+        schema.type = 'number';
+        schema.minimum = 1;
+    },
+    IsNegative: (schema) => {
+        schema.type = 'number';
+        schema.maximum = -1;
+    },
+    IsDivisibleBy: (schema, value) => {
+        schema.type = 'number';
+        schema.multipleOf = value;
+    },
+    IsDecimal: (schema) => {
+        schema.type = 'number';
+    },
+    IsNumber: (schema) => {
+        schema.type = 'number';
+    },
+    IsInt: (schema) => {
+        schema.type = 'integer';
+    },
+    IsLatitude: (schema) => {
+        schema.type = 'number';
+    },
+    IsLongitude: (schema) => {
+        schema.type = 'number';
+    },
+};
+ValidatorsDoc.stringMappings = {
+    MinLength: (schema, value) => {
+        schema.type = 'string';
+        schema.minLength = value;
+    },
+    MaxLength: (schema, value) => {
+        schema.type = 'string';
+        schema.maxLength = value;
+    },
+    Length: (schema, value) => {
+        schema.type = 'string';
+        if (Array.isArray(value) && value.length === 2) {
+            schema.minLength = value[0];
+            schema.maxLength = value[1];
+        }
+    },
+    Matches: (schema, value) => {
+        schema.type = 'string';
+        schema.pattern = value.toString();
+    },
+    Equals: (schema, value) => {
+        schema.type = 'string';
+        schema.const = value;
+    },
+    NotEquals: (schema, value) => {
+        schema.type = 'string';
+        schema['x-validate-NotEquals'] = value;
+    },
+    IsEmpty: (schema) => {
+        schema.type = 'string';
+        schema.maxLength = 0;
+    },
+    IsNotEmpty: (schema) => {
+        schema.type = 'string';
+        schema.minLength = 1;
+    },
+    IsIn: (schema, value) => {
+        schema.type = 'string';
+        schema.enum = value;
+    },
+    IsNotIn: (schema, value) => {
+        schema.type = 'string';
+        schema['x-validate-IsNotIn'] = value;
+    },
+    Contains: (schema, value) => {
+        schema.type = 'string';
+        schema['x-validate-Contains'] = value;
+    },
+    NotContains: (schema, value) => {
+        schema.type = 'string';
+        schema['x-validate-NotContains'] = value;
+    },
+    IsByteLength: (schema, value) => {
+        schema.type = 'string';
+        schema['x-validate-IsByteLength'] = value;
+    },
+};
+ValidatorsDoc.dateMappings = {
+    MinDate: (schema, value) => {
+        schema.type = 'string';
+        schema.format = 'date-time';
+        schema['x-minDate'] = value;
+    },
+    MaxDate: (schema, value) => {
+        schema.type = 'string';
+        schema.format = 'date-time';
+        schema['x-maxDate'] = value;
+    },
+    IsDate: (schema) => {
+        schema.type = 'string';
+        schema.format = 'date-time';
+    },
+    IsDateString: (schema) => {
+        schema.type = 'string';
+        schema.format = 'date-time';
+    },
+    IsNumberString: (schema) => {
+        schema.type = 'string';
+        schema.pattern = '^[0-9]+$';
+    },
+    IsISO8601: (schema) => {
+        schema.type = 'string';
+        schema.format = 'date-time';
+    },
+};
+ValidatorsDoc.arrayMappings = {
+    IsArray: (schema) => {
+        schema.type = 'array';
+        if (!schema.items) {
+            schema.items = { type: 'string' };
+        }
+    },
+    ArrayContains: (schema, value) => {
+        schema['x-validate-ArrayContains'] = value;
+    },
+    ArrayNotContains: (schema, value) => {
+        schema['x-validate-ArrayNotContains'] = value;
+    },
+    ArrayNotEmpty: (schema) => {
+        schema.type = 'array';
+        schema.minItems = 1;
+    },
+    ArrayMinSize: (schema, value) => {
+        schema.type = 'array';
+        schema.minItems = value;
+    },
+    ArrayMaxSize: (schema, value) => {
+        schema.type = 'array';
+        schema.maxItems = value;
+    },
+    ArrayUnique: (schema) => {
+        schema.type = 'array';
+        schema.uniqueItems = true;
+    },
+};
+ValidatorsDoc.extendedMappings = {
+    Allow: (schema, value) => {
+        schema['x-validate-Allow'] = value;
+    },
+    IsInstance: (schema, value) => {
+        schema['x-validate-IsInstance'] = value;
+    },
+    IsDefined: (schema) => {
+        schema['x-validate-IsDefined'] = true;
+    },
+    IsJSON: (schema) => {
+        schema['x-validate-IsJSON'] = true;
+    },
+    IsJWT: (schema) => {
+        schema['x-validate-IsJWT'] = true;
+    },
+    IsLatLong: (schema) => {
+        schema['x-validate-IsLatLong'] = true;
+    },
+    IsLocale: (schema) => {
+        schema['x-validate-IsLocale'] = true;
+    },
+    IsLowercase: (schema) => {
+        schema['x-validate-IsLowercase'] = true;
+    },
+    IsMACAddress: (schema) => {
+        schema['x-validate-IsMACAddress'] = true;
+    },
+    IsMilitaryTime: (schema) => {
+        schema['x-validate-IsMilitaryTime'] = true;
+    },
+    IsNotEmptyObject: (schema) => {
+        schema['x-validate-IsNotEmptyObject'] = true;
+    },
+    IsObject: (schema) => {
+        schema.type = 'object';
+    },
+    IsOctal: (schema) => {
+        schema['x-validate-IsOctal'] = true;
+    },
+    IsPhoneNumber: (schema, value) => {
+        schema['x-validate-IsPhoneNumber'] = value;
+    },
+    IsPort: (schema) => {
+        schema['x-validate-IsPort'] = true;
+    },
+    IsRgbColor: (schema) => {
+        schema['x-validate-IsRgbColor'] = true;
+    },
+    IsUppercase: (schema) => {
+        schema['x-validate-IsUppercase'] = true;
+    },
+    IsVariableWidth: (schema) => {
+        schema['x-validate-IsVariableWidth'] = true;
+    },
+    IsBoolean: (schema) => {
+        schema.type = 'boolean';
+    },
+};
+ValidatorsDoc.genericStringMappings = {
+    IsAlpha: (schema) => {
+        schema.type = 'string';
+    },
+    IsAlphanumeric: (schema) => {
+        schema.type = 'string';
+    },
+    IsAscii: (schema) => {
+        schema.type = 'string';
+    },
+    IsBase32: (schema) => {
+        schema.type = 'string';
+    },
+    IsBase58: (schema) => {
+        schema.type = 'string';
+    },
+    IsBase64: (schema) => {
+        schema.type = 'string';
+    },
+    IsBIC: (schema) => {
+        schema.type = 'string';
+    },
+    IsCreditCard: (schema) => {
+        schema.type = 'string';
+        schema.format = 'credit-card';
+    },
+    IsCurrency: (schema) => {
+        schema.type = 'string';
+    },
+    IsDataURI: (schema) => {
+        schema.type = 'string';
+    },
+    IsFQDN: (schema) => {
+        schema.type = 'string';
+    },
+    IsFullWidth: (schema) => {
+        schema.type = 'string';
+    },
+    IsHalfWidth: (schema) => {
+        schema.type = 'string';
+    },
+    IsHash: (schema) => {
+        schema.type = 'string';
+    },
+    IsHexadecimal: (schema) => {
+        schema.type = 'string';
+    },
+    IsHexColor: (schema) => {
+        schema.type = 'string';
+    },
+    IsHSL: (schema) => {
+        schema.type = 'string';
+    },
+    IsIBAN: (schema) => {
+        schema.type = 'string';
+    },
+    IsIdentityCard: (schema) => {
+        schema.type = 'string';
+    },
+    IsPassportNumber: (schema) => {
+        schema.type = 'string';
+    },
+    IsPostalCode: (schema) => {
+        schema.type = 'string';
+    },
+    IsMimeType: (schema) => {
+        schema.type = 'string';
+    },
+    IsMobilePhone: (schema) => {
+        schema.type = 'string';
+    },
+    IsMongoId: (schema) => {
+        schema.type = 'string';
+    },
+    IsMultibyte: (schema) => {
+        schema.type = 'string';
+    },
+    IsSurrogatePair: (schema) => {
+        schema.type = 'string';
+    },
+    IsTaxId: (schema) => {
+        schema.type = 'string';
+    },
+    IsUrl: (schema) => {
+        schema.type = 'string';
+        schema.format = 'uri';
+    },
+    IsMagnetURI: (schema) => {
+        schema.type = 'string';
+    },
+    IsUUID: (schema) => {
+        schema.type = 'string';
+        schema.format = 'uuid';
+    },
+    IsFirebasePushId: (schema) => {
+        schema.type = 'string';
+    },
+    IsTimeZone: (schema) => {
+        schema.type = 'string';
+    },
+    IsSemVer: (schema) => {
+        schema.type = 'string';
+    },
+    IsISSN: (schema) => {
+        schema.type = 'string';
+    },
+    IsISRC: (schema) => {
+        schema.type = 'string';
+    },
+    IsRFC3339: (schema) => {
+        schema.type = 'string';
+    },
+    IsStrongPassword: (schema) => {
+        schema.type = 'string';
+    },
+    IsEnum: (schema, value) => {
+        schema.enum = Object.values(value);
+        schema.type = 'string';
+    },
+    IsEmail: (schema) => {
+        schema.type = 'string';
+        schema.format = 'email';
+    },
+    IsBooleanString: (schema) => {
+        schema.type = 'string';
+        schema.pattern = '^(true|false)$';
+    },
+    IsString: (schema) => {
+        schema.type = 'string';
+    },
+    IsBtcAddress: (schema, value) => {
+        schema['x-validate-IsBtcAddress'] = value;
+    },
+};
+ValidatorsDoc.allMappings = {
+    ..._a.numericMappings,
+    ..._a.stringMappings,
+    ..._a.dateMappings,
+    ..._a.arrayMappings,
+    ..._a.extendedMappings,
+    ..._a.genericStringMappings,
+    ..._a.customMappings,
+};
+//# sourceMappingURL=validators-doc.js.map