@credo-ts/askar-to-drizzle-storage-migration 0.6.0-alpha-20251010154241 → 0.6.0-alpha-20251010171953

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/metadata/ValidationMetadata.js

@@ -0,0 +1,45 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/metadata/ValidationMetadata.js
+var require_ValidationMetadata = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/metadata/ValidationMetadata.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	* This metadata contains validation rules.
+	*/
+	var ValidationMetadata = class {
+		constructor(args) {
+			/**
+			* Validation groups used for this validation.
+			*/
+			this.groups = [];
+			/**
+			* Specifies if validated value is an array and each of its item must be validated.
+			*/
+			this.each = false;
+			this.context = void 0;
+			this.type = args.type;
+			this.name = args.name;
+			this.target = args.target;
+			this.propertyName = args.propertyName;
+			this.constraints = args === null || args === void 0 ? void 0 : args.constraints;
+			this.constraintCls = args.constraintCls;
+			this.validationTypeOptions = args.validationTypeOptions;
+			if (args.validationOptions) {
+				this.message = args.validationOptions.message;
+				this.groups = args.validationOptions.groups;
+				this.always = args.validationOptions.always;
+				this.each = args.validationOptions.each;
+				this.context = args.validationOptions.context;
+			}
+		}
+	};
+	exports.ValidationMetadata = ValidationMetadata;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ValidationMetadata();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/register-decorator.js

