@qraft/asyncapi-plugin 1.0.0-beta.0

package/dist/_vendor/ajv/dist/refs/json-schema-2020-12/schema.json.js

@@ -0,0 +1,94 @@
+var $schema = "https://json-schema.org/draft/2020-12/schema";
+var $id = "https://json-schema.org/draft/2020-12/schema";
+var $vocabulary = {
+	"https://json-schema.org/draft/2020-12/vocab/core": true,
+	"https://json-schema.org/draft/2020-12/vocab/applicator": true,
+	"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+	"https://json-schema.org/draft/2020-12/vocab/validation": true,
+	"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+	"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+	"https://json-schema.org/draft/2020-12/vocab/content": true
+};
+var $dynamicAnchor = "meta";
+var title = "Core and Validation specifications meta-schema";
+var allOf = [
+	{
+		$ref: "meta/core"
+	},
+	{
+		$ref: "meta/applicator"
+	},
+	{
+		$ref: "meta/unevaluated"
+	},
+	{
+		$ref: "meta/validation"
+	},
+	{
+		$ref: "meta/meta-data"
+	},
+	{
+		$ref: "meta/format-annotation"
+	},
+	{
+		$ref: "meta/content"
+	}
+];
+var type = [
+	"object",
+	"boolean"
+];
+var $comment = "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.";
+var properties = {
+	definitions: {
+		$comment: "\"definitions\" has been replaced by \"$defs\".",
+		type: "object",
+		additionalProperties: {
+			$dynamicRef: "#meta"
+		},
+		deprecated: true,
+		"default": {
+		}
+	},
+	dependencies: {
+		$comment: "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+		type: "object",
+		additionalProperties: {
+			anyOf: [
+				{
+					$dynamicRef: "#meta"
+				},
+				{
+					$ref: "meta/validation#/$defs/stringArray"
+				}
+			]
+		},
+		deprecated: true,
+		"default": {
+		}
+	},
+	$recursiveAnchor: {
+		$comment: "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+		$ref: "meta/core#/$defs/anchorString",
+		deprecated: true
+	},
+	$recursiveRef: {
+		$comment: "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+		$ref: "meta/core#/$defs/uriReferenceString",
+		deprecated: true
+	}
+};
+var require$$0 = {
+	$schema: $schema,
+	$id: $id,
+	$vocabulary: $vocabulary,
+	$dynamicAnchor: $dynamicAnchor,
+	title: title,
+	allOf: allOf,
+	type: type,
+	$comment: $comment,
+	properties: properties
+};
+
+export { $comment, $dynamicAnchor, $id, $schema, $vocabulary, allOf, require$$0 as default, properties, title, type };
+//# sourceMappingURL=schema.json.js.map

package/dist/_vendor/ajv/dist/refs/json-schema-2020-12/schema.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/_vendor/ajv/dist/refs/json-schema-draft-06.json.js

