@atscript/typescript 0.0.29 → 0.0.30

package/dist/utils.cjs

@@ -0,0 +1,552 @@
+"use strict";
+
+//#region packages/typescript/src/validator.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+const regexCache = new Map();
+var Validator = class {
+	isLimitExceeded() {
+		if (this.stackErrors.length > 0) return this.stackErrors[this.stackErrors.length - 1].length >= this.opts.errorLimit;
+		return this.errors.length >= this.opts.errorLimit;
+	}
+	push(name) {
+		this.stackPath.push(name);
+		this.stackErrors.push([]);
+	}
+	pop(saveErrors) {
+		this.stackPath.pop();
+		const popped = this.stackErrors.pop();
+		if (saveErrors && popped?.length) popped.forEach((error) => {
+			this.error(error.message, error.path, error.details);
+		});
+		return popped;
+	}
+	clear() {
+		this.stackErrors[this.stackErrors.length - 1] = [];
+	}
+	error(message, path, details) {
+		const errors = this.stackErrors[this.stackErrors.length - 1] || this.errors;
+		const error = {
+			path: path || this.path,
+			message
+		};
+		if (details?.length) error.details = details;
+		errors.push(error);
+	}
+	throw() {
+		throw new ValidatorError(this.errors);
+	}
+	validate(value, safe) {
+		this.push("");
+		this.errors = [];
+		this.stackErrors = [];
+		const passed = this.validateSafe(this.def, value);
+		this.pop(!passed);
+		if (!passed) {
+			if (safe) return false;
+			this.throw();
+		}
+		return true;
+	}
+	validateSafe(def, value) {
+		if (this.isLimitExceeded()) return false;
+		if (!isAnnotatedType(def)) throw new Error("Can not validate not-annotated type");
+		if (typeof this.opts.replace === "function") def = this.opts.replace(def, this.path);
+		if (def.optional && value === undefined) return true;
+		for (const plugin of this.opts.plugins) {
+			const result = plugin(this, def, value);
+			if (result === false || result === true) return result;
+		}
+		return this.validateAnnotatedType(def, value);
+	}
+	get path() {
+		return this.stackPath.slice(1).join(".");
+	}
+	validateAnnotatedType(def, value) {
+		switch (def.type.kind) {
+			case "object": return this.validateObject(def, value);
+			case "union": return this.validateUnion(def, value);
+			case "intersection": return this.validateIntersection(def, value);
+			case "tuple": return this.validateTuple(def, value);
+			case "array": return this.validateArray(def, value);
+			case "": return this.validatePrimitive(def, value);
+			default: throw new Error(`Unknown type "${def.type.kind}"`);
+		}
+	}
+	validateUnion(def, value) {
+		let i = 0;
+		const popped = [];
+		for (const item of def.type.items) {
+			this.push(`[${item.type.kind || item.type.designType}(${i})]`);
+			if (this.validateSafe(item, value)) {
+				this.pop(false);
+				return true;
+			}
+			const errors = this.pop(false);
+			if (errors) popped.push(...errors);
+			i++;
+		}
+		this.clear();
+		const expected = def.type.items.map((item, i$1) => `[${item.type.kind || item.type.designType}(${i$1})]`).join(", ");
+		this.error(`Value does not match any of the allowed types: ${expected}`, undefined, popped);
+		return false;
+	}
+	validateIntersection(def, value) {
+		for (const item of def.type.items) if (!this.validateSafe(item, value)) return false;
+		return true;
+	}
+	validateTuple(def, value) {
+		if (!Array.isArray(value) || value.length !== def.type.items.length) {
+			this.error(`Expected array of length ${def.type.items.length}`);
+			return false;
+		}
+		let i = 0;
+		for (const item of def.type.items) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(item, value[i])) {
+				this.pop(true);
+				return false;
+			}
+			this.pop(false);
+			i++;
+		}
+		return true;
+	}
+	validateArray(def, value) {
+		if (!Array.isArray(value)) {
+			this.error("Expected array");
+			return false;
+		}
+		const minLength = def.metadata.get("expect.minLength");
+		if (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} items, got ${value.length} items`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} items, got ${value.length} items`);
+			return false;
+		}
+		let i = 0;
+		let passed = true;
+		for (const item of value) {
+			this.push(`[${i}]`);
+			if (!this.validateSafe(def.type.of, item)) {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			} else this.pop(false);
+			i++;
+		}
+		return passed;
+	}
+	validateObject(def, value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) {
+			this.error("Expected object");
+			return false;
+		}
+		let passed = true;
+		const valueKeys = new Set(Object.keys(value));
+		const typeKeys = new Set();
+		const skipList = new Set();
+		if (this.opts.skipList) {
+			const path = this.stackPath.length > 1 ? `${this.path}.` : "";
+			this.opts.skipList.forEach((item) => {
+				if (item.startsWith(path)) {
+					const key = item.slice(path.length);
+					skipList.add(key);
+					valueKeys.delete(key);
+				}
+			});
+		}
+		let partialFunctionMatched = false;
+		if (typeof this.opts.partial === "function") partialFunctionMatched = this.opts.partial(def, this.path);
+		for (const [key, item] of def.type.props.entries()) {
+			if (skipList.has(key)) continue;
+			typeKeys.add(key);
+			if (value[key] === undefined) {
+				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
+			}
+			this.push(key);
+			if (this.validateSafe(item, value[key])) this.pop(false);
+else {
+				passed = false;
+				this.pop(true);
+				if (this.isLimitExceeded()) return false;
+			}
+		}
+		for (const key of valueKeys)
+ /** matched patterns for unknown keys */ if (!typeKeys.has(key)) {
+			const matched = [];
+			for (const { pattern, def: propDef } of def.type.propsPatterns) if (pattern.test(key)) matched.push({
+				pattern,
+				def: propDef
+			});
+			if (matched.length) {
+				let keyPassed = false;
+				for (const { def: def$1 } of matched) if (this.validateSafe(def$1, value[key])) {
+					this.pop(false);
+					keyPassed = true;
+					break;
+				}
+				if (!keyPassed) {
+					this.push(key);
+					this.validateSafe(matched[0].def, value[key]);
+					this.pop(true);
+					passed = false;
+					if (this.isLimitExceeded()) return false;
+				}
+			} else if (this.opts.unknwonProps !== "ignore") {
+				if (this.opts.unknwonProps === "error") {
+					this.push(key);
+					this.error(`Unexpected property`);
+					this.pop(true);
+					if (this.isLimitExceeded()) return false;
+					passed = false;
+				} else if (this.opts.unknwonProps === "strip") delete value[key];
+			}
+		}
+		return passed;
+	}
+	validatePrimitive(def, value) {
+		if (typeof def.type.value !== "undefined") {
+			if (value !== def.type.value) {
+				this.error(`Expected ${def.type.value}, got ${value}`);
+				return false;
+			}
+			return true;
+		}
+		const typeOfValue = Array.isArray(value) ? "array" : typeof value;
+		switch (def.type.designType) {
+			case "never":
+				this.error(`This type is impossible, must be an internal problem`);
+				return false;
+			case "any": return true;
+			case "string":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateString(def, value);
+			case "number":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return this.validateNumber(def, value);
+			case "boolean":
+				if (typeOfValue !== def.type.designType) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "undefined":
+				if (value !== undefined) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			case "null":
+				if (value !== null) {
+					this.error(`Expected ${def.type.designType}, got ${typeOfValue}`);
+					return false;
+				}
+				return true;
+			default: throw new Error(`Unknown type "${def.type.designType}"`);
+		}
+	}
+	validateString(def, value) {
+		const minLength = def.metadata.get("expect.minLength");
+		if (typeof minLength === "number" && value.length < minLength) {
+			this.error(`Expected minimum length of ${minLength} characters, got ${value.length} characters`);
+			return false;
+		}
+		const maxLength = def.metadata.get("expect.maxLength");
+		if (typeof maxLength === "number" && value.length > maxLength) {
+			this.error(`Expected maximum length of ${maxLength} characters, got ${value.length} characters`);
+			return false;
+		}
+		const patterns = def.metadata.get("expect.pattern");
+		for (const { pattern, flags, message } of patterns || []) {
+			if (!pattern) continue;
+			const cacheKey = `${pattern}//${flags || ""}`;
+			let regex = regexCache.get(cacheKey);
+			if (!regex) {
+				regex = new RegExp(pattern, flags);
+				regexCache.set(cacheKey, regex);
+			}
+			if (!regex.test(value)) {
+				this.error(message || `Value is expected to match pattern "${pattern}"`);
+				return false;
+			}
+		}
+		return true;
+	}
+	validateNumber(def, value) {
+		const int = def.metadata.get("expect.int");
+		if (typeof int === "boolean" && int && value % 1 !== 0) {
+			this.error(`Expected integer, got ${value}`);
+			return false;
+		}
+		const min = def.metadata.get("expect.min");
+		if (typeof min === "number" && value < min) {
+			this.error(`Expected minimum ${min}, got ${value}`);
+			return false;
+		}
+		const max = def.metadata.get("expect.max");
+		if (typeof max === "number" && value > max) {
+			this.error(`Expected maximum ${max}, got ${value}`);
+			return false;
+		}
+		return true;
+	}
+	constructor(def, opts) {
+		_define_property(this, "def", void 0);
+		_define_property(this, "opts", void 0);
+		_define_property(this, "errors", void 0);
+		_define_property(this, "stackErrors", void 0);
+		_define_property(this, "stackPath", void 0);
+		this.def = def;
+		this.errors = [];
+		this.stackErrors = [];
+		this.stackPath = [];
+		this.opts = {
+			partial: false,
+			unknwonProps: "error",
+			errorLimit: 10,
+			...opts,
+			plugins: opts?.plugins || []
+		};
+	}
+};
+var ValidatorError = class extends Error {
+	constructor(errors) {
+		super(`${errors[0].path ? errors[0].path + ": " : ""}${errors[0].message}`), _define_property(this, "errors", void 0), _define_property(this, "name", void 0), this.errors = errors, this.name = "Validation Error";
+	}
+};
+
+//#endregion
+//#region packages/typescript/src/annotated-type.ts
+function isAnnotatedType(type) {
+	return type && type.__is_atscript_annotated_type;
+}
+function defineAnnotatedType(_kind, base) {
+	const kind = _kind || "";
+	const type = base?.type || {};
+	type.kind = kind;
+	if ([
+		"union",
+		"intersection",
+		"tuple"
+	].includes(kind)) type.items = [];
+	if (kind === "object") {
+		type.props = new Map();
+		type.propsPatterns = [];
+	}
+	type.tags = new Set();
+	const metadata = base?.metadata || new Map();
+	if (base) Object.assign(base, {
+		__is_atscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	});
+else base = {
+		__is_atscript_annotated_type: true,
+		metadata,
+		type,
+		validator(opts) {
+			return new Validator(this, opts);
+		}
+	};
+	const handle = {
+		$type: base,
+		$def: type,
+		$metadata: metadata,
+		_existingObject: undefined,
+		tags(...tags) {
+			for (const tag of tags) this.$def.tags.add(tag);
+			return this;
+		},
+		designType(value) {
+			this.$def.designType = value;
+			return this;
+		},
+		value(value) {
+			this.$def.value = value;
+			return this;
+		},
+		of(value) {
+			this.$def.of = value;
+			return this;
+		},
+		item(value) {
+			this.$def.items.push(value);
+			return this;
+		},
+		prop(name, value) {
+			this.$def.props.set(name, value);
+			return this;
+		},
+		propPattern(pattern, def) {
+			this.$def.propsPatterns.push({
+				pattern,
+				def
+			});
+			return this;
+		},
+		optional(value = true) {
+			this.$type.optional = value;
+			return this;
+		},
+		copyMetadata(fromMetadata, ignore) {
+			for (const [key, value] of fromMetadata.entries()) if (!ignore || !ignore.has(key)) this.$metadata.set(key, value);
+			return this;
+		},
+		refTo(type$1, chain) {
+			let newBase = type$1;
+			const typeName = type$1.name || "Unknown";
+			if (isAnnotatedType(newBase)) {
+				let keys = "";
+				for (const c of chain || []) {
+					keys += `["${c}"]`;
+					if (newBase.type.kind === "object" && newBase.type.props.has(c)) newBase = newBase.type.props.get(c);
+else throw new Error(`Can't find prop ${typeName}${keys}`);
+				}
+				if (!newBase && keys) throw new Error(`Can't find prop ${typeName}${keys}`);
+else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
+				this.$type = {
+					__is_atscript_annotated_type: true,
+					type: newBase.type,
+					metadata,
+					validator(opts) {
+						return new Validator(this, opts);
+					}
+				};
+			} else throw new Error(`${type$1} is not annotated type`);
+			return this;
+		},
+		annotate(key, value, asArray) {
+			if (asArray) if (this.$metadata.has(key)) {
+				const a = this.$metadata.get(key);
+				if (Array.isArray(a)) a.push(value);
+else this.$metadata.set(key, [a, value]);
+			} else this.$metadata.set(key, [value]);
+else this.$metadata.set(key, value);
+			return this;
+		}
+	};
+	return handle;
+}
+function isAnnotatedTypeOfPrimitive(t) {
+	if (["array", "object"].includes(t.type.kind)) return false;
+	if (!t.type.kind) return true;
+	if ([
+		"union",
+		"tuple",
+		"intersection"
+	].includes(t.type.kind)) {
+		for (const item of t.type.items) if (!isAnnotatedTypeOfPrimitive(item)) return false;
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region packages/typescript/src/json-schema.ts
+function buildJsonSchema(type) {
+	const build = (def) => {
+		const t = def.type;
+		const meta = def.metadata;
+		switch (t.kind) {
+			case "object": {
+				const obj = t;
+				const properties = {};
+				const required = [];
+				for (const [key, val] of obj.props.entries()) {
+					properties[key] = build(val);
+					if (!val.optional) required.push(key);
+				}
+				const schema = {
+					type: "object",
+					properties
+				};
+				if (required.length) schema.required = required;
+				return schema;
+			}
+			case "array": {
+				const arr = t;
+				const schema = {
+					type: "array",
+					items: build(arr.of)
+				};
+				const minLength = meta.get("expect.minLength");
+				if (typeof minLength === "number") schema.minItems = minLength;
+				const maxLength = meta.get("expect.maxLength");
+				if (typeof maxLength === "number") schema.maxItems = maxLength;
+				return schema;
+			}
+			case "union": {
+				const grp = t;
+				return { anyOf: grp.items.map(build) };
+			}
+			case "intersection": {
+				const grp = t;
+				return { allOf: grp.items.map(build) };
+			}
+			case "tuple": {
+				const grp = t;
+				return {
+					type: "array",
+					items: grp.items.map(build),
+					additionalItems: false
+				};
+			}
+			case "": {
+				const fin = t;
+				const schema = {};
+				if (fin.value !== undefined) schema.const = fin.value;
+				if (fin.designType && fin.designType !== "any") {
+					schema.type = fin.designType === "undefined" ? "null" : fin.designType;
+					if (schema.type === "number" && meta.get("expect.int")) schema.type = "integer";
+				}
+				if (schema.type === "string") {
+					const minLength = meta.get("expect.minLength");
+					if (typeof minLength === "number") schema.minLength = minLength;
+					const maxLength = meta.get("expect.maxLength");
+					if (typeof maxLength === "number") schema.maxLength = maxLength;
+					const patterns = meta.get("expect.pattern");
+					if (patterns?.length) if (patterns.length === 1) schema.pattern = patterns[0].pattern;
+else schema.allOf = (schema.allOf || []).concat(patterns.map((p) => ({ pattern: p.pattern })));
+				}
+				if (schema.type === "number" || schema.type === "integer") {
+					const min = meta.get("expect.min");
+					if (typeof min === "number") schema.minimum = min;
+					const max = meta.get("expect.max");
+					if (typeof max === "number") schema.maximum = max;
+				}
+				return schema;
+			}
+			default: return {};
+		}
+	};
+	return build(type);
+}
+
+//#endregion
+exports.Validator = Validator
+exports.ValidatorError = ValidatorError
+exports.buildJsonSchema = buildJsonSchema
+exports.defineAnnotatedType = defineAnnotatedType
+exports.isAnnotatedType = isAnnotatedType
+exports.isAnnotatedTypeOfPrimitive = isAnnotatedTypeOfPrimitive

package/dist/utils.d.ts

@@ -0,0 +1,132 @@
+interface TError {
+    path: string;
+    message: string;
+    details?: TError[];
+}
+type TValidatorPlugin = (ctx: TValidatorPluginContext, def: TAtscriptAnnotatedType, value: any) => boolean | undefined;
+interface TValidatorOptions {
+    partial: boolean | 'deep' | ((type: TAtscriptAnnotatedType<TAtscriptTypeObject>, path: string) => boolean);
+    replace?: (type: TAtscriptAnnotatedType, path: string) => TAtscriptAnnotatedType;
+    plugins: TValidatorPlugin[];
+    unknwonProps: 'strip' | 'ignore' | 'error';
+    errorLimit: number;
+    skipList?: Set<string>;
+}
+interface TValidatorPluginContext {
+    opts: Validator<any>['opts'];
+    validateAnnotatedType: Validator<any>['validateAnnotatedType'];
+    error: Validator<any>['error'];
+    path: Validator<any>['path'];
+}
+declare class Validator<T extends TAtscriptAnnotatedTypeConstructor> {
+    protected readonly def: T | TAtscriptAnnotatedType<any>;
+    protected opts: TValidatorOptions;
+    constructor(def: T | TAtscriptAnnotatedType<any>, opts?: Partial<TValidatorOptions>);
+    errors: TError[];
+    protected stackErrors: TError[][];
+    protected stackPath: string[];
+    protected isLimitExceeded(): boolean;
+    protected push(name: string): void;
+    protected pop(saveErrors: boolean): TError[] | undefined;
+    protected clear(): void;
+    protected error(message: string, path?: string, details?: TError[]): void;
+    protected throw(): void;
+    validate<TT = T>(value: any, safe?: boolean): value is TT;
+    protected validateSafe(def: TAtscriptAnnotatedType, value: any): boolean;
+    protected get path(): string;
+    protected validateAnnotatedType(def: TAtscriptAnnotatedType, value: any): boolean;
+    protected validateUnion(def: TAtscriptAnnotatedType<TAtscriptTypeComplex>, value: any): boolean;
+    protected validateIntersection(def: TAtscriptAnnotatedType<TAtscriptTypeComplex>, value: any): boolean;
+    protected validateTuple(def: TAtscriptAnnotatedType<TAtscriptTypeComplex>, value: any): boolean;
+    protected validateArray(def: TAtscriptAnnotatedType<TAtscriptTypeArray>, value: any): boolean;
+    protected validateObject(def: TAtscriptAnnotatedType<TAtscriptTypeObject>, value: any): boolean;
+    protected validatePrimitive(def: TAtscriptAnnotatedType<TAtscriptTypeFinal>, value: any): boolean;
+    protected validateString(def: TAtscriptAnnotatedType<TAtscriptTypeFinal>, value: string): boolean;
+    protected validateNumber(def: TAtscriptAnnotatedType<TAtscriptTypeFinal>, value: number): boolean;
+}
+declare class ValidatorError extends Error {
+    readonly errors: TError[];
+    name: string;
+    constructor(errors: TError[]);
+}
+
+interface TAtscriptTypeComplex {
+    kind: 'union' | 'intersection' | 'tuple';
+    items: TAtscriptAnnotatedType[];
+    tags: Set<AtscriptPrimitiveTags>;
+}
+interface TAtscriptTypeArray {
+    kind: 'array';
+    of: TAtscriptAnnotatedType;
+    tags: Set<AtscriptPrimitiveTags>;
+}
+interface TAtscriptTypeObject<K extends string = string> {
+    kind: 'object';
+    props: Map<K, TAtscriptAnnotatedType>;
+    propsPatterns: {
+        pattern: RegExp;
+        def: TAtscriptAnnotatedType;
+    }[];
+    tags: Set<AtscriptPrimitiveTags>;
+}
+interface TAtscriptTypeFinal {
+    kind: '';
+    /**
+     * design type
+     */
+    designType: 'string' | 'number' | 'boolean' | 'undefined' | 'null' | 'object' | 'any' | 'never';
+    /**
+     * value for literals
+     */
+    value?: string | number | boolean;
+    tags: Set<AtscriptPrimitiveTags>;
+}
+type TAtscriptTypeDef = TAtscriptTypeComplex | TAtscriptTypeFinal | TAtscriptTypeArray | TAtscriptTypeObject<string>;
+interface TAtscriptAnnotatedType<T = TAtscriptTypeDef> {
+    __is_atscript_annotated_type: true;
+    type: T;
+    validator: <TT extends TAtscriptAnnotatedTypeConstructor>(opts?: Partial<TValidatorOptions>) => Validator<TT>;
+    metadata: TMetadataMap<AtscriptMetadata>;
+    optional?: boolean;
+}
+type TAtscriptAnnotatedTypeConstructor = TAtscriptAnnotatedType & (new (...args: any[]) => any);
+/**
+ * Type Guard to check if a type is atscript-annotated
+ */
+declare function isAnnotatedType(type: any): type is TAtscriptAnnotatedType;
+type TKind = '' | 'array' | 'object' | 'union' | 'intersection' | 'tuple';
+declare function defineAnnotatedType(_kind?: TKind, base?: any): TAnnotatedTypeHandle;
+/**
+ * Atscript Metadata Map with typed setters/getters
+ */
+interface TMetadataMap<O extends object> extends Map<keyof O, O[keyof O]> {
+    get<K extends keyof O>(key: K): O[K] | undefined;
+    set<K extends keyof O>(key: K, value: O[K]): this;
+}
+interface TAnnotatedTypeHandle {
+    $type: TAtscriptAnnotatedType;
+    $def: {
+        kind: TKind;
+    } & Omit<TAtscriptTypeComplex, 'kind'> & Omit<TAtscriptTypeFinal, 'kind'> & Omit<TAtscriptTypeArray, 'kind'> & Omit<TAtscriptTypeObject<string>, 'kind'>;
+    $metadata: TMetadataMap<AtscriptMetadata>;
+    _existingObject: TAtscriptAnnotatedType | undefined;
+    tags(...tags: string[]): TAnnotatedTypeHandle;
+    designType(value: TAtscriptTypeFinal['designType']): TAnnotatedTypeHandle;
+    value(value: string | number | boolean): TAnnotatedTypeHandle;
+    of(value: TAtscriptAnnotatedType): TAnnotatedTypeHandle;
+    item(value: TAtscriptAnnotatedType): TAnnotatedTypeHandle;
+    prop(name: string, value: TAtscriptAnnotatedType): TAnnotatedTypeHandle;
+    propPattern(pattern: RegExp, value: TAtscriptAnnotatedType): TAnnotatedTypeHandle;
+    optional(value?: boolean): TAnnotatedTypeHandle;
+    copyMetadata(fromMetadata: TMetadataMap<AtscriptMetadata>): TAnnotatedTypeHandle;
+    refTo(type: TAtscriptAnnotatedType & {
+        name?: string;
+    }, chain?: string[]): TAnnotatedTypeHandle;
+    annotate(key: keyof AtscriptMetadata, value: any, asArray?: boolean): TAnnotatedTypeHandle;
+}
+declare function isAnnotatedTypeOfPrimitive(t: TAtscriptAnnotatedType): boolean;
+
+type TJsonSchema = Record<string, any>;
+declare function buildJsonSchema(type: TAtscriptAnnotatedType): TJsonSchema;
+
+export { type TAnnotatedTypeHandle, type TAtscriptAnnotatedType, type TAtscriptAnnotatedTypeConstructor, type TAtscriptTypeArray, type TAtscriptTypeComplex, type TAtscriptTypeDef, type TAtscriptTypeFinal, type TAtscriptTypeObject, type TMetadataMap, type TValidatorOptions, type TValidatorPlugin, type TValidatorPluginContext, Validator, ValidatorError, buildJsonSchema, defineAnnotatedType, isAnnotatedType, isAnnotatedTypeOfPrimitive };