@@ -0,0 +1,57 @@
+const require_rolldown_runtime = require('../../../../../../_virtual/rolldown_runtime.js');
+const require_ValidationMetadata$1 = require('./metadata/ValidationMetadata.js');
+const require_MetadataStorage$1 = require('./metadata/MetadataStorage.js');
+const require_ValidationTypes$1 = require('./validation/ValidationTypes.js');
+const require_container$1 = require('./container.js');
+const require_ConstraintMetadata$1 = require('./metadata/ConstraintMetadata.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/register-decorator.js
+var require_register_decorator = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/register-decorator.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const ConstraintMetadata_1 = require_ConstraintMetadata$1.require_ConstraintMetadata();
+	const ValidationMetadata_1 = require_ValidationMetadata$1.require_ValidationMetadata();
+	const ValidationTypes_1 = require_ValidationTypes$1.require_ValidationTypes();
+	const container_1 = require_container$1.require_container();
+	const MetadataStorage_1 = require_MetadataStorage$1.require_MetadataStorage();
+	/**
+	* Registers a custom validation decorator.
+	*/
+	function registerDecorator(options) {
+		let constraintCls;
+		if (options.validator instanceof Function) {
+			constraintCls = options.validator;
+			if ((0, container_1.getFromContainer)(MetadataStorage_1.MetadataStorage).getTargetValidatorConstraints(options.validator).length > 1) throw `More than one implementation of ValidatorConstraintInterface found for validator on: ${options.target.name}:${options.propertyName}`;
+		} else {
+			const validator = options.validator;
+			constraintCls = class CustomConstraint {
+				validate(value, validationArguments) {
+					return validator.validate(value, validationArguments);
+				}
+				defaultMessage(validationArguments) {
+					if (validator.defaultMessage) return validator.defaultMessage(validationArguments);
+					return "";
+				}
+			};
+			(0, MetadataStorage_1.getMetadataStorage)().addConstraintMetadata(new ConstraintMetadata_1.ConstraintMetadata(constraintCls, options.name, options.async));
+		}
+		const validationMetadataArgs = {
+			type: options.name && ValidationTypes_1.ValidationTypes.isValid(options.name) ? options.name : ValidationTypes_1.ValidationTypes.CUSTOM_VALIDATION,
+			name: options.name,
+			target: options.target,
+			propertyName: options.propertyName,
+			validationOptions: options.options,
+			constraintCls,
+			constraints: options.constraints
+		};
+		(0, MetadataStorage_1.getMetadataStorage)().addValidationMetadata(new ValidationMetadata_1.ValidationMetadata(validationMetadataArgs));
+	}
+	exports.registerDecorator = registerDecorator;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_register_decorator();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/convert-to-array.util.js

@@ -0,0 +1,22 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/convert-to-array.util.js
+var require_convert_to_array_util = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/convert-to-array.util.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	* Convert Map, Set to Array
+	*/
+	function convertToArray(val) {
+		if (val instanceof Map) return Array.from(val.values());
+		return Array.isArray(val) ? val : Array.from(val);
+	}
+	exports.convertToArray = convertToArray;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_convert_to_array_util();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/get-global.util.js

@@ -0,0 +1,27 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/get-global.util.js
+var require_get_global_util = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/get-global.util.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	* This function returns the global object across Node and browsers.
+	*
+	* Note: `globalThis` is the standardized approach however it has been added to
+	* Node.js in version 12. We need to include this snippet until Node 12 EOL.
+	*/
+	function getGlobal() {
+		if (typeof globalThis !== "undefined") return globalThis;
+		if (typeof global !== "undefined") return global;
+		if (typeof window !== "undefined") return window;
+		if (typeof self !== "undefined") return self;
+	}
+	exports.getGlobal = getGlobal;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_get_global_util();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/index.js

@@ -0,0 +1,37 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+const require_convert_to_array_util$1 = require('./convert-to-array.util.js');
+const require_get_global_util$1 = require('./get-global.util.js');
+const require_is_promise_util$1 = require('./is-promise.util.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/index.js
+var require_utils = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/index.js": ((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(require_convert_to_array_util$1.require_convert_to_array_util(), exports);
+	__exportStar(require_get_global_util$1.require_get_global_util(), exports);
+	__exportStar(require_is_promise_util$1.require_is_promise_util(), exports);
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_utils();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/is-promise.util.js

@@ -0,0 +1,18 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/is-promise.util.js
+var require_is_promise_util = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/utils/is-promise.util.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function isPromise(p) {
+		return p !== null && typeof p === "object" && typeof p.then === "function";
+	}
+	exports.isPromise = isPromise;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_is_promise_util();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationArguments.js

@@ -0,0 +1,14 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationArguments.js
+var require_ValidationArguments = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationArguments.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ValidationArguments();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationError.js

@@ -0,0 +1,42 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationError.js
+var require_ValidationError = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationError.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	* Validation error description.
+	*/
+	var ValidationError = class {
+		/**
+		*
+		* @param shouldDecorate decorate the message with ANSI formatter escape codes for better readability
+		* @param hasParent true when the error is a child of an another one
+		* @param parentPath path as string to the parent of this property
+		* @param showConstraintMessages show constraint messages instead of constraint names
+		*/
+		toString(shouldDecorate = false, hasParent = false, parentPath = ``, showConstraintMessages = false) {
+			const boldStart = shouldDecorate ? `\x1b[1m` : ``;
+			const boldEnd = shouldDecorate ? `\x1b[22m` : ``;
+			const constraintsToString = () => {
+				var _a;
+				return (showConstraintMessages ? Object.values : Object.keys)((_a = this.constraints) !== null && _a !== void 0 ? _a : {}).join(`, `);
+			};
+			const propConstraintFailed = (propertyName) => ` - property ${boldStart}${parentPath}${propertyName}${boldEnd} has failed the following constraints: ${boldStart}${constraintsToString()}${boldEnd} \n`;
+			if (!hasParent) return `An instance of ${boldStart}${this.target ? this.target.constructor.name : "an object"}${boldEnd} has failed the validation:\n` + (this.constraints ? propConstraintFailed(this.property) : ``) + (this.children ? this.children.map((childError) => childError.toString(shouldDecorate, true, this.property, showConstraintMessages)).join(``) : ``);
+			else {
+				const formattedProperty = Number.isInteger(+this.property) ? `[${this.property}]` : `${parentPath ? `.` : ``}${this.property}`;
+				if (this.constraints) return propConstraintFailed(formattedProperty);
+				else return this.children ? this.children.map((childError) => childError.toString(shouldDecorate, true, `${parentPath}${formattedProperty}`, showConstraintMessages)).join(``) : ``;
+			}
+		}
+	};
+	exports.ValidationError = ValidationError;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ValidationError();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationExecutor.js

@@ -0,0 +1,228 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+const require_index = require('../utils/index.js');
+const require_MetadataStorage$1 = require('../metadata/MetadataStorage.js');
+const require_ValidationError$1 = require('./ValidationError.js');
+const require_ValidationTypes$1 = require('./ValidationTypes.js');
+const require_ValidationUtils$1 = require('./ValidationUtils.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationExecutor.js
+var require_ValidationExecutor = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationExecutor.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const ValidationError_1 = require_ValidationError$1.require_ValidationError();
+	const ValidationTypes_1 = require_ValidationTypes$1.require_ValidationTypes();
+	const ValidationUtils_1 = require_ValidationUtils$1.require_ValidationUtils();
+	const utils_1 = require_index.require_utils();
+	const MetadataStorage_1 = require_MetadataStorage$1.require_MetadataStorage();
+	/**
+	* Executes validation over given object.
+	*/
+	var ValidationExecutor = class {
+		constructor(validator, validatorOptions) {
+			this.validator = validator;
+			this.validatorOptions = validatorOptions;
+			this.awaitingPromises = [];
+			this.ignoreAsyncValidations = false;
+			this.metadataStorage = (0, MetadataStorage_1.getMetadataStorage)();
+		}
+		execute(object, targetSchema, validationErrors) {
+			var _a, _b;
+			/**
+			* If there is no metadata registered it means possibly the dependencies are not flatterned and
+			* more than one instance is used.
+			*
+			* TODO: This needs proper handling, forcing to use the same container or some other proper solution.
+			*/
+			if (!this.metadataStorage.hasValidationMetaData && ((_a = this.validatorOptions) === null || _a === void 0 ? void 0 : _a.enableDebugMessages) === true) console.warn("No validation metadata found. No validation will be  performed. There are multiple possible reasons:\n  - There may be multiple class-validator versions installed. You will need to flatten your dependencies to fix the issue.\n  - This validation runs before any file with validation decorator was parsed by NodeJS.");
+			const groups = this.validatorOptions ? this.validatorOptions.groups : void 0;
+			const strictGroups = this.validatorOptions && this.validatorOptions.strictGroups || false;
+			const always = this.validatorOptions && this.validatorOptions.always || false;
+			/** Forbid unknown values are turned on by default and any other value than false will enable it. */
+			const forbidUnknownValues = ((_b = this.validatorOptions) === null || _b === void 0 ? void 0 : _b.forbidUnknownValues) === void 0 || this.validatorOptions.forbidUnknownValues !== false;
+			const targetMetadatas = this.metadataStorage.getTargetValidationMetadatas(object.constructor, targetSchema, always, strictGroups, groups);
+			const groupedMetadatas = this.metadataStorage.groupByPropertyName(targetMetadatas);
+			if (this.validatorOptions && forbidUnknownValues && !targetMetadatas.length) {
+				const validationError = new ValidationError_1.ValidationError();
+				if (!this.validatorOptions || !this.validatorOptions.validationError || this.validatorOptions.validationError.target === void 0 || this.validatorOptions.validationError.target === true) validationError.target = object;
+				validationError.value = void 0;
+				validationError.property = void 0;
+				validationError.children = [];
+				validationError.constraints = { unknownValue: "an unknown value was passed to the validate function" };
+				validationErrors.push(validationError);
+				return;
+			}
+			if (this.validatorOptions && this.validatorOptions.whitelist) this.whitelist(object, groupedMetadatas, validationErrors);
+			Object.keys(groupedMetadatas).forEach((propertyName) => {
+				const value = object[propertyName];
+				const definedMetadatas = groupedMetadatas[propertyName].filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.IS_DEFINED);
+				const metadatas = groupedMetadatas[propertyName].filter((metadata) => metadata.type !== ValidationTypes_1.ValidationTypes.IS_DEFINED && metadata.type !== ValidationTypes_1.ValidationTypes.WHITELIST);
+				if (value instanceof Promise && metadatas.find((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.PROMISE_VALIDATION)) this.awaitingPromises.push(value.then((resolvedValue) => {
+					this.performValidations(object, resolvedValue, propertyName, definedMetadatas, metadatas, validationErrors);
+				}));
+				else this.performValidations(object, value, propertyName, definedMetadatas, metadatas, validationErrors);
+			});
+		}
+		whitelist(object, groupedMetadatas, validationErrors) {
+			const notAllowedProperties = [];
+			Object.keys(object).forEach((propertyName) => {
+				if (!groupedMetadatas[propertyName] || groupedMetadatas[propertyName].length === 0) notAllowedProperties.push(propertyName);
+			});
+			if (notAllowedProperties.length > 0) if (this.validatorOptions && this.validatorOptions.forbidNonWhitelisted) notAllowedProperties.forEach((property) => {
+				const validationError = this.generateValidationError(object, object[property], property);
+				validationError.constraints = { [ValidationTypes_1.ValidationTypes.WHITELIST]: `property ${property} should not exist` };
+				validationError.children = void 0;
+				validationErrors.push(validationError);
+			});
+			else notAllowedProperties.forEach((property) => delete object[property]);
+		}
+		stripEmptyErrors(errors) {
+			return errors.filter((error) => {
+				if (error.children) error.children = this.stripEmptyErrors(error.children);
+				if (Object.keys(error.constraints).length === 0) if (error.children.length === 0) return false;
+				else delete error.constraints;
+				return true;
+			});
+		}
+		performValidations(object, value, propertyName, definedMetadatas, metadatas, validationErrors) {
+			const customValidationMetadatas = metadatas.filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.CUSTOM_VALIDATION);
+			const nestedValidationMetadatas = metadatas.filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.NESTED_VALIDATION);
+			const conditionalValidationMetadatas = metadatas.filter((metadata) => metadata.type === ValidationTypes_1.ValidationTypes.CONDITIONAL_VALIDATION);
+			const validationError = this.generateValidationError(object, value, propertyName);
+			validationErrors.push(validationError);
+			if (!this.conditionalValidations(object, value, conditionalValidationMetadatas)) return;
+			this.customValidations(object, value, definedMetadatas, validationError);
+			this.mapContexts(object, value, definedMetadatas, validationError);
+			if (value === void 0 && this.validatorOptions && this.validatorOptions.skipUndefinedProperties === true) return;
+			if (value === null && this.validatorOptions && this.validatorOptions.skipNullProperties === true) return;
+			if ((value === null || value === void 0) && this.validatorOptions && this.validatorOptions.skipMissingProperties === true) return;
+			this.customValidations(object, value, customValidationMetadatas, validationError);
+			this.nestedValidations(value, nestedValidationMetadatas, validationError);
+			this.mapContexts(object, value, metadatas, validationError);
+			this.mapContexts(object, value, customValidationMetadatas, validationError);
+		}
+		generateValidationError(object, value, propertyName) {
+			const validationError = new ValidationError_1.ValidationError();
+			if (!this.validatorOptions || !this.validatorOptions.validationError || this.validatorOptions.validationError.target === void 0 || this.validatorOptions.validationError.target === true) validationError.target = object;
+			if (!this.validatorOptions || !this.validatorOptions.validationError || this.validatorOptions.validationError.value === void 0 || this.validatorOptions.validationError.value === true) validationError.value = value;
+			validationError.property = propertyName;
+			validationError.children = [];
+			validationError.constraints = {};
+			return validationError;
+		}
+		conditionalValidations(object, value, metadatas) {
+			return metadatas.map((metadata) => metadata.constraints[0](object, value)).reduce((resultA, resultB) => resultA && resultB, true);
+		}
+		customValidations(object, value, metadatas, error) {
+			metadatas.forEach((metadata) => {
+				this.metadataStorage.getTargetValidatorConstraints(metadata.constraintCls).forEach((customConstraintMetadata) => {
+					if (customConstraintMetadata.async && this.ignoreAsyncValidations) return;
+					if (this.validatorOptions && this.validatorOptions.stopAtFirstError && Object.keys(error.constraints || {}).length > 0) return;
+					const validationArguments = {
+						targetName: object.constructor ? object.constructor.name : void 0,
+						property: metadata.propertyName,
+						object,
+						value,
+						constraints: metadata.constraints
+					};
+					if (!metadata.each || !(Array.isArray(value) || value instanceof Set || value instanceof Map)) {
+						const validatedValue = customConstraintMetadata.instance.validate(value, validationArguments);
+						if ((0, utils_1.isPromise)(validatedValue)) {
+							const promise = validatedValue.then((isValid) => {
+								if (!isValid) {
+									const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
+									error.constraints[type] = message;
+									if (metadata.context) {
+										if (!error.contexts) error.contexts = {};
+										error.contexts[type] = Object.assign(error.contexts[type] || {}, metadata.context);
+									}
+								}
+							});
+							this.awaitingPromises.push(promise);
+						} else if (!validatedValue) {
+							const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
+							error.constraints[type] = message;
+						}
+						return;
+					}
+					const validatedSubValues = (0, utils_1.convertToArray)(value).map((subValue) => customConstraintMetadata.instance.validate(subValue, validationArguments));
+					if (validatedSubValues.some((validatedSubValue) => (0, utils_1.isPromise)(validatedSubValue))) {
+						const asyncValidatedSubValues = validatedSubValues.map((validatedSubValue) => (0, utils_1.isPromise)(validatedSubValue) ? validatedSubValue : Promise.resolve(validatedSubValue));
+						const asyncValidationIsFinishedPromise = Promise.all(asyncValidatedSubValues).then((flatValidatedValues) => {
+							if (!flatValidatedValues.every((isValid) => isValid)) {
+								const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
+								error.constraints[type] = message;
+								if (metadata.context) {
+									if (!error.contexts) error.contexts = {};
+									error.contexts[type] = Object.assign(error.contexts[type] || {}, metadata.context);
+								}
+							}
+						});
+						this.awaitingPromises.push(asyncValidationIsFinishedPromise);
+						return;
+					}
+					if (!validatedSubValues.every((isValid) => isValid)) {
+						const [type, message] = this.createValidationError(object, value, metadata, customConstraintMetadata);
+						error.constraints[type] = message;
+					}
+				});
+			});
+		}
+		nestedValidations(value, metadatas, error) {
+			if (value === void 0) return;
+			metadatas.forEach((metadata) => {
+				if (metadata.type !== ValidationTypes_1.ValidationTypes.NESTED_VALIDATION && metadata.type !== ValidationTypes_1.ValidationTypes.PROMISE_VALIDATION) return;
+				else if (this.validatorOptions && this.validatorOptions.stopAtFirstError && Object.keys(error.constraints || {}).length > 0) return;
+				if (Array.isArray(value) || value instanceof Set || value instanceof Map) (value instanceof Set ? Array.from(value) : value).forEach((subValue, index) => {
+					this.performValidations(value, subValue, index.toString(), [], metadatas, error.children);
+				});
+				else if (value instanceof Object) {
+					const targetSchema = typeof metadata.target === "string" ? metadata.target : metadata.target.name;
+					this.execute(value, targetSchema, error.children);
+				} else {
+					const [type, message] = this.createValidationError(metadata.target, value, metadata);
+					error.constraints[type] = message;
+				}
+			});
+		}
+		mapContexts(object, value, metadatas, error) {
+			return metadatas.forEach((metadata) => {
+				if (metadata.context) {
+					let customConstraint;
+					if (metadata.type === ValidationTypes_1.ValidationTypes.CUSTOM_VALIDATION) customConstraint = this.metadataStorage.getTargetValidatorConstraints(metadata.constraintCls)[0];
+					const type = this.getConstraintType(metadata, customConstraint);
+					if (error.constraints[type]) {
+						if (!error.contexts) error.contexts = {};
+						error.contexts[type] = Object.assign(error.contexts[type] || {}, metadata.context);
+					}
+				}
+			});
+		}
+		createValidationError(object, value, metadata, customValidatorMetadata) {
+			const targetName = object.constructor ? object.constructor.name : void 0;
+			const type = this.getConstraintType(metadata, customValidatorMetadata);
+			const validationArguments = {
+				targetName,
+				property: metadata.propertyName,
+				object,
+				value,
+				constraints: metadata.constraints
+			};
+			let message = metadata.message || "";
+			if (!metadata.message && (!this.validatorOptions || this.validatorOptions && !this.validatorOptions.dismissDefaultMessages)) {
+				if (customValidatorMetadata && customValidatorMetadata.instance.defaultMessage instanceof Function) message = customValidatorMetadata.instance.defaultMessage(validationArguments);
+			}
+			return [type, ValidationUtils_1.ValidationUtils.replaceMessageSpecialTokens(message, validationArguments)];
+		}
+		getConstraintType(metadata, customValidatorMetadata) {
+			return customValidatorMetadata && customValidatorMetadata.name ? customValidatorMetadata.name : metadata.type;
+		}
+	};
+	exports.ValidationExecutor = ValidationExecutor;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ValidationExecutor();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationTypes.js

@@ -0,0 +1,32 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationTypes.js
+var require_ValidationTypes = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationTypes.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	* Validation types.
+	*/
+	var ValidationTypes = class {
+		/**
+		* Checks if validation type is valid.
+		*/
+		static isValid(type) {
+			return type !== "isValid" && type !== "getMessage" && Object.keys(this).map((key) => this[key]).indexOf(type) !== -1;
+		}
+	};
+	exports.ValidationTypes = ValidationTypes;
+	ValidationTypes.CUSTOM_VALIDATION = "customValidation";
+	ValidationTypes.NESTED_VALIDATION = "nestedValidation";
+	ValidationTypes.PROMISE_VALIDATION = "promiseValidation";
+	ValidationTypes.CONDITIONAL_VALIDATION = "conditionalValidation";
+	ValidationTypes.WHITELIST = "whitelistValidation";
+	ValidationTypes.IS_DEFINED = "isDefined";
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ValidationTypes();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationUtils.js

@@ -0,0 +1,42 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationUtils.js
+var require_ValidationUtils = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/ValidationUtils.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	/**
+	* Convert the constraint to a string to be shown in an error
+	*/
+	function constraintToString(constraint) {
+		if (Array.isArray(constraint)) return constraint.join(", ");
+		if (typeof constraint === "symbol") constraint = constraint.description;
+		return `${constraint}`;
+	}
+	exports.constraintToString = constraintToString;
+	var ValidationUtils = class {
+		static replaceMessageSpecialTokens(message, validationArguments) {
+			let messageString;
+			if (message instanceof Function) messageString = message(validationArguments);
+			else if (typeof message === "string") messageString = message;
+			if (messageString && Array.isArray(validationArguments.constraints)) validationArguments.constraints.forEach((constraint, index) => {
+				messageString = messageString.replace(new RegExp(`\\$constraint${index + 1}`, "g"), constraintToString(constraint));
+			});
+			if (messageString && validationArguments.value !== void 0 && validationArguments.value !== null && [
+				"string",
+				"boolean",
+				"number"
+			].includes(typeof validationArguments.value)) messageString = messageString.replace(/\$value/g, validationArguments.value);
+			if (messageString) messageString = messageString.replace(/\$property/g, validationArguments.property);
+			if (messageString) messageString = messageString.replace(/\$target/g, validationArguments.targetName);
+			return messageString;
+		}
+	};
+	exports.ValidationUtils = ValidationUtils;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ValidationUtils();
+  }
+});