@@ -0,0 +1,233 @@
+var $schema = "http://json-schema.org/draft-06/schema#";
+var $id = "http://json-schema.org/draft-06/schema#";
+var title = "Core schema meta-schema";
+var definitions = {
+	schemaArray: {
+		type: "array",
+		minItems: 1,
+		items: {
+			$ref: "#"
+		}
+	},
+	nonNegativeInteger: {
+		type: "integer",
+		minimum: 0
+	},
+	nonNegativeIntegerDefault0: {
+		allOf: [
+			{
+				$ref: "#/definitions/nonNegativeInteger"
+			},
+			{
+				"default": 0
+			}
+		]
+	},
+	simpleTypes: {
+		"enum": [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		]
+	},
+	stringArray: {
+		type: "array",
+		items: {
+			type: "string"
+		},
+		uniqueItems: true,
+		"default": [
+		]
+	}
+};
+var type = [
+	"object",
+	"boolean"
+];
+var properties = {
+	$id: {
+		type: "string",
+		format: "uri-reference"
+	},
+	$schema: {
+		type: "string",
+		format: "uri"
+	},
+	$ref: {
+		type: "string",
+		format: "uri-reference"
+	},
+	title: {
+		type: "string"
+	},
+	description: {
+		type: "string"
+	},
+	"default": {
+	},
+	examples: {
+		type: "array",
+		items: {
+		}
+	},
+	multipleOf: {
+		type: "number",
+		exclusiveMinimum: 0
+	},
+	maximum: {
+		type: "number"
+	},
+	exclusiveMaximum: {
+		type: "number"
+	},
+	minimum: {
+		type: "number"
+	},
+	exclusiveMinimum: {
+		type: "number"
+	},
+	maxLength: {
+		$ref: "#/definitions/nonNegativeInteger"
+	},
+	minLength: {
+		$ref: "#/definitions/nonNegativeIntegerDefault0"
+	},
+	pattern: {
+		type: "string",
+		format: "regex"
+	},
+	additionalItems: {
+		$ref: "#"
+	},
+	items: {
+		anyOf: [
+			{
+				$ref: "#"
+			},
+			{
+				$ref: "#/definitions/schemaArray"
+			}
+		],
+		"default": {
+		}
+	},
+	maxItems: {
+		$ref: "#/definitions/nonNegativeInteger"
+	},
+	minItems: {
+		$ref: "#/definitions/nonNegativeIntegerDefault0"
+	},
+	uniqueItems: {
+		type: "boolean",
+		"default": false
+	},
+	contains: {
+		$ref: "#"
+	},
+	maxProperties: {
+		$ref: "#/definitions/nonNegativeInteger"
+	},
+	minProperties: {
+		$ref: "#/definitions/nonNegativeIntegerDefault0"
+	},
+	required: {
+		$ref: "#/definitions/stringArray"
+	},
+	additionalProperties: {
+		$ref: "#"
+	},
+	definitions: {
+		type: "object",
+		additionalProperties: {
+			$ref: "#"
+		},
+		"default": {
+		}
+	},
+	properties: {
+		type: "object",
+		additionalProperties: {
+			$ref: "#"
+		},
+		"default": {
+		}
+	},
+	patternProperties: {
+		type: "object",
+		additionalProperties: {
+			$ref: "#"
+		},
+		"default": {
+		}
+	},
+	dependencies: {
+		type: "object",
+		additionalProperties: {
+			anyOf: [
+				{
+					$ref: "#"
+				},
+				{
+					$ref: "#/definitions/stringArray"
+				}
+			]
+		}
+	},
+	propertyNames: {
+		$ref: "#"
+	},
+	"const": {
+	},
+	"enum": {
+		type: "array",
+		minItems: 1,
+		uniqueItems: true
+	},
+	type: {
+		anyOf: [
+			{
+				$ref: "#/definitions/simpleTypes"
+			},
+			{
+				type: "array",
+				items: {
+					$ref: "#/definitions/simpleTypes"
+				},
+				minItems: 1,
+				uniqueItems: true
+			}
+		]
+	},
+	format: {
+		type: "string"
+	},
+	allOf: {
+		$ref: "#/definitions/schemaArray"
+	},
+	anyOf: {
+		$ref: "#/definitions/schemaArray"
+	},
+	oneOf: {
+		$ref: "#/definitions/schemaArray"
+	},
+	not: {
+		$ref: "#"
+	}
+};
+var require$$7 = {
+	$schema: $schema,
+	$id: $id,
+	title: title,
+	definitions: definitions,
+	type: type,
+	properties: properties,
+	"default": {
+}
+};
+
+export { $id, $schema, require$$7 as default, definitions, properties, title, type };
+//# sourceMappingURL=json-schema-draft-06.json.js.map

package/dist/_vendor/ajv/dist/refs/json-schema-draft-06.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-draft-06.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/_vendor/ajv/dist/refs/json-schema-draft-07.json.js

