@atscript/typescript 0.1.3 → 0.1.5

package/dist/cli.cjs

@@ -298,6 +298,10 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 				patterns.push(prop);
 				continue;
 			}
+			if (this.isPhantomProp(prop.getDefinition())) {
+				this.writeln(`// ${prop.id}: phantom`);
+				continue;
+			}
 			const optional = !!prop.token("optional");
 			this.write(wrapProp(prop.id), optional ? "?" : "", ": ");
 			const renderedDef = this.renderTypeDefString(prop.getDefinition());
@@ -401,11 +405,20 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFina
 		this.writeln(`const __is_atscript_annotated_type: true`);
 		this.writeln(`const type: ${typeDef}`);
 		this.writeln(`const metadata: TMetadataMap<AtscriptMetadata>`);
-		this.writeln(`const validator: (opts?: Partial<TValidatorOptions>) => Validator<TAtscriptAnnotatedType, ${name}>`);
+		this.writeln(`const validator: (opts?: Partial<TValidatorOptions>) => Validator<typeof ${name}, ${name}>`);
 		if (resolveJsonSchemaMode(this.opts) === false) this.writeln("/** @deprecated JSON Schema support is disabled. Calling this method will throw a runtime error. To enable, set `jsonSchema: 'lazy'` or `jsonSchema: 'bundle'` in tsPlugin options, or add `@emit.jsonSchema` annotation to individual interfaces. */");
 		this.writeln("const toJsonSchema: () => any");
 		this.popln();
 	}