package/build/node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/Validator.js

@@ -0,0 +1,63 @@
+const require_rolldown_runtime = require('../../../../../../../_virtual/rolldown_runtime.js');
+const require_ValidationExecutor$1 = require('./ValidationExecutor.js');
+
+//#region ../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/Validator.js
+var require_Validator = /* @__PURE__ */ require_rolldown_runtime.__commonJS({ "../../node_modules/.pnpm/class-validator@0.14.1/node_modules/class-validator/cjs/validation/Validator.js": ((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const ValidationExecutor_1 = require_ValidationExecutor$1.require_ValidationExecutor();
+	/**
+	* Validator performs validation of the given object based on its metadata.
+	*/
+	var Validator = class {
+		/**
+		* Performs validation of the given object based on decorators or validation schema.
+		*/
+		validate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
+			return this.coreValidate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions);
+		}
+		/**
+		* Performs validation of the given object based on decorators or validation schema and reject on error.
+		*/
+		async validateOrReject(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
+			const errors = await this.coreValidate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions);
+			if (errors.length) return Promise.reject(errors);
+		}
+		/**
+		* Performs validation of the given object based on decorators or validation schema.
+		*/
+		validateSync(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
+			const object = typeof objectOrSchemaName === "string" ? objectOrValidationOptions : objectOrSchemaName;
+			const options = typeof objectOrSchemaName === "string" ? maybeValidatorOptions : objectOrValidationOptions;
+			const schema = typeof objectOrSchemaName === "string" ? objectOrSchemaName : void 0;
+			const executor = new ValidationExecutor_1.ValidationExecutor(this, options);
+			executor.ignoreAsyncValidations = true;
+			const validationErrors = [];
+			executor.execute(object, schema, validationErrors);
+			return executor.stripEmptyErrors(validationErrors);
+		}
+		/**
+		* Performs validation of the given object based on decorators or validation schema.
+		* Common method for `validateOrReject` and `validate` methods.
+		*/
+		coreValidate(objectOrSchemaName, objectOrValidationOptions, maybeValidatorOptions) {
+			const object = typeof objectOrSchemaName === "string" ? objectOrValidationOptions : objectOrSchemaName;
+			const options = typeof objectOrSchemaName === "string" ? maybeValidatorOptions : objectOrValidationOptions;
+			const schema = typeof objectOrSchemaName === "string" ? objectOrSchemaName : void 0;
+			const executor = new ValidationExecutor_1.ValidationExecutor(this, options);
+			const validationErrors = [];
+			executor.execute(object, schema, validationErrors);
+			return Promise.all(executor.awaitingPromises).then(() => {
+				return executor.stripEmptyErrors(validationErrors);
+			});
+		}
+	};
+	exports.Validator = Validator;
+}) });
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_Validator();
+  }
+});