@@ -0,0 +1,254 @@
+var $schema = "http://json-schema.org/draft-07/schema#";
+var $id = "http://json-schema.org/draft-07/schema#";
+var title = "Core schema meta-schema";
+var definitions = {
+	schemaArray: {
+		type: "array",
+		minItems: 1,
+		items: {
+			$ref: "#"
+		}
+	},
+	nonNegativeInteger: {
+		type: "integer",
+		minimum: 0
+	},
+	nonNegativeIntegerDefault0: {
+		allOf: [
+			{
+				$ref: "#/definitions/nonNegativeInteger"
+			},
+			{
+				"default": 0
+			}
+		]
+	},
+	simpleTypes: {
+		"enum": [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		]
+	},
+	stringArray: {
+		type: "array",
+		items: {
+			type: "string"
+		},
+		uniqueItems: true,
+		"default": [
+		]
+	}
+};
+var type = [
+	"object",
+	"boolean"
+];
+var properties = {
+	$id: {
+		type: "string",
+		format: "uri-reference"
+	},
+	$schema: {
+		type: "string",
+		format: "uri"
+	},
+	$ref: {
+		type: "string",
+		format: "uri-reference"
+	},
+	$comment: {
+		type: "string"
+	},
+	title: {
+		type: "string"
+	},
+	description: {
+		type: "string"
+	},
+	"default": true,
+	readOnly: {
+		type: "boolean",
+		"default": false
+	},
+	examples: {
+		type: "array",
+		items: true
+	},
+	multipleOf: {
+		type: "number",
+		exclusiveMinimum: 0
+	},
+	maximum: {
+		type: "number"
+	},
+	exclusiveMaximum: {
+		type: "number"
+	},
+	minimum: {
+		type: "number"
+	},
+	exclusiveMinimum: {
+		type: "number"
+	},
+	maxLength: {
+		$ref: "#/definitions/nonNegativeInteger"
+	},
+	minLength: {
+		$ref: "#/definitions/nonNegativeIntegerDefault0"
+	},
+	pattern: {
+		type: "string",
+		format: "regex"
+	},
+	additionalItems: {
+		$ref: "#"
+	},
+	items: {
+		anyOf: [
+			{
+				$ref: "#"
+			},
+			{
+				$ref: "#/definitions/schemaArray"
+			}
+		],
+		"default": true
+	},
+	maxItems: {
+		$ref: "#/definitions/nonNegativeInteger"
+	},
+	minItems: {
+		$ref: "#/definitions/nonNegativeIntegerDefault0"
+	},
+	uniqueItems: {
+		type: "boolean",
+		"default": false
+	},
+	contains: {
+		$ref: "#"
+	},
+	maxProperties: {
+		$ref: "#/definitions/nonNegativeInteger"
+	},
+	minProperties: {
+		$ref: "#/definitions/nonNegativeIntegerDefault0"
+	},
+	required: {
+		$ref: "#/definitions/stringArray"
+	},
+	additionalProperties: {
+		$ref: "#"
+	},
+	definitions: {
+		type: "object",
+		additionalProperties: {
+			$ref: "#"
+		},
+		"default": {
+		}
+	},
+	properties: {
+		type: "object",
+		additionalProperties: {
+			$ref: "#"
+		},
+		"default": {
+		}
+	},
+	patternProperties: {
+		type: "object",
+		additionalProperties: {
+			$ref: "#"
+		},
+		propertyNames: {
+			format: "regex"
+		},
+		"default": {
+		}
+	},
+	dependencies: {
+		type: "object",
+		additionalProperties: {
+			anyOf: [
+				{
+					$ref: "#"
+				},
+				{
+					$ref: "#/definitions/stringArray"
+				}
+			]
+		}
+	},
+	propertyNames: {
+		$ref: "#"
+	},
+	"const": true,
+	"enum": {
+		type: "array",
+		items: true,
+		minItems: 1,
+		uniqueItems: true
+	},
+	type: {
+		anyOf: [
+			{
+				$ref: "#/definitions/simpleTypes"
+			},
+			{
+				type: "array",
+				items: {
+					$ref: "#/definitions/simpleTypes"
+				},
+				minItems: 1,
+				uniqueItems: true
+			}
+		]
+	},
+	format: {
+		type: "string"
+	},
+	contentMediaType: {
+		type: "string"
+	},
+	contentEncoding: {
+		type: "string"
+	},
+	"if": {
+		$ref: "#"
+	},
+	then: {
+		$ref: "#"
+	},
+	"else": {
+		$ref: "#"
+	},
+	allOf: {
+		$ref: "#/definitions/schemaArray"
+	},
+	anyOf: {
+		$ref: "#/definitions/schemaArray"
+	},
+	oneOf: {
+		$ref: "#/definitions/schemaArray"
+	},
+	not: {
+		$ref: "#"
+	}
+};
+var require$$3 = {
+	$schema: $schema,
+	$id: $id,
+	title: title,
+	definitions: definitions,
+	type: type,
+	properties: properties,
+	"default": true
+};
+
+export { $id, $schema, require$$3 as default, definitions, properties, title, type };
+//# sourceMappingURL=json-schema-draft-07.json.js.map

package/dist/_vendor/ajv/dist/refs/json-schema-draft-07.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-draft-07.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/_vendor/ajv/dist/runtime/equal.js