+	isPhantomProp(def) {
+		if (!def) return false;
+		if ((0, __atscript_core.isPrimitive)(def) && def.id === "phantom") return true;
+		if ((0, __atscript_core.isRef)(def)) {
+			const unwound = this.doc.unwindType(def.id, def.chain)?.def;
+			return (0, __atscript_core.isPrimitive)(unwound) && unwound.id === "phantom";
+		}
+		return false;
+	}
 	isTypeTarget(name, doc) {
 		const d = doc || this.doc;
 		const decl = d.getDeclarationOwnerNode(name);
@@ -448,7 +461,11 @@ function renderPrimitiveTypeDef(def) {
 //#region packages/typescript/src/traverse.ts
 function forAnnotatedType(def, handlers) {
 	switch (def.type.kind) {
-		case "": return handlers.final(def);
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
 		case "object": return handlers.object(def);
 		case "array": return handlers.array(def);
 		case "union": return handlers.union(def);
@@ -542,6 +559,7 @@ var Validator = class {
 	validateAnnotatedType(def, value) {
 		return forAnnotatedType(def, {
 			final: (d) => this.validatePrimitive(d, value),
+			phantom: () => true,
 			object: (d) => this.validateObject(d, value),
 			array: (d) => this.validateArray(d, value),
 			union: (d) => this.validateUnion(d, value),
@@ -638,7 +656,7 @@ var Validator = class {
 		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;
+			if (skipList.has(key) || isPhantomType(item)) continue;
 			typeKeys.add(key);
 			if (value[key] === undefined) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
@@ -920,6 +938,9 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 	};
 	return handle;
 }
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
 
 //#endregion
 //#region packages/typescript/src/json-schema.ts
@@ -927,10 +948,14 @@ function buildJsonSchema(type) {
 	const build$1 = (def) => {
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
+			phantom() {
+				return {};
+			},
 			object(d) {
 				const properties = {};
 				const required = [];
 				for (const [key, val] of d.type.props.entries()) {
+					if (isPhantomType(val)) continue;
 					properties[key] = build$1(val);
 					if (!val.optional) required.push(key);
 				}

package/dist/index.cjs

@@ -295,6 +295,10 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 				patterns.push(prop);
 				continue;
 			}
+			if (this.isPhantomProp(prop.getDefinition())) {
+				this.writeln(`// ${prop.id}: phantom`);
+				continue;
+			}
 			const optional = !!prop.token("optional");
 			this.write(wrapProp(prop.id), optional ? "?" : "", ": ");
 			const renderedDef = this.renderTypeDefString(prop.getDefinition());
@@ -398,11 +402,20 @@ else if ((0, __atscript_core.isPrimitive)(realDef)) typeDef = `TAtscriptTypeFina
 		this.writeln(`const __is_atscript_annotated_type: true`);
 		this.writeln(`const type: ${typeDef}`);
 		this.writeln(`const metadata: TMetadataMap<AtscriptMetadata>`);
-		this.writeln(`const validator: (opts?: Partial<TValidatorOptions>) => Validator<TAtscriptAnnotatedType, ${name}>`);
+		this.writeln(`const validator: (opts?: Partial<TValidatorOptions>) => Validator<typeof ${name}, ${name}>`);
 		if (resolveJsonSchemaMode(this.opts) === false) this.writeln("/** @deprecated JSON Schema support is disabled. Calling this method will throw a runtime error. To enable, set `jsonSchema: 'lazy'` or `jsonSchema: 'bundle'` in tsPlugin options, or add `@emit.jsonSchema` annotation to individual interfaces. */");
 		this.writeln("const toJsonSchema: () => any");
 		this.popln();
 	}
+	isPhantomProp(def) {
+		if (!def) return false;
+		if ((0, __atscript_core.isPrimitive)(def) && def.id === "phantom") return true;
+		if ((0, __atscript_core.isRef)(def)) {
+			const unwound = this.doc.unwindType(def.id, def.chain)?.def;
+			return (0, __atscript_core.isPrimitive)(unwound) && unwound.id === "phantom";
+		}
+		return false;
+	}
 	isTypeTarget(name, doc) {
 		const d = doc || this.doc;
 		const decl = d.getDeclarationOwnerNode(name);
@@ -445,7 +458,11 @@ function renderPrimitiveTypeDef(def) {
 //#region packages/typescript/src/traverse.ts
 function forAnnotatedType(def, handlers) {
 	switch (def.type.kind) {
-		case "": return handlers.final(def);
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
 		case "object": return handlers.object(def);
 		case "array": return handlers.array(def);
 		case "union": return handlers.union(def);
@@ -539,6 +556,7 @@ var Validator = class {
 	validateAnnotatedType(def, value) {
 		return forAnnotatedType(def, {
 			final: (d) => this.validatePrimitive(d, value),
+			phantom: () => true,
 			object: (d) => this.validateObject(d, value),
 			array: (d) => this.validateArray(d, value),
 			union: (d) => this.validateUnion(d, value),
@@ -635,7 +653,7 @@ var Validator = class {
 		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;
+			if (skipList.has(key) || isPhantomType(item)) continue;
 			typeKeys.add(key);
 			if (value[key] === undefined) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
@@ -917,6 +935,9 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 	};
 	return handle;
 }
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
 
 //#endregion
 //#region packages/typescript/src/json-schema.ts
@@ -924,10 +945,14 @@ function buildJsonSchema(type) {
 	const build = (def) => {
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
+			phantom() {
+				return {};
+			},
 			object(d) {
 				const properties = {};
 				const required = [];
 				for (const [key, val] of d.type.props.entries()) {
+					if (isPhantomType(val)) continue;
 					properties[key] = build(val);
 					if (!val.optional) required.push(key);
 				}

package/dist/index.mjs

@@ -271,6 +271,10 @@ var TypeRenderer = class TypeRenderer extends BaseRenderer {
 				patterns.push(prop);
 				continue;
 			}
+			if (this.isPhantomProp(prop.getDefinition())) {
+				this.writeln(`// ${prop.id}: phantom`);
+				continue;
+			}
 			const optional = !!prop.token("optional");
 			this.write(wrapProp(prop.id), optional ? "?" : "", ": ");
 			const renderedDef = this.renderTypeDefString(prop.getDefinition());
@@ -374,11 +378,20 @@ else if (isPrimitive(realDef)) typeDef = `TAtscriptTypeFinal<${name}>`;
 		this.writeln(`const __is_atscript_annotated_type: true`);
 		this.writeln(`const type: ${typeDef}`);
 		this.writeln(`const metadata: TMetadataMap<AtscriptMetadata>`);
-		this.writeln(`const validator: (opts?: Partial<TValidatorOptions>) => Validator<TAtscriptAnnotatedType, ${name}>`);
+		this.writeln(`const validator: (opts?: Partial<TValidatorOptions>) => Validator<typeof ${name}, ${name}>`);
 		if (resolveJsonSchemaMode(this.opts) === false) this.writeln("/** @deprecated JSON Schema support is disabled. Calling this method will throw a runtime error. To enable, set `jsonSchema: 'lazy'` or `jsonSchema: 'bundle'` in tsPlugin options, or add `@emit.jsonSchema` annotation to individual interfaces. */");
 		this.writeln("const toJsonSchema: () => any");
 		this.popln();
 	}
+	isPhantomProp(def) {
+		if (!def) return false;
+		if (isPrimitive(def) && def.id === "phantom") return true;
+		if (isRef(def)) {
+			const unwound = this.doc.unwindType(def.id, def.chain)?.def;
+			return isPrimitive(unwound) && unwound.id === "phantom";
+		}
+		return false;
+	}
 	isTypeTarget(name, doc) {
 		const d = doc || this.doc;
 		const decl = d.getDeclarationOwnerNode(name);
@@ -421,7 +434,11 @@ function renderPrimitiveTypeDef(def) {
 //#region packages/typescript/src/traverse.ts
 function forAnnotatedType(def, handlers) {
 	switch (def.type.kind) {
-		case "": return handlers.final(def);
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
 		case "object": return handlers.object(def);
 		case "array": return handlers.array(def);
 		case "union": return handlers.union(def);
@@ -515,6 +532,7 @@ var Validator = class {
 	validateAnnotatedType(def, value) {
 		return forAnnotatedType(def, {
 			final: (d) => this.validatePrimitive(d, value),
+			phantom: () => true,
 			object: (d) => this.validateObject(d, value),
 			array: (d) => this.validateArray(d, value),
 			union: (d) => this.validateUnion(d, value),
@@ -611,7 +629,7 @@ var Validator = class {
 		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;
+			if (skipList.has(key) || isPhantomType(item)) continue;
 			typeKeys.add(key);
 			if (value[key] === undefined) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
@@ -893,6 +911,9 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 	};
 	return handle;
 }
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
 
 //#endregion
 //#region packages/typescript/src/json-schema.ts
@@ -900,10 +921,14 @@ function buildJsonSchema(type) {
 	const build = (def) => {
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
+			phantom() {
+				return {};
+			},
 			object(d) {
 				const properties = {};
 				const required = [];
 				for (const [key, val] of d.type.props.entries()) {
+					if (isPhantomType(val)) continue;
 					properties[key] = build(val);
 					if (!val.optional) required.push(key);
 				}

package/dist/utils.cjs

@@ -3,7 +3,11 @@
 //#region packages/typescript/src/traverse.ts
 function forAnnotatedType(def, handlers) {
 	switch (def.type.kind) {
-		case "": return handlers.final(def);
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
 		case "object": return handlers.object(def);
 		case "array": return handlers.array(def);
 		case "union": return handlers.union(def);
@@ -97,6 +101,7 @@ var Validator = class {
 	validateAnnotatedType(def, value) {
 		return forAnnotatedType(def, {
 			final: (d) => this.validatePrimitive(d, value),
+			phantom: () => true,
 			object: (d) => this.validateObject(d, value),
 			array: (d) => this.validateArray(d, value),
 			union: (d) => this.validateUnion(d, value),
@@ -193,7 +198,7 @@ var Validator = class {
 		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;
+			if (skipList.has(key) || isPhantomType(item)) continue;
 			typeKeys.add(key);
 			if (value[key] === undefined) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
@@ -475,6 +480,9 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 	};
 	return handle;
 }
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
 function isAnnotatedTypeOfPrimitive(t) {
 	if (["array", "object"].includes(t.type.kind)) return false;
 	if (!t.type.kind) return true;
@@ -495,10 +503,14 @@ function buildJsonSchema(type) {
 	const build = (def) => {
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
+			phantom() {
+				return {};
+			},
 			object(d) {
 				const properties = {};
 				const required = [];
 				for (const [key, val] of d.type.props.entries()) {
+					if (isPhantomType(val)) continue;
 					properties[key] = build(val);
 					if (!val.optional) required.push(key);
 				}
@@ -671,6 +683,13 @@ function serializeNode(def, path, options) {
 }
 function serializeTypeDef(def, path, options) {
 	return forAnnotatedType(def, {
+		phantom(d) {
+			return {
+				kind: "",
+				designType: d.type.designType,
+				tags: Array.from(d.type.tags)
+			};
+		},
 		final(d) {
 			const result = {
 				kind: "",
@@ -682,7 +701,10 @@ function serializeTypeDef(def, path, options) {
 		},
 		object(d) {
 			const props = {};
-			for (const [key, val] of d.type.props.entries()) props[key] = serializeNode(val, [...path, key], options);
+			for (const [key, val] of d.type.props.entries()) {
+				if (isPhantomType(val)) continue;
+				props[key] = serializeNode(val, [...path, key], options);
+			}
 			const propsPatterns = d.type.propsPatterns.map((pp) => ({
 				pattern: {
 					source: pp.pattern.source,
@@ -819,4 +841,5 @@ exports.forAnnotatedType = forAnnotatedType
 exports.fromJsonSchema = fromJsonSchema
 exports.isAnnotatedType = isAnnotatedType
 exports.isAnnotatedTypeOfPrimitive = isAnnotatedTypeOfPrimitive
+exports.isPhantomType = isPhantomType
 exports.serializeAnnotatedType = serializeAnnotatedType

package/dist/utils.d.ts

@@ -130,7 +130,7 @@ interface TAtscriptTypeFinal<DataType = unknown> {
     /**
      * design type
      */
-    designType: 'string' | 'number' | 'boolean' | 'undefined' | 'null' | 'object' | 'any' | 'never';
+    designType: 'string' | 'number' | 'boolean' | 'undefined' | 'null' | 'object' | 'any' | 'never' | 'phantom';
     /**
      * value for literals
      */
@@ -156,10 +156,10 @@ type TAtscriptTypeDef<DataType = unknown> = TAtscriptTypeComplex<DataType> | TAt
  * @typeParam T - The underlying type definition (e.g. {@link TAtscriptTypeObject}).
  * @typeParam DataType - The TypeScript type the validated data narrows to (auto-inferred from `T`).
  */
-interface TAtscriptAnnotatedType<T = TAtscriptTypeDef, DataType = InferDataType<T>> {
+interface TAtscriptAnnotatedType<T extends TAtscriptTypeDef = TAtscriptTypeDef, DataType = InferDataType<T>> {
     __is_atscript_annotated_type: true;
     type: T;
-    validator: (opts?: Partial<TValidatorOptions>) => Validator;
+    validator(opts?: Partial<TValidatorOptions>): Validator<this, DataType>;
     metadata: TMetadataMap<AtscriptMetadata>;
     optional?: boolean;
 }
@@ -224,6 +224,13 @@ interface TAnnotatedTypeHandle {
     }, chain?: string[]): TAnnotatedTypeHandle;
     annotate(key: keyof AtscriptMetadata, value: any, asArray?: boolean): TAnnotatedTypeHandle;
 }
+/**
+ * Checks whether an annotated type is a phantom type.
+ *
+ * Phantom types do not affect the data type, validation, or schema,
+ * but are discoverable via runtime type traversal.
+ */
+declare function isPhantomType(def: TAtscriptAnnotatedType): boolean;
 /**
  * Checks whether an annotated type resolves to a primitive (non-object, non-array) shape.
  *
@@ -280,6 +287,10 @@ declare function fromJsonSchema(schema: TJsonSchema): TAtscriptAnnotatedType;
  * Provides the common `switch (def.type.kind)` pattern used by
  * the validator, JSON-schema builder, and serializer.
  * Each caller supplies its own handlers that control recursion.
+ *
+ * When a `phantom` handler is provided, phantom types (`designType === 'phantom'`)
+ * are dispatched to it instead of `final`. This allows consumers to skip or
+ * handle phantom props without polluting their `final` handler.
  */
 declare function forAnnotatedType<R>(def: TAtscriptAnnotatedType, handlers: {
     final: (def: TAtscriptAnnotatedType<TAtscriptTypeFinal>) => R;
@@ -288,6 +299,7 @@ declare function forAnnotatedType<R>(def: TAtscriptAnnotatedType, handlers: {
     union: (def: TAtscriptAnnotatedType<TAtscriptTypeComplex>) => R;
     intersection: (def: TAtscriptAnnotatedType<TAtscriptTypeComplex>) => R;
     tuple: (def: TAtscriptAnnotatedType<TAtscriptTypeComplex>) => R;
+    phantom?: (def: TAtscriptAnnotatedType<TAtscriptTypeFinal>) => R;
 }): R;
 
 /** Current serialization format version. Bumped on breaking changes to the serialized shape. */
@@ -396,5 +408,5 @@ declare function serializeAnnotatedType(type: TAtscriptAnnotatedType, options?:
  */
 declare function deserializeAnnotatedType(data: TSerializedAnnotatedType): TAtscriptAnnotatedType;
 
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, serializeAnnotatedType };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType };
 export type { InferDataType, TAnnotatedTypeHandle, TAtscriptAnnotatedType, TAtscriptAnnotatedTypeConstructor, TAtscriptTypeArray, TAtscriptTypeComplex, TAtscriptTypeDef, TAtscriptTypeFinal, TAtscriptTypeObject, TMetadataMap, TProcessAnnotationContext, TSerializeOptions, TSerializedAnnotatedType, TSerializedAnnotatedTypeInner, TSerializedTypeArray, TSerializedTypeComplex, TSerializedTypeDef, TSerializedTypeFinal, TSerializedTypeObject, TValidatorOptions, TValidatorPlugin, TValidatorPluginContext };

package/dist/utils.mjs

@@ -2,7 +2,11 @@
 //#region packages/typescript/src/traverse.ts
 function forAnnotatedType(def, handlers) {
 	switch (def.type.kind) {
-		case "": return handlers.final(def);
+		case "": {
+			const typed = def;
+			if (handlers.phantom && typed.type.designType === "phantom") return handlers.phantom(typed);
+			return handlers.final(typed);
+		}
 		case "object": return handlers.object(def);
 		case "array": return handlers.array(def);
 		case "union": return handlers.union(def);
@@ -96,6 +100,7 @@ var Validator = class {
 	validateAnnotatedType(def, value) {
 		return forAnnotatedType(def, {
 			final: (d) => this.validatePrimitive(d, value),
+			phantom: () => true,
 			object: (d) => this.validateObject(d, value),
 			array: (d) => this.validateArray(d, value),
 			union: (d) => this.validateUnion(d, value),
@@ -192,7 +197,7 @@ var Validator = class {
 		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;
+			if (skipList.has(key) || isPhantomType(item)) continue;
 			typeKeys.add(key);
 			if (value[key] === undefined) {
 				if (partialFunctionMatched || this.opts.partial === "deep" || this.opts.partial === true && this.stackPath.length <= 1) continue;
@@ -474,6 +479,9 @@ else if (!newBase) throw new Error(`"${typeName}" is not annotated type`);
 	};
 	return handle;
 }
+function isPhantomType(def) {
+	return def.type.kind === "" && def.type.designType === "phantom";
+}
 function isAnnotatedTypeOfPrimitive(t) {
 	if (["array", "object"].includes(t.type.kind)) return false;
 	if (!t.type.kind) return true;
@@ -494,10 +502,14 @@ function buildJsonSchema(type) {
 	const build = (def) => {
 		const meta = def.metadata;
 		return forAnnotatedType(def, {
+			phantom() {
+				return {};
+			},
 			object(d) {
 				const properties = {};
 				const required = [];
 				for (const [key, val] of d.type.props.entries()) {
+					if (isPhantomType(val)) continue;
 					properties[key] = build(val);
 					if (!val.optional) required.push(key);
 				}
@@ -670,6 +682,13 @@ function serializeNode(def, path, options) {
 }
 function serializeTypeDef(def, path, options) {
 	return forAnnotatedType(def, {
+		phantom(d) {
+			return {
+				kind: "",
+				designType: d.type.designType,
+				tags: Array.from(d.type.tags)
+			};
+		},
 		final(d) {
 			const result = {
 				kind: "",
@@ -681,7 +700,10 @@ function serializeTypeDef(def, path, options) {
 		},
 		object(d) {
 			const props = {};
-			for (const [key, val] of d.type.props.entries()) props[key] = serializeNode(val, [...path, key], options);
+			for (const [key, val] of d.type.props.entries()) {
+				if (isPhantomType(val)) continue;
+				props[key] = serializeNode(val, [...path, key], options);
+			}
 			const propsPatterns = d.type.propsPatterns.map((pp) => ({
 				pattern: {
 					source: pp.pattern.source,
@@ -807,4 +829,4 @@ function deserializeTypeDef(t) {
 }
 
 //#endregion
-export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, serializeAnnotatedType };
+export { SERIALIZE_VERSION, Validator, ValidatorError, annotate, buildJsonSchema, defineAnnotatedType, deserializeAnnotatedType, forAnnotatedType, fromJsonSchema, isAnnotatedType, isAnnotatedTypeOfPrimitive, isPhantomType, serializeAnnotatedType };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/typescript",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Atscript: typescript-gen support.",
   "type": "module",
   "main": "dist/index.mjs",
@@ -70,7 +70,7 @@
   "homepage": "https://github.com/moostjs/atscript/tree/main/packages/typescript#readme",
   "license": "ISC",
   "peerDependencies": {
-    "@atscript/core": "^0.1.3"
+    "@atscript/core": "^0.1.5"
   },
   "dependencies": {
     "@moostjs/event-cli": "^0.5.32",