@@ -0,0 +1,19 @@
+import { __exports as equal } from '../../../../_virtual/equal.js';
+import { __require as requireFastDeepEqual } from '../../../fast-deep-equal/index.js';
+
+var hasRequiredEqual;
+
+function requireEqual () {
+	if (hasRequiredEqual) return equal;
+	hasRequiredEqual = 1;
+	Object.defineProperty(equal, "__esModule", { value: true });
+	// https://github.com/ajv-validator/ajv/issues/889
+	const equal$1 = /*@__PURE__*/ requireFastDeepEqual();
+	equal$1.code = 'require("ajv/dist/runtime/equal").default';
+	equal.default = equal$1;
+	
+	return equal;
+}
+
+export { requireEqual as __require };
+//# sourceMappingURL=equal.js.map

package/dist/_vendor/ajv/dist/runtime/equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"equal.js","sources":["../../../../../../../node_modules/ajv/dist/runtime/equal.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// https://github.com/ajv-validator/ajv/issues/889\nconst equal = require(\"fast-deep-equal\");\nequal.code = 'require(\"ajv/dist/runtime/equal\").default';\nexports.default = equal;\n//# sourceMappingURL=equal.js.map"],"names":["equal_1","equal","require$$0"],"mappings":";;;;;;;;AACA,CAAA,MAAM,CAAC,cAAc,CAACA,KAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;AAC7D;CACA,MAAMC,OAAK,iBAA6BC,oBAAA,EAAA,CAAA;CACxCD,OAAK,CAAC,IAAI,GAAG,2CAA2C,CAAA;AACxD,CAAAD,KAAA,CAAA,OAAe,GAAGC,OAAK,CAAA;AACvB,CAAA;;;;;;","x_google_ignoreList":[0]}

package/dist/_vendor/ajv/dist/runtime/ucs2length.js

@@ -0,0 +1,35 @@
+import { __exports as ucs2length } from '../../../../_virtual/ucs2length.js';
+
+var hasRequiredUcs2length;
+
+function requireUcs2length () {
+	if (hasRequiredUcs2length) return ucs2length;
+	hasRequiredUcs2length = 1;
+	Object.defineProperty(ucs2length, "__esModule", { value: true });
+	// https://mathiasbynens.be/notes/javascript-encoding
+	// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode
+	function ucs2length$1(str) {
+	    const len = str.length;
+	    let length = 0;
+	    let pos = 0;
+	    let value;
+	    while (pos < len) {
+	        length++;
+	        value = str.charCodeAt(pos++);
+	        if (value >= 0xd800 && value <= 0xdbff && pos < len) {
+	            // high surrogate, and there is a next character
+	            value = str.charCodeAt(pos);
+	            if ((value & 0xfc00) === 0xdc00)
+	                pos++; // low surrogate
+	        }
+	    }
+	    return length;
+	}
+	ucs2length.default = ucs2length$1;
+	ucs2length$1.code = 'require("ajv/dist/runtime/ucs2length").default';
+	
+	return ucs2length;
+}
+
+export { requireUcs2length as __require };
+//# sourceMappingURL=ucs2length.js.map

package/dist/_vendor/ajv/dist/runtime/ucs2length.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ucs2length.js","sources":["../../../../../../../node_modules/ajv/dist/runtime/ucs2length.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// https://mathiasbynens.be/notes/javascript-encoding\n// https://github.com/bestiejs/punycode.js - punycode.ucs2.decode\nfunction ucs2length(str) {\n    const len = str.length;\n    let length = 0;\n    let pos = 0;\n    let value;\n    while (pos < len) {\n        length++;\n        value = str.charCodeAt(pos++);\n        if (value >= 0xd800 && value <= 0xdbff && pos < len) {\n            // high surrogate, and there is a next character\n            value = str.charCodeAt(pos);\n            if ((value & 0xfc00) === 0xdc00)\n                pos++; // low surrogate\n        }\n    }\n    return length;\n}\nexports.default = ucs2length;\nucs2length.code = 'require(\"ajv/dist/runtime/ucs2length\").default';\n//# sourceMappingURL=ucs2length.js.map"],"names":["ucs2length_1","ucs2length"],"mappings":";;;;;;;AACA,CAAA,MAAM,CAAC,cAAc,CAACA,UAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;AAC7D;AACA;CACA,SAASC,YAAU,CAAC,GAAG,EAAE;AACzB,KAAI,MAAM,GAAG,GAAG,GAAG,CAAC,MAAM,CAAA;KACtB,IAAI,MAAM,GAAG,CAAC,CAAA;KACd,IAAI,GAAG,GAAG,CAAC,CAAA;AACf,KAAI,IAAI,KAAK,CAAA;AACb,KAAI,OAAO,GAAG,GAAG,GAAG,EAAE;AACtB,SAAQ,MAAM,EAAE,CAAA;SACR,KAAK,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,CAAA;AACrC,SAAQ,IAAI,KAAK,IAAI,MAAM,IAAI,KAAK,IAAI,MAAM,IAAI,GAAG,GAAG,GAAG,EAAE;AAC7D;AACA,aAAY,KAAK,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAA;AACvC,aAAY,IAAI,CAAC,KAAK,GAAG,MAAM,MAAM,MAAM;iBAC3B,GAAG,EAAE,CAAC;AACtB,UAAA;AACA,MAAA;AACA,KAAI,OAAO,MAAM,CAAA;AACjB,EAAA;AACA,CAAAD,UAAA,CAAA,OAAe,GAAGC,YAAU,CAAA;CAC5BA,YAAU,CAAC,IAAI,GAAG,gDAAgD,CAAA;AAClE,CAAA;;;;;;","x_google_ignoreList":[0]}

package/dist/_vendor/ajv/dist/runtime/uri.js

@@ -0,0 +1,18 @@
+import { __exports as uri } from '../../../../_virtual/uri.js';
+import { __require as requireFastUri } from '../../../fast-uri/index.js';
+
+var hasRequiredUri;
+
+function requireUri () {
+	if (hasRequiredUri) return uri;
+	hasRequiredUri = 1;
+	Object.defineProperty(uri, "__esModule", { value: true });
+	const uri$1 = /*@__PURE__*/ requireFastUri();
+	uri$1.code = 'require("ajv/dist/runtime/uri").default';
+	uri.default = uri$1;
+	
+	return uri;
+}
+
+export { requireUri as __require };
+//# sourceMappingURL=uri.js.map

package/dist/_vendor/ajv/dist/runtime/uri.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uri.js","sources":["../../../../../../../node_modules/ajv/dist/runtime/uri.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst uri = require(\"fast-uri\");\nuri.code = 'require(\"ajv/dist/runtime/uri\").default';\nexports.default = uri;\n//# sourceMappingURL=uri.js.map"],"names":["uri_1","uri","require$$0"],"mappings":";;;;;;;;AACA,CAAA,MAAM,CAAC,cAAc,CAACA,GAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;CAC7D,MAAMC,KAAG,iBAAsBC,cAAA,EAAA,CAAA;CAC/BD,KAAG,CAAC,IAAI,GAAG,yCAAyC,CAAA;AACpD,CAAAD,GAAA,CAAA,OAAe,GAAGC,KAAG,CAAA;AACrB,CAAA;;;;;;","x_google_ignoreList":[0]}

package/dist/_vendor/ajv/dist/runtime/validation_error.js

@@ -0,0 +1,22 @@
+import { __exports as validation_error } from '../../../../_virtual/validation_error.js';
+
+var hasRequiredValidation_error;
+
+function requireValidation_error () {
+	if (hasRequiredValidation_error) return validation_error;
+	hasRequiredValidation_error = 1;
+	Object.defineProperty(validation_error, "__esModule", { value: true });
+	class ValidationError extends Error {
+	    constructor(errors) {
+	        super("validation failed");
+	        this.errors = errors;
+	        this.ajv = this.validation = true;
+	    }
+	}
+	validation_error.default = ValidationError;
+	
+	return validation_error;
+}
+
+export { requireValidation_error as __require };
+//# sourceMappingURL=validation_error.js.map

package/dist/_vendor/ajv/dist/runtime/validation_error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation_error.js","sources":["../../../../../../../node_modules/ajv/dist/runtime/validation_error.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nclass ValidationError extends Error {\n    constructor(errors) {\n        super(\"validation failed\");\n        this.errors = errors;\n        this.ajv = this.validation = true;\n    }\n}\nexports.default = ValidationError;\n//# sourceMappingURL=validation_error.js.map"],"names":[],"mappings":";;;;;;;AACA,CAAA,MAAM,CAAC,cAAc,CAAC,gBAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;CAC7D,MAAM,eAAe,SAAS,KAAK,CAAC;KAChC,WAAW,CAAC,MAAM,EAAE;SAChB,KAAK,CAAC,mBAAmB,CAAC,CAAA;AAClC,SAAQ,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;SACpB,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;AACzC,MAAA;AACA,EAAA;AACA,CAAA,gBAAA,CAAA,OAAe,GAAG,eAAe,CAAA;AACjC,CAAA;;;;;;","x_google_ignoreList":[0]}