@powerlines/deepkit 0.4.90 → 0.4.92

package/dist/vendor/type.d.ts

@@ -1 +1,3425 @@
-export * from '@deepkit/type';
+export type NumberFields<T> = {
+	[K in keyof T]: T[K] extends number | bigint ? K : never;
+}[keyof T];
+export type Expression<T> = {
+	[P in keyof T & string]?: string;
+};
+type Partial$1<T> = {
+	[P in keyof T & string]?: T[P];
+};
+export type DeepPartial<T> = {
+	[P in keyof T]?: T[P];
+} & {
+	[deepPath: string]: any;
+};
+export interface ChangesInterface<T> {
+	$set?: DeepPartial<T> | T;
+	$unset?: {
+		[path: string]: number;
+	};
+	$inc?: Partial$1<Pick<T, NumberFields<T>>>;
+}
+export declare class Changes<T extends object> {
+	$set?: DeepPartial<T> | T;
+	$unset?: {
+		[path: string]: number;
+	};
+	$inc?: Partial$1<Pick<T, NumberFields<T>>>;
+	empty: boolean;
+	fieldNames: string[];
+	constructor(changes?: ChangesInterface<T>);
+	clear(): void;
+	getReturning(): string[];
+	protected detectEmpty(): void;
+	replaceSet($set: DeepPartial<T> | T): void;
+	mergeSet($set: Partial$1<T> | T): void;
+	increase(property: NumberFields<T>, increase?: number): void;
+	set(property: keyof T & string, value: any): void;
+	unset(property: keyof T & string, unset?: boolean): void;
+	has(name: keyof T & string): boolean;
+}
+export declare class ItemChanges<T extends object> extends Changes<T> {
+	protected item: T;
+	constructor(changes: ChangesInterface<T> | undefined, item: T);
+	increase(property: NumberFields<T>, increase?: number): void;
+	set(property: keyof T & string, value: any): void;
+	unset(property: keyof T & string, unset?: boolean): void;
+}
+export declare const changeSetSymbol: unique symbol;
+export declare class AtomicChangeInstance<T extends object> {
+	protected object: any;
+	readonly changeSet: Changes<T>;
+	constructor(object: any);
+	increase(property: NumberFields<T>, increase?: number): void;
+}
+export declare function atomicChange<T extends object>(object: T): AtomicChangeInstance<T>;
+export declare type __ΩNumberFields = any[];
+export declare type __ΩExpression = any[];
+export declare type __ΩPartial = any[];
+export declare type __ΩDeepPartial = any[];
+export declare type __ΩChangesInterface = any[];
+declare class CustomError extends Error {
+	name: string;
+	constructor(...args: any[]);
+}
+interface CustomError {
+	cause?: unknown;
+}
+interface ClassType<T = any> {
+	new (...args: any[]): T;
+}
+type AbstractClassType<T = any> = abstract new (...args: any[]) => T;
+type ExtractClassType<T> = T extends AbstractClassType<infer K> ? K : never;
+declare class CompilerContext {
+	readonly context: Map<string, any>;
+	protected constVariables: Map<any, string>;
+	maxReservedVariable: number;
+	protected reservedNames: Set<string>;
+	protected variableContext: {
+		[name: string]: any;
+	};
+	/**
+	 * Code that is executed in the context, but before the actual function is generated.
+	 * This helps for example to initialize dynamically some context variables.
+	 */
+	preCode: string;
+	initialiseVariables: string[];
+	config: {
+		indent: boolean;
+	};
+	constructor(config?: Partial<CompilerContext["config"]>);
+	reserveName(name: string): string;
+	set(values: {
+		[name: string]: any;
+	}): void;
+	/**
+	 * Returns always the same variable name for the same value.
+	 * The variable name should not be set afterwards.
+	 */
+	reserveConst(value: any, name?: string): string;
+	reserveVariable(name?: string, value?: any): string;
+	raw(functionCode: string): Function;
+	protected format(code: string): string;
+	build(functionCode: string, ...args: string[]): any;
+	buildAsync(functionCode: string, ...args: string[]): Function;
+}
+type TypeAnnotation<T extends string, Options = never> = unknown;
+/**
+ * note: Checks are based on range checks (>, <, etc), so when adding
+ * new types a check is required for all code using `TypeNumberBrand`.
+ */
+export declare enum TypeNumberBrand {
+	integer = 0,
+	int8 = 1,
+	int16 = 2,
+	int32 = 3,
+	uint8 = 4,
+	uint16 = 5,
+	uint32 = 6,
+	float = 7,
+	float32 = 8,
+	float64 = 9
+}
+declare enum ReflectionOp {
+	never = 0,
+	any = 1,
+	unknown = 2,
+	void = 3,
+	object = 4,
+	string = 5,
+	number = 6,
+	numberBrand = 7,
+	boolean = 8,
+	bigint = 9,
+	symbol = 10,
+	null = 11,
+	undefined = 12,
+	/**
+	 * The literal type of string, number, or boolean.
+	 *
+	 * This OP has 1 parameter. The next byte is the absolute address of the literal on the stack, which is the actual literal value.
+	 *
+	 * Pushes a function type.
+	 */
+	literal = 13,
+	/**
+	 * This OP pops all types on the current stack frame.
+	 *
+	 * This OP has 1 parameter. The next byte is the absolute address of a string|number|symbol entry on the stack.
+	 *
+	 * Pushes a function type.
+	 */
+	function = 14,
+	/**
+	 * This OP pops all types on the current stack frame.
+	 *
+	 * Pushes a method type.
+	 */
+	method = 15,
+	methodSignature = 16,//has 1 parameter, reference to stack for its property name
+	parameter = 17,
+	/**
+	 * This OP pops the latest type entry on the stack.
+	 *
+	 * Pushes a property type.
+	 */
+	property = 18,
+	propertySignature = 19,//has 1 parameter, reference to stack for its property name
+	/**
+	 * This OP pops all types on the current stack frame. Those types should be method|property.
+	 *
+	 * Pushes a TypeClass onto the stack.
+	 */
+	class = 20,
+	/**
+	 * If a class extends another class with generics, this OP represents the generic type arguments of the super class.
+	 *
+	 * e.g. `class A extends B<string, boolean>`, string and boolean are on the stack and classExtends pops() them, and then assigns to A.extendsTypeArguments = [string, boolean].
+	 *
+	 * This is only emitted when the class that is currently being described actually extends another class and uses generics.
+	 *
+	 * This OP has 1 argument and pops x types from the stack. X is the first argument.
+	 * Expects a TypeClass on the stack.
+	 */
+	classExtends = 21,
+	/**
+	 * This OP has 1 parameter, the stack entry to the actual class symbol.
+	 */
+	classReference = 22,
+	/**
+	 * Marks the last entry in the stack as optional. Used for method|property. Equal to the QuestionMark operator in a property assignment.
+	 */
+	optional = 23,
+	readonly = 24,
+	public = 25,
+	private = 26,
+	protected = 27,
+	abstract = 28,
+	defaultValue = 29,
+	description = 30,
+	rest = 31,
+	regexp = 32,
+	enum = 33,
+	enumMember = 34,//has one argument, the name.
+	set = 35,
+	map = 36,
+	/**
+	 * Pops the latest stack entry and uses it as T for an array type.
+	 *
+	 * Pushes an array type.
+	 */
+	array = 37,
+	tuple = 38,
+	tupleMember = 39,
+	namedTupleMember = 40,//has one argument, the name.
+	union = 41,//pops frame. requires frame start when stack can be dirty.
+	intersection = 42,
+	indexSignature = 43,
+	objectLiteral = 44,
+	mappedType = 45,//2 parameters: functionPointer and modifier.
+	in = 46,
+	frame = 47,//creates a new stack frame
+	moveFrame = 48,//pop() as T, pops the current stack frame, push(T)
+	return = 49,
+	templateLiteral = 50,
+	date = 51,
+	int8Array = 52,
+	uint8ClampedArray = 53,
+	uint8Array = 54,
+	int16Array = 55,
+	uint16Array = 56,
+	int32Array = 57,
+	uint32Array = 58,
+	float32Array = 59,
+	float64Array = 60,
+	bigInt64Array = 61,
+	arrayBuffer = 62,
+	promise = 63,
+	arg = 64,//@deprecated. parameter is a number referencing an entry in the stack, relative to the beginning of the current frame, *-1. pushes that entry onto the stack. this is related to the calling convention.
+	typeParameter = 65,//generic type parameter, e.g. T in a generic. has 1 parameter: reference to the name.
+	typeParameterDefault = 66,//generic type parameter with a default value, e.g. T in a generic. has 1 parameter: reference to the name. pop() for the default value
+	var = 67,//reserve a new variable in the stack
+	loads = 68,//pushes to the stack a referenced value in the stack. has 2 parameters: <frame> <index>, frame is a negative offset to the frame, and index the index of the stack entry withing the referenced frame
+	indexAccess = 69,//T['string'], 2 items on the stack
+	keyof = 70,//keyof operator
+	infer = 71,//2 params, like `loads`
+	typeof = 72,//1 parameter that points to a function returning the runtime value from which we need to extract the type
+	condition = 73,
+	jumpCondition = 74,//@deprecated. used when INFER is used in `extends` conditional branch. 2 args: left program, right program
+	jump = 75,//jump to an address
+	call = 76,//has one parameter, the next program address. creates a new stack frame with current program address as first stack entry, and jumps back to that + 1.
+	inline = 77,
+	inlineCall = 78,
+	distribute = 79,//has one parameter, the co-routine program index.
+	extends = 80,//X extends Y in a conditional type, XY popped from the stack, pushes boolean on the stack
+	widen = 81,//widens the type on the stack, .e.g 'asd' => string, 34 => number, etc. this is necessary for infer runtime data, and widen if necessary (object member or non-contained literal)
+	static = 82,
+	mappedType2 = 83,//same as mappedType2 but the given functionPointer returns a tuple [type, name]
+	functionReference = 84,//Same as classReference but for functions
+	callSignature = 85,//Same as function but for call signatures (in object literals)
+	/**
+	 * Assign for Enum, Interface, Class, and TypeAlias declaration at the very end
+	 * of the program the typeName. This is so that we have type names available even
+	 * if the JS code is minified.
+	 *
+	 * his operator also assigns originTypes to the type, as it acts as the finalization
+	 * step of a type.
+	 */
+	typeName = 86,//has one parameter, the index of the stack entry that contains the type name. Uses current head of the stack as type and assigns typeName to it.
+	/**
+	 * If a class implement an interface or type,
+	 *
+	 * e.g. `class A implements B`, then B is on the stack and implements pops() it, and then assigns to A.implements = [B].
+	 *
+	 * This is only emitted when the class that is currently being described actually implements something.
+	 *
+	 * This OP has 1 argument and pops x types from the stack. X is the first argument.
+	 * Expects a TypeClass on the stack.
+	 */
+	implements = 87,//pops one type from the stack and assigns it to the latest class on the stack as `implements` type.
+	nominal = 88,//marks the last type on the stack as nominal. (used at the end of class/interface/type alias programs).
+	/**
+	 * Custom Storm Software operators
+	 */
+	tags = 89
+}
+export declare enum ReflectionVisibility {
+	public = 0,
+	protected = 1,
+	private = 2
+}
+export declare enum ReflectionKind {
+	never = 0,
+	any = 1,
+	unknown = 2,
+	void = 3,
+	object = 4,
+	string = 5,
+	number = 6,
+	boolean = 7,
+	symbol = 8,
+	bigint = 9,
+	null = 10,
+	undefined = 11,
+	regexp = 12,
+	literal = 13,
+	templateLiteral = 14,
+	property = 15,
+	method = 16,
+	function = 17,
+	parameter = 18,
+	promise = 19,
+	/**
+	 * Uint8Array, Date, custom classes, Set, Map, etc
+	 */
+	class = 20,
+	typeParameter = 21,
+	enum = 22,
+	union = 23,
+	intersection = 24,
+	array = 25,
+	tuple = 26,
+	tupleMember = 27,
+	enumMember = 28,
+	rest = 29,
+	objectLiteral = 30,
+	indexSignature = 31,
+	propertySignature = 32,
+	methodSignature = 33,
+	infer = 34,
+	callSignature = 35
+}
+export type TypeDecorator = (annotations: Annotations, decorator: TypeObjectLiteral) => boolean;
+export type Annotations = any;
+/**
+ * @reflection never
+ */
+export interface TypeAnnotations {
+	id?: number;
+	origin?: Type;
+	/**
+	 * True when this type comes from an inline type, e.g.
+	 *
+	 * `type A = T;`. Type of `T` is inlined.
+	 * `type A = {}`. Type of `{}` is not inlined.
+	 *
+	 * If the type is not inlined and the result of a type function, then we assign parents of members accordingly. This is not the caee when a type was inlined.
+	 */
+	inlined?: true;
+	/**
+	 * If the type was created by a type function, this contains the alias name.
+	 */
+	typeName?: string;
+	/**
+	 * If the type was created by a type function, this contains the arguments passed the function.
+	 */
+	typeArguments?: Type[];
+	/**
+	 * Set for index access expressions, e.g. Config['property'].
+	 */
+	indexAccessOrigin?: {
+		container: TypeClass | TypeObjectLiteral;
+		index: Type;
+	};
+	/**
+	 * type User = {id: number, user: string};
+	 * type UserCreate = Pick<User, 'user'>;
+	 * typeOf<UserCreate>().originTypes[0].typeName = 'Pick'
+	 * typeOf<UserCreate>().originTypes[0].typeArguments = [User, 'user']
+	 */
+	originTypes?: {
+		typeName: string;
+		typeArguments?: Type[];
+	}[];
+	annotations?: Annotations;
+	decorators?: Type[];
+	scheduleDecorators?: TypeObjectLiteral[];
+	/**
+	 * A place where arbitrary jit functions and its cache data is stored.
+	 */
+	jit?: JitContainer;
+}
+export declare function applyScheduledAnnotations(type: Type): void;
+export declare function hasTypeInformation(object: ClassType | Function): boolean;
+/**
+ * Object to hold runtime jit data.
+ */
+export type JitContainer = any;
+export declare function getTypeJitContainer(type: Type): JitContainer;
+export declare function clearTypeJitContainer(type: Type): void;
+export interface TagsReflection {
+	hidden?: boolean;
+	ignore?: boolean;
+	internal?: boolean;
+	alias?: string[];
+	title?: string;
+	readonly?: boolean;
+	permission?: string[];
+	domain?: string;
+}
+export interface TypeNever extends TypeAnnotations {
+	kind: ReflectionKind.never;
+	parent?: Type;
+}
+export interface TypeAny extends TypeAnnotations {
+	kind: ReflectionKind.any;
+	parent?: Type;
+}
+export interface TypeUnknown extends TypeAnnotations {
+	kind: ReflectionKind.unknown;
+	parent?: Type;
+}
+export interface TypeVoid extends TypeAnnotations {
+	kind: ReflectionKind.void;
+	parent?: Type;
+}
+export interface TypeObject extends TypeAnnotations {
+	kind: ReflectionKind.object;
+	parent?: Type;
+}
+export interface TypeString extends TypeAnnotations {
+	kind: ReflectionKind.string;
+	parent?: Type;
+}
+export declare function isIntegerType(type: Type): type is TypeNumber;
+export interface TypeNumber extends TypeAnnotations {
+	kind: ReflectionKind.number;
+	brand?: TypeNumberBrand;
+	parent?: Type;
+}
+export interface TypeBoolean extends TypeAnnotations {
+	kind: ReflectionKind.boolean;
+	parent?: Type;
+}
+export interface TypeBigInt extends TypeAnnotations {
+	kind: ReflectionKind.bigint;
+	parent?: Type;
+}
+export interface TypeSymbol extends TypeAnnotations {
+	kind: ReflectionKind.symbol;
+	parent?: Type;
+}
+export interface TypeNull extends TypeAnnotations {
+	kind: ReflectionKind.null;
+	parent?: Type;
+}
+export interface TypeUndefined extends TypeAnnotations {
+	kind: ReflectionKind.undefined;
+	parent?: Type;
+}
+export interface TypeLiteral extends TypeAnnotations {
+	kind: ReflectionKind.literal;
+	literal: symbol | string | number | boolean | bigint | RegExp;
+	parent?: Type;
+}
+export interface TypeTemplateLiteral extends TypeAnnotations {
+	kind: ReflectionKind.templateLiteral;
+	types: (TypeString | TypeAny | TypeNumber | TypeLiteral | TypeInfer)[];
+	parent?: Type;
+}
+export interface TypeRegexp extends TypeAnnotations {
+	kind: ReflectionKind.regexp;
+	parent?: Type;
+}
+export interface TypeBaseMember extends TypeAnnotations {
+	visibility: ReflectionVisibility;
+	abstract?: true;
+	static?: true;
+	optional?: true;
+	readonly?: true;
+	tags?: TagsReflection;
+}
+export interface TypeParameter extends TypeAnnotations {
+	kind: ReflectionKind.parameter;
+	name: string;
+	type: Type;
+	parent: TypeFunction | TypeMethod | TypeMethodSignature | TypeCallSignature;
+	visibility?: ReflectionVisibility;
+	readonly?: true;
+	optional?: true;
+	description?: string;
+	/**
+	 * Set when the parameter has a default value aka initializer.
+	 */
+	default?: (() => any) | any;
+	tags?: TagsReflection;
+}
+export interface TypeMethod extends TypeBaseMember {
+	kind: ReflectionKind.method;
+	parent: TypeClass;
+	name: number | string | symbol;
+	description?: string;
+	parameters: TypeParameter[];
+	return: Type;
+}
+export interface TypeProperty extends TypeBaseMember {
+	kind: ReflectionKind.property;
+	parent: TypeClass;
+	visibility: ReflectionVisibility;
+	name: number | string | symbol;
+	description?: string;
+	type: Type;
+	/**
+	 * Set when the property has a default value aka initializer.
+	 */
+	default?: (() => any) | any;
+}
+export interface TypeFunction extends TypeAnnotations {
+	kind: ReflectionKind.function;
+	parent?: Type;
+	name?: number | string | symbol;
+	description?: string;
+	function?: Function;
+	parameters: TypeParameter[];
+	return: Type;
+	tags?: TagsReflection;
+}
+export interface TypeCallSignature extends TypeAnnotations {
+	kind: ReflectionKind.callSignature;
+	parent?: Type;
+	parameters: TypeParameter[];
+	return: Type;
+	tags?: TagsReflection;
+}
+export interface TypePromise extends TypeAnnotations {
+	kind: ReflectionKind.promise;
+	parent?: Type;
+	type: Type;
+}
+export interface TypeClass extends TypeAnnotations {
+	kind: ReflectionKind.class;
+	parent?: Type;
+	classType: ClassType;
+	description?: string;
+	/**
+	 * When the class extends another class and uses on it generic type arguments, then those arguments
+	 * are in this array.
+	 * For example `class A extends B<string, boolean> {}` then extendsArguments = [string, boolean].
+	 * The reference to `B` is not part of TypeClass since this information is available in JavaScript runtime
+	 * by using `Object.getPrototypeOf(type.classType)`.
+	 */
+	extendsArguments?: Type[];
+	/**
+	 * When the class implements another interface/type, then those types are in this array.
+	 *
+	 * For example `class A implements B<string, boolean> {}` then implements = [B<string, boolean>].
+	 */
+	implements?: Type[];
+	/**
+	 * When class has generic type arguments, e.g. MyClass<string>, it contains
+	 * all type arguments. If no type arguments are given, it's undefined.
+	 */
+	arguments?: Type[];
+	/**
+	 * properties/methods.
+	 */
+	types: (TypeIndexSignature | TypeProperty | TypeMethod)[];
+	tags?: TagsReflection;
+}
+export interface TypeEnum extends TypeAnnotations {
+	kind: ReflectionKind.enum;
+	parent?: Type;
+	enum: {
+		[name: string]: string | number | undefined | null;
+	};
+	values: (string | number | undefined | null)[];
+	indexType: Type;
+	description?: string;
+	tags?: TagsReflection;
+}
+export interface TypeEnumMember extends TypeAnnotations {
+	kind: ReflectionKind.enumMember;
+	parent: TypeEnum;
+	name: string;
+	description?: string;
+	default?: (() => string | number) | string | number;
+	tags?: TagsReflection;
+}
+export interface TypeTypeParameter extends TypeAnnotations {
+	kind: ReflectionKind.typeParameter;
+	parent?: Type;
+	name: string;
+	tags?: TagsReflection;
+}
+export interface TypeUnion extends TypeAnnotations {
+	kind: ReflectionKind.union;
+	parent?: Type;
+	types: Type[];
+}
+export interface TypeIntersection extends TypeAnnotations {
+	kind: ReflectionKind.intersection;
+	parent?: Type;
+	types: Type[];
+}
+export interface TypeArray extends TypeAnnotations {
+	kind: ReflectionKind.array;
+	parent?: Type;
+	type: Type;
+	tags?: TagsReflection;
+}
+export interface TypePropertySignature extends TypeAnnotations {
+	kind: ReflectionKind.propertySignature;
+	parent: TypeObjectLiteral;
+	name: number | string | symbol;
+	optional?: true;
+	readonly?: true;
+	description?: string;
+	type: Type;
+	/**
+	 * Set when the property has a default value aka initializer.
+	 */
+	default?: (() => any) | any;
+	tags?: TagsReflection;
+}
+export interface TypeMethodSignature extends TypeAnnotations {
+	kind: ReflectionKind.methodSignature;
+	parent: TypeObjectLiteral;
+	name: number | string | symbol;
+	optional?: true;
+	description?: string;
+	parameters: TypeParameter[];
+	return: Type;
+	tags?: TagsReflection;
+}
+/**
+ * Object literals or interfaces.
+ */
+export interface TypeObjectLiteral extends TypeAnnotations {
+	kind: ReflectionKind.objectLiteral;
+	parent?: Type;
+	description?: string;
+	types: (TypeIndexSignature | TypePropertySignature | TypeMethodSignature | TypeCallSignature)[];
+	/**
+	 * When the interface extends another interface/type, then those types are in this array.
+	 *
+	 * For example `interface A extends B<string, boolean> {}` then implements = [B<string, boolean>].
+	 */
+	implements?: Type[];
+	tags?: TagsReflection;
+}
+export interface TypeIndexSignature extends TypeAnnotations {
+	kind: ReflectionKind.indexSignature;
+	parent: TypeClass | TypeObjectLiteral;
+	index: Type;
+	type: Type;
+	/**
+	 * Set when the property has a default value aka initializer.
+	 */
+	default?: (() => any) | any;
+	tags?: TagsReflection;
+}
+export interface TypeInfer extends TypeAnnotations {
+	kind: ReflectionKind.infer;
+	parent?: Type;
+	set(type: Type): void;
+}
+export interface TypeTupleMember extends TypeAnnotations {
+	kind: ReflectionKind.tupleMember;
+	parent: TypeTuple;
+	type: Type;
+	optional?: true;
+	name?: string;
+}
+export interface TypeTuple extends TypeAnnotations {
+	kind: ReflectionKind.tuple;
+	parent?: Type;
+	types: TypeTupleMember[];
+}
+export interface TypeRest extends TypeAnnotations {
+	kind: ReflectionKind.rest;
+	parent: TypeTypeParameter | TypeTupleMember;
+	type: Type;
+}
+/**
+ * @reflection never
+ */
+export type Type = TypeNever | TypeAny | TypeUnknown | TypeVoid | TypeObject | TypeString | TypeNumber | TypeBoolean | TypeBigInt | TypeSymbol | TypeNull | TypeUndefined | TypeLiteral | TypeTemplateLiteral | TypeParameter | TypeFunction | TypeMethod | TypeProperty | TypePromise | TypeClass | TypeEnum | TypeEnumMember | TypeUnion | TypeIntersection | TypeArray | TypeObjectLiteral | TypeIndexSignature | TypePropertySignature | TypeMethodSignature | TypeTypeParameter | TypeInfer | TypeTuple | TypeTupleMember | TypeRest | TypeRegexp | TypeCallSignature;
+export type Widen<T> = T extends string ? string : T extends number ? number : T extends bigint ? bigint : T extends boolean ? boolean : T extends symbol ? symbol : T;
+export type FindType<T extends Type, LOOKUP extends ReflectionKind> = T extends {
+	kind: infer K;
+} ? K extends LOOKUP ? T : never : never;
+/**
+ * Merge dynamic runtime types with static types. In the type-system resolves as any, in runtime as the correct type.
+ *
+ * ```typescript
+ * const stringType = {kind: ReflectionKind.string};
+ * type t = {a: InlineRuntimeType<typeof stringType>}
+ *
+ * const value = 34;
+ * type t = {a: InlineRuntimeType<typeof value>}
+ * ```
+ */
+export type InlineRuntimeType<T extends ReflectionClass<any> | Type | number | string | boolean | bigint> = T extends ReflectionClass<infer K> ? K : any;
+export declare function isType(entry: any): entry is Type;
+export declare function isBinary(type: Type): boolean;
+export declare function isPrimitive<T extends Type>(type: T): boolean;
+export declare function isPropertyType(type: Type): type is TypePropertySignature | TypeProperty;
+/**
+ * Returns true if the type is TypePropertySignature | TypeProperty and not a static member.
+ */
+export declare function isPropertyMemberType(type: Type): type is TypePropertySignature | TypeProperty;
+/**
+ * Return all properties created in the constructor (via `constructor(public title: string)`)
+ *
+ * If a non-property parameter is in the constructor, the type is given instead, e.g. `constructor(public title: string, anotherOne:number)` => [TypeProperty, TypeNumber]
+ */
+export declare function getConstructorProperties(type: TypeClass | TypeObjectLiteral): {
+	parameters: (TypeProperty | Type)[];
+	properties: TypeProperty[];
+};
+export type WithAnnotations = TypeAny | TypeUnknown | TypeString | TypeNumber | TypeBigInt | TypeBoolean | TypeArray | TypeTuple | TypeLiteral | TypeNull | TypeUndefined | TypeClass | TypeObjectLiteral | TypeObject | TypeTemplateLiteral | TypeRegexp | TypeSymbol;
+export declare function isWithAnnotations(type: ParentLessType): type is WithAnnotations;
+export declare function getAnnotations(type: WithAnnotations): Annotations;
+type StackEntry = {
+	left: Type;
+	right: Type;
+};
+/**
+ * Checks if the structure of a and b are identical.
+ */
+export declare function isSameType(a: Type, b: Type, stack?: StackEntry[]): boolean;
+export declare function addType<T extends Type>(container: T, type: Type): T;
+export declare function isTypeIncluded(types: Type[], type: Type, stack?: StackEntry[]): boolean;
+/**
+ * `true | (string | number)` => `true | string | number`
+ */
+export declare function flatten<T extends Type>(type: T): T;
+/**
+ * Flatten nested union types.
+ */
+export declare function flattenUnionTypes(types: Type[]): Type[];
+/**
+ * empty union => never
+ * union with one member => member
+ * otherwise the union is returned
+ */
+export declare function unboxUnion(union: TypeUnion): Type;
+export declare function findMember(index: string | number | symbol | TypeTemplateLiteral, types: Type[]): TypePropertySignature | TypeMethodSignature | TypeMethod | TypeProperty | TypeIndexSignature | undefined;
+interface CStack {
+	iterator: Type[];
+	i: number;
+	round: number;
+}
+export declare function emptyObject(type: Type): boolean;
+export declare class CartesianProduct {
+	protected stack: CStack[];
+	private current;
+	private next;
+	toGroup(type: Type): Type[];
+	add(item: Type): void;
+	calculate(): Type[][];
+}
+/**
+ * Query a container type and return the result.
+ *
+ * container[index]
+ *
+ * e.g. {a: string}['a'] => string
+ * e.g. {a: string, b: number}[keyof T] => string | number
+ * e.g. [string, number][0] => string
+ * e.g. [string, number][number] => string | number
+ */
+export declare function indexAccess(container: Type, index: Type): Type;
+export declare function merge(types: (TypeObjectLiteral | TypeClass)[]): TypeObjectLiteral;
+export declare function narrowOriginalLiteral(type: Type): Type;
+type GetArrayElement<T extends any[]> = [
+	T
+] extends [
+	Array<infer K>
+] ? K : never;
+type RemoveParent<T, K extends keyof T> = {
+	[P in K]: T[P] extends Type[] ? RemoveParentHomomorphic<GetArrayElement<T[P]>>[] : T[P] extends Type ? RemoveParentHomomorphic<T[P]> : T[P];
+};
+type RemoveParentHomomorphic<T> = RemoveParent<T, Exclude<keyof T, "parent">>;
+type RemoveDeepParent<T extends Type> = T extends infer K ? RemoveParentHomomorphic<K> : never;
+export type ParentLessType = RemoveDeepParent<Type>;
+/**
+ * This function does not do a deep copy, only shallow. A deep copy makes it way to inefficient, so much that router.spec.ts takes up to 20-30seconds
+ * to complete instead of barely 30ms.
+ */
+export declare function copyAndSetParent<T extends ParentLessType>(inc: T, parent?: Type): FindType<Type, T["kind"]>;
+export declare function widenLiteral(type: Type): Type;
+export declare function assertType<K extends ReflectionKind, T>(t: Type | undefined, kind: K): asserts t is FindType<Type, K>;
+export declare function getClassType(type: Type): ClassType;
+export declare function isMember(type: Type): type is TypePropertySignature | TypeProperty | TypeMethodSignature | TypeMethod;
+export declare function hasMember(type: TypeObjectLiteral | TypeClass, memberName: number | string | symbol, memberType?: Type): boolean;
+export declare function getMember(type: TypeObjectLiteral | TypeClass, memberName: number | string | symbol): TypeMethodSignature | TypeMethod | TypePropertySignature | TypeProperty | void;
+export declare function getTypeObjectLiteralFromTypeClass<T extends Type>(type: T): T extends TypeClass ? TypeObjectLiteral : T;
+/**
+ * Checks whether `undefined` is allowed as type.
+ */
+export declare function isOptional(type: Type): boolean;
+/**
+ * Whether a property has an initializer/default value.
+ */
+export declare function hasDefaultValue(type: Type): boolean;
+/**
+ * Checks whether `null` is allowed as type.
+ */
+export declare function isNullable(type: Type): boolean;
+/**
+ * Get tags from type.
+ */
+export declare function getTags(type: Type): TagsReflection;
+/**
+ * Checks whether the \`hidden\` tag was specified for the type.
+ */
+export declare function isHidden(type: Type): boolean;
+/**
+ * Checks whether the \`ignore\` tag was specified for the type.
+ */
+export declare function isIgnore(type: Type): boolean;
+/**
+ * Checks whether the \`internal\` tag was specified for the type.
+ */
+export declare function isInternal(type: Type): boolean;
+/**
+ * Returns the values specified by the type's \`alias\` tag(s).
+ */
+export declare function getAlias(type: Type): string[];
+/**
+ * Checks whether the \`readonly\` tag was specified for the type.
+ */
+export declare function isReadonly(type: Type): boolean;
+/**
+ * Returns the values specified by the type's \`title\` tag.
+ */
+export declare function getTitle(type: Type): string | undefined;
+/**
+ * Returns the values specified by the type's \`permission\` tag(s).
+ */
+export declare function getPermission(type: Type): string[];
+/**
+ * Returns the values specified by the type's \`domain\` tag.
+ */
+export declare function getDomain(type: Type): string | undefined;
+/**
+ * Integer
+ */
+export type integer = number;
+/**
+ * Integer 8 bit.
+ * Min value -127, max value 128
+ */
+export type int8 = number;
+/**
+ * Unsigned integer 8 bit.
+ * Min value 0, max value 255
+ */
+export type uint8 = number;
+/**
+ * Integer 16 bit.
+ * Min value -32768, max value 32767
+ */
+export type int16 = number;
+/**
+ * Unsigned integer 16 bit.
+ * Min value 0, max value 65535
+ */
+export type uint16 = number;
+/**
+ * Integer 8 bit.
+ * Min value -2147483648, max value 2147483647
+ */
+export type int32 = number;
+/**
+ * Unsigned integer 32 bit.
+ * Min value 0, max value 4294967295
+ */
+export type uint32 = number;
+/**
+ * Float (same as number, but different semantic for databases).
+ */
+export type float = number;
+/**
+ * Float 32 bit.
+ */
+export type float32 = number;
+/**
+ * Float 64 bit.
+ */
+export type float64 = number;
+export declare class AnnotationDefinition<T = true> {
+	readonly id: string;
+	symbol: symbol;
+	constructor(id: string);
+	register(annotations: Annotations, data: T): void;
+	reset(annotations: Annotations): void;
+	registerType<TType extends Type>(type: TType, data: T): TType;
+	replace(annotations: Annotations, annotation: T[]): void;
+	replaceType(type: Type, annotation: T[]): void;
+	getAnnotations(type: Type): T[];
+	getFirst(type: Type): T | undefined;
+	hasAnnotations(type: Type): boolean;
+}
+export type AnnotationType<T extends AnnotationDefinition<any>> = T extends AnnotationDefinition<infer K> ? K : never;
+export type ReferenceActions = "RESTRICT" | "NO ACTION" | "CASCADE" | "SET NULL" | "SET DEFAULT";
+export interface ReferenceOptions {
+	/**
+	 * Default is CASCADE.
+	 */
+	onDelete?: ReferenceActions;
+	/**
+	 * Default is CASCADE.
+	 */
+	onUpdate?: ReferenceActions;
+}
+/**
+ * note: if this is adjusted, make sure to adjust ReflectionClass, entityAnnotation, and type serializer accordingly.
+ */
+export interface EntityOptions {
+	name?: string;
+	description?: string;
+	collection?: string;
+	database?: string;
+	singleTableInheritance?: boolean;
+	indexes?: {
+		names: string[];
+		options: IndexOptions;
+	}[];
+}
+/**
+ * Type to decorate an interface/object literal with entity information.
+ *
+ * ```typescript
+ * interface User extends Entity<{name: 'user'}> {
+ *     id: number & PrimaryKey & AutoIncrement;
+ *     username: string & Unique;
+ * }
+ * ```
+ */
+export type Entity<T extends EntityOptions> = {} & TypeAnnotation<"entity", T>;
+/**
+ * Marks a property as primary key.
+ * ```typescript
+ * class Entity {
+ *     id: number & Primary = 0;
+ * }
+ * ```
+ */
+export type PrimaryKey = TypeAnnotation<"primaryKey">;
+type TypeKeyOf<T> = T[keyof T];
+export type PrimaryKeyFields<T> = any extends T ? any : {
+	[P in keyof T]: Required<T[P]> extends Required<PrimaryKey> ? T[P] : never;
+};
+export type PrimaryKeyType<T> = any extends T ? any : TypeKeyOf<PrimaryKeyFields<T>>;
+export type ReferenceFields<T> = {
+	[P in keyof T]: Required<T[P]> extends Required<Reference> | Required<BackReference> ? T[P] : never;
+};
+/**
+ * Marks a primary property key as auto-increment.
+ *
+ * ```typescript
+ * class Entity {
+ *     id: number & Primary & AutoIncrement = 0;
+ * }
+ * ```
+ */
+export type AutoIncrement = TypeAnnotation<"autoIncrement">;
+/**
+ * UUID v4, as string, serialized as string in JSON, and binary in database.
+ * Use `uuid()` as handy initializer.
+ *
+ * ```typescript
+ * class Entity {
+ *     id: UUID = uuid();
+ * }
+ * ```
+ */
+export type UUID = string & TypeAnnotation<"UUIDv4">;
+/**
+ * MongoDB's ObjectID type. serialized as string in JSON, ObjectID in database.
+ */
+export type MongoId = string & TypeAnnotation<"mongoId">;
+/**
+ * Same as `bigint` but serializes to unsigned binary with unlimited size (instead of 8 bytes in most databases).
+ * Negative values will be converted to positive (abs(x)).
+ *
+ * ```typescript
+ * class Entity {
+ *     id: BinaryBigInt = 0n;
+ * }
+ * ```
+ */
+export type BinaryBigInt = bigint & TypeAnnotation<"binaryBigInt">;
+/**
+ * Same as `bigint` but serializes to signed binary with unlimited size (instead of 8 bytes in most databases).
+ * The binary has an additional leading sign byte and is represented as an uint: 255 for negative, 0 for zero, or 1 for positive.
+ *
+ * ```typescript
+ * class Entity {
+ *     id: SignedBinaryBigInt = 0n;
+ * }
+ * ```
+ */
+export type SignedBinaryBigInt = bigint & TypeAnnotation<"signedBinaryBigInt">;
+export interface BackReferenceOptions {
+	/**
+	 * Necessary for normalised many-to-many relations. This defines the class of the pivot table/collection.
+	 */
+	via?: ClassType | {};
+	/**
+	 * A reference/backReference can define which reference on the other side
+	 * reference back. This is necessary when there are multiple outgoing references
+	 * to the same entity.
+	 */
+	mappedBy?: string;
+}
+export type Reference<Options extends ReferenceOptions = {}> = TypeAnnotation<"reference", Options>;
+export type BackReference<Options extends BackReferenceOptions = {}> = TypeAnnotation<"backReference", Options>;
+export type EmbeddedMeta<Options> = TypeAnnotation<"embedded", Options>;
+export type Embedded<T, Options extends {
+	prefix?: string;
+} = {}> = T & EmbeddedMeta<Options>;
+export type MapName<Alias extends string, ForSerializer extends string = ""> = TypeAnnotation<"mapName", [
+	Alias,
+	ForSerializer
+]>;
+export declare const referenceAnnotation: AnnotationDefinition<ReferenceOptions>;
+export declare const entityAnnotation: {
+	set<K extends keyof EntityOptions>(type: Type, name: K, value: EntityOptions[K]): void;
+	get(type: Type): EntityOptions;
+	symbol: symbol;
+	readonly id: string;
+	register(annotations: Annotations, data: EntityOptions): void;
+	reset(annotations: Annotations): void;
+	registerType<TType extends Type>(type: TType, data: EntityOptions): TType;
+	replace(annotations: Annotations, annotation: EntityOptions[]): void;
+	replaceType(type: Type, annotation: EntityOptions[]): void;
+	getAnnotations(type: Type): EntityOptions[];
+	getFirst(type: Type): EntityOptions | undefined;
+	hasAnnotations(type: Type): boolean;
+};
+export declare const mapNameAnnotation: AnnotationDefinition<{
+	name: string;
+	serializer?: string;
+}>;
+export declare const autoIncrementAnnotation: AnnotationDefinition<true>;
+export declare const primaryKeyAnnotation: {
+	isPrimaryKey(type: Type): boolean;
+	symbol: symbol;
+	readonly id: string;
+	register(annotations: Annotations, data: true): void;
+	reset(annotations: Annotations): void;
+	registerType<TType extends Type>(type: TType, data: true): TType;
+	replace(annotations: Annotations, annotation: true[]): void;
+	replaceType(type: Type, annotation: true[]): void;
+	getAnnotations(type: Type): true[];
+	getFirst(type: Type): true | undefined;
+	hasAnnotations(type: Type): boolean;
+};
+export interface BackReferenceOptionsResolved {
+	/**
+	 * Necessary for normalised many-to-many relations. This defines the class of the pivot table/collection.
+	 */
+	via?: TypeClass | TypeObjectLiteral;
+	/**
+	 * A reference/backReference can define which reference on the other side
+	 * reference back. This is necessary when there are multiple outgoing references
+	 * to the same entity.
+	 */
+	mappedBy?: string;
+}
+export declare const backReferenceAnnotation: AnnotationDefinition<BackReferenceOptionsResolved>;
+export declare const validationAnnotation: AnnotationDefinition<{
+	name: string;
+	args: Type[];
+}>;
+export declare const UUIDAnnotation: AnnotationDefinition<true>;
+export declare const mongoIdAnnotation: AnnotationDefinition<true>;
+export declare const uuidAnnotation: AnnotationDefinition<true>;
+export declare const defaultAnnotation: AnnotationDefinition<Type>;
+export declare function isUUIDType(type: Type): boolean;
+export declare function isPrimaryKeyType(type: Type): boolean;
+export declare function isAutoIncrementType(type: Type): boolean;
+export declare function isMongoIdType(type: Type): boolean;
+export declare function isBinaryBigIntType(type: Type): boolean;
+export declare function isReferenceType(type: Type): boolean;
+export declare function getReferenceType(type: Type): ReferenceOptions | undefined;
+export declare function isBackReferenceType(type: Type): boolean;
+export declare function resolveProperty(type: Type): Type;
+export declare function getBackReferenceType(type: Type): BackReferenceOptionsResolved;
+export declare function isDateType(type: Type): boolean;
+export declare function isSetType(type: Type): boolean;
+export declare function isMapType(type: Type): boolean;
+/**
+ * Get the key type of a Map or object literal with index signatures.
+ */
+export declare function getKeyType(type: Type): Type;
+/**
+ * Get the value type of a Map or object literal with index signatures.
+ */
+export declare function getValueType(type: Type): Type;
+export interface EmbeddedOptions {
+	prefix?: string;
+}
+export declare const embeddedAnnotation: AnnotationDefinition<EmbeddedOptions>;
+export declare function hasEmbedded(type: Type): boolean;
+/**
+ * Assigns one or multiple groups to a type.
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *     username: string;
+ *     password: string & Group<'credentials'>;
+ * }
+ * ```
+ */
+export type Group<Name extends string> = TypeAnnotation<"group", Name>;
+/**
+ * Excludes the type from serialization of all kind.
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *    username: string;
+ *    password: string & Excluded;
+ *  }
+ *  ```
+ */
+export type Excluded<Name extends string = "*"> = TypeAnnotation<"excluded", Name>;
+/**
+ * Assigns arbitrary data to a type that can be read in runtime.
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   username: string;
+ *   password: string & Data<'role', 'admin'>;
+ * }
+ * ```
+ */
+export type Data<Name extends string, Value> = TypeAnnotation<"data", [
+	Name,
+	Value
+]>;
+/**
+ * Resets an already set decorator to undefined.
+ *
+ * The required Name is the name of the type decorator (its first tuple entry).
+ *
+ * ```typescript
+ * type Password = string & MinLength<6> & Excluded;
+ *
+ * interface UserCreationPayload {
+ *     password: Password & ResetAnnotation<'excluded'>
+ * }
+ * ```
+ */
+export type ResetAnnotation<Name extends string> = TypeAnnotation<"reset", Name>;
+export type IndexOptions = {
+	name?: string;
+	size?: number;
+	unique?: boolean;
+	spatial?: boolean;
+	sparse?: boolean;
+	fulltext?: boolean;
+	where?: string;
+	expireAfterSeconds?: number;
+};
+export type Unique<Options extends IndexOptions = {}> = TypeAnnotation<"index", Options & {
+	unique: true;
+}>;
+export type Index<Options extends IndexOptions = {}> = TypeAnnotation<"index", Options>;
+export interface DatabaseFieldOptions {
+	/**
+	 * The name of the column in the database.
+	 * e.g. `userName: string & DatabaseField<{name: 'user_name'}>`
+	 *
+	 * Can alternatively also be configured by using a different NamingStrategy.
+	 */
+	name?: string;
+	/**
+	 *
+	 * e.g. `field: string & MySQL<{type: 'VARCHAR(255)'}>`
+	 */
+	type?: string;
+	/**
+	 * If the property is on a class, its initializer/default value is per default used.
+	 * This can be overridden using this option.
+	 * e.g. `field: string & MySQL<{default: 'abc'}>`
+	 */
+	default?: any;
+	/**
+	 * e.g. `field: string & MySQL<{defaultExpr: 'NOW()'}>`
+	 */
+	defaultExpr?: any;
+	/**
+	 * If true no default column value is inferred from the property initializer/default value.
+	 * e.g. `field: string & MySQL<{noDefault: true}> = ''`
+	 */
+	noDefault?: true;
+	/**
+	 * Skip this property in all queries and database migration files.
+	 */
+	skip?: true;
+	/**
+	 * Skip this property in database migration files. This excludes the property from the database, but
+	 * keeps it in the queries.
+	 */
+	skipMigration?: true;
+}
+export interface MySQLOptions extends DatabaseFieldOptions {
+}
+export interface PostgresOptions extends DatabaseFieldOptions {
+}
+export interface SqliteOptions extends DatabaseFieldOptions {
+}
+type Database<Name extends string, Options extends {
+	[name: string]: any;
+}> = TypeAnnotation<"database", [
+	Name,
+	Options
+]>;
+export type MySQL<Options extends MySQLOptions> = Database<"mysql", Options>;
+export type Postgres<Options extends PostgresOptions> = Database<"postgres", Options>;
+export type SQLite<Options extends SqliteOptions> = Database<"sqlite", Options>;
+export type DatabaseField<Options extends DatabaseFieldOptions, Name extends string = "*"> = Database<Name, Options>;
+export declare const enum BinaryBigIntType {
+	unsigned = 0,
+	signed = 1
+}
+export declare const binaryBigIntAnnotation: AnnotationDefinition<BinaryBigIntType>;
+export declare const groupAnnotation: AnnotationDefinition<string>;
+export declare const excludedAnnotation: {
+	isExcluded(type: Type, name: string): boolean;
+	symbol: symbol;
+	readonly id: string;
+	register(annotations: Annotations, data: string): void;
+	reset(annotations: Annotations): void;
+	registerType<TType extends Type>(type: TType, data: string): TType;
+	replace(annotations: Annotations, annotation: string[]): void;
+	replaceType(type: Type, annotation: string[]): void;
+	getAnnotations(type: Type): string[];
+	getFirst(type: Type): string | undefined;
+	hasAnnotations(type: Type): boolean;
+};
+export declare const dataAnnotation: {
+	set<T extends Type>(type: T, key: string, value: any): T;
+	get(type: Type, key: string): any;
+	symbol: symbol;
+	readonly id: string;
+	register(annotations: Annotations, data: {
+		[name: string]: any;
+	}): void;
+	reset(annotations: Annotations): void;
+	registerType<TType extends Type>(type: TType, data: {
+		[name: string]: any;
+	}): TType;
+	replace(annotations: Annotations, annotation: {
+		[name: string]: any;
+	}[]): void;
+	replaceType(type: Type, annotation: {
+		[name: string]: any;
+	}[]): void;
+	getAnnotations(type: Type): {
+		[name: string]: any;
+	}[];
+	getFirst(type: Type): {
+		[name: string]: any;
+	} | undefined;
+	hasAnnotations(type: Type): boolean;
+};
+/**
+ * All raw data from `TypeAnnotation<Name, Options>` types.
+ */
+export declare const typeAnnotation: {
+	/**
+	 * Returns the parsed Type to JS objects, e.g. `{name: string}` => `{name: 'xy'}`
+	 */
+	getOption(type: Type, name: string): any;
+	/**
+	 * Returns the Type object of the annotation which can be parsed with `typeToObject`.
+	 */
+	getType(type: Type, name: string): Type | undefined;
+	symbol: symbol;
+	readonly id: string;
+	register(annotations: Annotations, data: {
+		name: string;
+		options: Type;
+	}): void;
+	reset(annotations: Annotations): void;
+	registerType<TType extends Type>(type: TType, data: {
+		name: string;
+		options: Type;
+	}): TType;
+	replace(annotations: Annotations, annotation: {
+		name: string;
+		options: Type;
+	}[]): void;
+	replaceType(type: Type, annotation: {
+		name: string;
+		options: Type;
+	}[]): void;
+	getAnnotations(type: Type): {
+		name: string;
+		options: Type;
+	}[];
+	getFirst(type: Type): {
+		name: string;
+		options: Type;
+	} | undefined;
+	hasAnnotations(type: Type): boolean;
+};
+export declare const indexAnnotation: AnnotationDefinition<IndexOptions>;
+export declare const databaseAnnotation: {
+	getDatabase<T extends DatabaseFieldOptions>(type: Type, name: string): T | undefined;
+	symbol: symbol;
+	readonly id: string;
+	register(annotations: Annotations, data: {
+		name: string;
+		options: {
+			[name: string]: any;
+		};
+	}): void;
+	reset(annotations: Annotations): void;
+	registerType<TType extends Type>(type: TType, data: {
+		name: string;
+		options: {
+			[name: string]: any;
+		};
+	}): TType;
+	replace(annotations: Annotations, annotation: {
+		name: string;
+		options: {
+			[name: string]: any;
+		};
+	}[]): void;
+	replaceType(type: Type, annotation: {
+		name: string;
+		options: {
+			[name: string]: any;
+		};
+	}[]): void;
+	getAnnotations(type: Type): {
+		name: string;
+		options: {
+			[name: string]: any;
+		};
+	}[];
+	getFirst(type: Type): {
+		name: string;
+		options: {
+			[name: string]: any;
+		};
+	} | undefined;
+	hasAnnotations(type: Type): boolean;
+};
+export declare function registerTypeDecorator(decorator: TypeDecorator): void;
+/**
+ * Type annotations are object literals with a single optional __meta in it
+ * that has as type a tuple with the name of the annotation as first entry.
+ * The tuple is intersected with the `never` type to make sure it does not
+ * interfere with type checking.
+ *
+ * The processor has currently implemented to not resolve `never & x` to `never`,
+ * so we still have the intersection type in runtime to resolve __meta correctly.
+ *
+ * ```typescript
+ * type MyAnnotation1 = TypeAnnotation<'myAnnotation'>
+ * type MyAnnotation1<T> = TypeAnnotation<'myAnnotation', T>
+ *
+ * //under the hood it is:
+ * type lowLevel1 = { __meta?: never & ['myAnnotation'] }
+ * type lowLevel2<T> = { __meta?: never & ['myAnnotation', T] }
+ * ```
+ */
+export declare function getAnnotationMeta(type: TypeObjectLiteral): {
+	id: string;
+	options: Type;
+} | undefined;
+export declare const typeDecorators: TypeDecorator[];
+export declare function typeToObject(type?: Type, state?: {
+	stack: Type[];
+}): any;
+export declare function memberNameToString(name: number | string | symbol): string;
+export declare const binaryTypes: ClassType[];
+/**
+ * Returns true if the given type is Date, ArrayBuffer, Uint8Array, etc.
+ */
+export declare function isGlobalTypeClass(type: Type): type is TypeClass;
+/**
+ * Returns true if the given type is TypeClass and references a custom (non-global) class.
+ */
+export declare function isCustomTypeClass(type: Type): type is TypeClass;
+/**
+ * Returns a type predicate that checks if the given type is a class and is of the given classType.
+ * If withInheritance is true, it also checks if the type is a subclass of the given classType.
+ */
+export declare function isTypeClassOf(classType: ClassType, withInheritance?: boolean): (type: Type) => boolean;
+/**
+ * Returns the members of a class or object literal.
+ */
+export declare function resolveTypeMembers(type: TypeClass | TypeObjectLiteral): (TypeProperty | TypePropertySignature | TypeMethodSignature | TypeMethod | TypeIndexSignature | TypeCallSignature)[];
+export declare function stringifyResolvedType(type: Type): string;
+export declare function stringifyShortResolvedType(type: Type, stateIn?: Partial<StringifyTypeOptions>): string;
+/**
+ * Returns all (including inherited) constructor properties of a class.
+ */
+export declare function getDeepConstructorProperties(type: TypeClass): TypeParameter[];
+/**
+ * Returns the index to `type.values` if the given value is part of the enum, exactly or case-insensitive.
+ * Returns -1 if not found.
+ */
+export declare function getEnumValueIndexMatcher(type: TypeEnum): (value: string | number | undefined | null) => number;
+interface StringifyTypeOptions {
+	showNames: boolean;
+	showFullDefinition: boolean;
+	showDescription: boolean;
+	defaultIsOptional: boolean;
+	showHeritage: boolean;
+	showDefaults: boolean;
+	showTags: boolean;
+	defaultValues: any;
+	stringify?: (type: Type) => string | undefined;
+}
+export declare function stringifyType(type: Type, stateIn?: Partial<StringifyTypeOptions>): string;
+export declare function annotateClass<T>(clazz: ClassType | AbstractClassType, type?: ReceiveType<T>): void;
+export declare type __ΩReflectionVisibility = any[];
+export declare type __ΩReflectionKind = any[];
+export declare type __ΩTypeDecorator = any[];
+export declare type __ΩAnnotations = any[];
+export declare type __ΩJitContainer = any[];
+export declare type __ΩTagsReflection = any[];
+export declare type __ΩTypeNever = any[];
+export declare type __ΩTypeAny = any[];
+export declare type __ΩTypeUnknown = any[];
+export declare type __ΩTypeVoid = any[];
+export declare type __ΩTypeObject = any[];
+export declare type __ΩTypeString = any[];
+export declare type __ΩTypeNumber = any[];
+export declare type __ΩTypeBoolean = any[];
+export declare type __ΩTypeBigInt = any[];
+export declare type __ΩTypeSymbol = any[];
+export declare type __ΩTypeNull = any[];
+export declare type __ΩTypeUndefined = any[];
+export declare type __ΩTypeLiteral = any[];
+export declare type __ΩTypeTemplateLiteral = any[];
+export declare type __ΩTypeRegexp = any[];
+export declare type __ΩTypeBaseMember = any[];
+export declare type __ΩTypeParameter = any[];
+export declare type __ΩTypeMethod = any[];
+export declare type __ΩTypeProperty = any[];
+export declare type __ΩTypeFunction = any[];
+export declare type __ΩTypeCallSignature = any[];
+export declare type __ΩTypePromise = any[];
+export declare type __ΩTypeClass = any[];
+export declare type __ΩTypeEnum = any[];
+export declare type __ΩTypeEnumMember = any[];
+export declare type __ΩTypeTypeParameter = any[];
+export declare type __ΩTypeUnion = any[];
+export declare type __ΩTypeIntersection = any[];
+export declare type __ΩTypeArray = any[];
+export declare type __ΩTypePropertySignature = any[];
+export declare type __ΩTypeMethodSignature = any[];
+export declare type __ΩTypeObjectLiteral = any[];
+export declare type __ΩTypeIndexSignature = any[];
+export declare type __ΩTypeInfer = any[];
+export declare type __ΩTypeTupleMember = any[];
+export declare type __ΩTypeTuple = any[];
+export declare type __ΩTypeRest = any[];
+export declare type __ΩWiden = any[];
+export declare type __ΩFindType = any[];
+export declare type __ΩInlineRuntimeType = any[];
+export declare type __ΩWithAnnotations = any[];
+export declare type __ΩParentLessType = any[];
+export declare type __Ωinteger = any[];
+export declare type __Ωint8 = any[];
+export declare type __Ωuint8 = any[];
+export declare type __Ωint16 = any[];
+export declare type __Ωuint16 = any[];
+export declare type __Ωint32 = any[];
+export declare type __Ωuint32 = any[];
+export declare type __Ωfloat = any[];
+export declare type __Ωfloat32 = any[];
+export declare type __Ωfloat64 = any[];
+export declare type __ΩAnnotationType = any[];
+export declare type __ΩReferenceActions = any[];
+export declare type __ΩReferenceOptions = any[];
+export declare type __ΩEntityOptions = any[];
+export declare type __ΩEntity = any[];
+export declare type __ΩPrimaryKey = any[];
+export declare type __ΩPrimaryKeyFields = any[];
+export declare type __ΩPrimaryKeyType = any[];
+export declare type __ΩReferenceFields = any[];
+export declare type __ΩAutoIncrement = any[];
+export declare type __ΩUUID = any[];
+export declare type __ΩMongoId = any[];
+export declare type __ΩBinaryBigInt = any[];
+export declare type __ΩSignedBinaryBigInt = any[];
+export declare type __ΩBackReferenceOptions = any[];
+export declare type __ΩReference = any[];
+export declare type __ΩBackReference = any[];
+export declare type __ΩEmbeddedMeta = any[];
+export declare type __ΩEmbedded = any[];
+export declare type __ΩMapName = any[];
+export declare type __ΩBackReferenceOptionsResolved = any[];
+export declare type __ΩEmbeddedOptions = any[];
+export declare type __ΩGroup = any[];
+export declare type __ΩExcluded = any[];
+export declare type __ΩData = any[];
+export declare type __ΩResetAnnotation = any[];
+export declare type __ΩIndexOptions = any[];
+export declare type __ΩUnique = any[];
+export declare type __ΩIndex = any[];
+export declare type __ΩDatabaseFieldOptions = any[];
+export declare type __ΩMySQLOptions = any[];
+export declare type __ΩPostgresOptions = any[];
+export declare type __ΩSqliteOptions = any[];
+export declare type __ΩMySQL = any[];
+export declare type __ΩPostgres = any[];
+export declare type __ΩSQLite = any[];
+export declare type __ΩDatabaseField = any[];
+export declare type __ΩBinaryBigIntType = any[];
+export interface SerializedTypeAnnotations {
+	entityOptions?: EntityOptions;
+	typeName?: string;
+	typeArguments?: SerializedTypeReference[];
+	indexAccessOrigin?: {
+		container: SerializedTypeReference;
+		index: SerializedTypeReference;
+	};
+	decorators?: SerializedTypeReference[];
+}
+export interface SerializedTypeObjectLiteral extends SerializedTypeAnnotations {
+	kind: ReflectionKind.objectLiteral;
+	types: SerializedTypeReference[];
+	tags?: TagsReflection;
+}
+export interface SerializedTypeClassType extends SerializedTypeAnnotations {
+	kind: ReflectionKind.class;
+	name?: string;
+	globalObject?: true;
+	classType: string;
+	extendsArguments?: SerializedTypeReference[];
+	arguments?: SerializedTypeReference[];
+	superClass?: SerializedTypeReference;
+	types: SerializedTypeReference[];
+	tags?: TagsReflection;
+}
+export interface SerializedTypeFunction extends SerializedTypeAnnotations {
+	kind: ReflectionKind.function;
+	name?: number | string | symbol;
+	parameters: SerializedTypeParameter[];
+	return: SerializedTypeReference;
+	tags?: TagsReflection;
+}
+export type SerializedTypeReference = number;
+export interface SimpleSerializedType extends SerializedTypeAnnotations {
+	kind: ReflectionKind.never | ReflectionKind.any | ReflectionKind.unknown | ReflectionKind.void | ReflectionKind.object | ReflectionKind.string | ReflectionKind.number | ReflectionKind.boolean | ReflectionKind.symbol | ReflectionKind.bigint | ReflectionKind.null | ReflectionKind.undefined | ReflectionKind.regexp;
+	origin?: SerializedTypeReference;
+}
+export interface SerializedTypeLiteral extends SerializedTypeAnnotations {
+	kind: ReflectionKind.literal;
+	literal: {
+		type: "symbol";
+		name: string;
+	} | string | number | boolean | {
+		type: "bigint";
+		value: string;
+	} | {
+		type: "regex";
+		regex: string;
+	};
+}
+export interface SerializedTypeTemplateLiteral extends SerializedTypeAnnotations {
+	kind: ReflectionKind.templateLiteral;
+	types: SerializedTypeReference[];
+}
+export interface SerializedTypeParameter extends SerializedTypeAnnotations {
+	kind: ReflectionKind.parameter;
+	name: string;
+	type: SerializedTypeReference;
+	visibility?: ReflectionVisibility;
+	readonly?: true;
+	optional?: true;
+	/**
+	 * Set when the parameter has a default value aka initializer.
+	 */
+	default?: any;
+	tags?: TagsReflection;
+}
+export interface SerializedTypeBaseMember extends SerializedTypeAnnotations {
+	visibility: ReflectionVisibility;
+	abstract?: true;
+	optional?: true;
+	readonly?: true;
+	tags?: TagsReflection;
+}
+export interface SerializedTypeMethod extends SerializedTypeBaseMember {
+	kind: ReflectionKind.method;
+	visibility: ReflectionVisibility;
+	name: number | string | symbol;
+	parameters: SerializedTypeParameter[];
+	optional?: true;
+	abstract?: true;
+	return: SerializedTypeReference;
+}
+export interface SerializedTypeProperty extends SerializedTypeBaseMember {
+	kind: ReflectionKind.property;
+	visibility: ReflectionVisibility;
+	name: number | string | symbol;
+	optional?: true;
+	readonly?: true;
+	abstract?: true;
+	description?: string;
+	type: SerializedTypeReference;
+	/**
+	 * Set when the property has a default value aka initializer.
+	 */
+	default?: any;
+}
+export interface SerializedTypePromise extends SerializedTypeAnnotations {
+	kind: ReflectionKind.promise;
+	type: SerializedTypeReference;
+}
+export interface SerializedTypeEnum extends SerializedTypeAnnotations {
+	kind: ReflectionKind.enum;
+	enum: {
+		[name: string]: string | number | undefined | null;
+	};
+	values: (string | number | undefined | null)[];
+	indexType: SerializedTypeReference;
+	tags?: TagsReflection;
+}
+export interface SerializedTypeUnion extends SerializedTypeAnnotations {
+	kind: ReflectionKind.union;
+	types: SerializedTypeReference[];
+}
+export interface SerializedTypeIntersection extends SerializedTypeAnnotations {
+	kind: ReflectionKind.intersection;
+	types: SerializedTypeReference[];
+}
+export interface SerializedTypeArray extends SerializedTypeAnnotations {
+	kind: ReflectionKind.array;
+	type: SerializedTypeReference;
+	tags?: TagsReflection;
+}
+export interface SerializedTypeIndexSignature extends SerializedTypeAnnotations {
+	kind: ReflectionKind.indexSignature;
+	index: SerializedTypeReference;
+	type: SerializedTypeReference;
+	/**
+	 * Set when the parameter has a default value aka initializer.
+	 */
+	default?: any;
+}
+export interface SerializedTypePropertySignature extends SerializedTypeAnnotations {
+	kind: ReflectionKind.propertySignature;
+	name: number | string | symbol;
+	optional?: true;
+	readonly?: true;
+	description?: string;
+	type: SerializedTypeReference;
+	/**
+	 * Set when the parameter has a default value aka initializer.
+	 */
+	default?: any;
+	tags?: TagsReflection;
+}
+export interface SerializedTypeMethodSignature extends SerializedTypeAnnotations {
+	kind: ReflectionKind.methodSignature;
+	name: number | string | symbol;
+	optional?: true;
+	parameters: SerializedTypeParameter[];
+	return: SerializedTypeReference;
+	tags?: TagsReflection;
+}
+export interface SerializedTypeTypeParameter extends SerializedTypeAnnotations {
+	kind: ReflectionKind.typeParameter;
+	name: string;
+}
+export interface SerializedTypeInfer extends SerializedTypeAnnotations {
+	kind: ReflectionKind.infer;
+}
+export interface SerializedTypeTupleMember extends SerializedTypeAnnotations {
+	kind: ReflectionKind.tupleMember;
+	type: SerializedTypeReference;
+	optional?: true;
+	name?: string;
+}
+export interface SerializedTypeTuple extends SerializedTypeAnnotations {
+	kind: ReflectionKind.tuple;
+	types: SerializedTypeTupleMember[];
+}
+export interface SerializedTypeRest extends SerializedTypeAnnotations {
+	kind: ReflectionKind.rest;
+	type: SerializedTypeReference;
+}
+export type SerializedType = SimpleSerializedType | SerializedTypeLiteral | SerializedTypeTemplateLiteral | SerializedTypeParameter | SerializedTypeFunction | SerializedTypeMethod | SerializedTypeProperty | SerializedTypePromise | SerializedTypeClassType | SerializedTypeEnum | SerializedTypeUnion | SerializedTypeIntersection | SerializedTypeArray | SerializedTypeObjectLiteral | SerializedTypeIndexSignature | SerializedTypePropertySignature | SerializedTypeMethodSignature | SerializedTypeTypeParameter | SerializedTypeInfer | SerializedTypeTuple | SerializedTypeTupleMember | SerializedTypeRest;
+export type SerializedTypes = SerializedType[];
+export interface SerializerState {
+	types: SerializedTypes;
+	disableMethods?: true;
+	refs: Map<Type, number>;
+}
+/**
+ * Converts a (possibly circular/nested) type into a JSON.stringify'able structure suited to be transmitted over the wire and deserialized back to the correct Type object.
+ */
+export declare function serializeType(type: Type, state?: Partial<SerializerState>): SerializedTypes;
+interface DeserializeState {
+	types: SerializedTypes;
+	disableReuse?: boolean;
+	deserialized: {
+		[index: number]: {
+			type: Type;
+			refs: Type[];
+			active: boolean;
+		};
+	};
+}
+export declare function deserializeType(types?: SerializedTypes, state?: Partial<DeserializeState>): Type;
+export declare type __ΩSerializedTypeAnnotations = any[];
+export declare type __ΩSerializedTypeObjectLiteral = any[];
+export declare type __ΩSerializedTypeClassType = any[];
+export declare type __ΩSerializedTypeFunction = any[];
+export declare type __ΩSerializedTypeReference = any[];
+export declare type __ΩSimpleSerializedType = any[];
+export declare type __ΩSerializedTypeLiteral = any[];
+export declare type __ΩSerializedTypeTemplateLiteral = any[];
+export declare type __ΩSerializedTypeParameter = any[];
+export declare type __ΩSerializedTypeBaseMember = any[];
+export declare type __ΩSerializedTypeMethod = any[];
+export declare type __ΩSerializedTypeProperty = any[];
+export declare type __ΩSerializedTypePromise = any[];
+export declare type __ΩSerializedTypeEnum = any[];
+export declare type __ΩSerializedTypeUnion = any[];
+export declare type __ΩSerializedTypeIntersection = any[];
+export declare type __ΩSerializedTypeArray = any[];
+export declare type __ΩSerializedTypeIndexSignature = any[];
+export declare type __ΩSerializedTypePropertySignature = any[];
+export declare type __ΩSerializedTypeMethodSignature = any[];
+export declare type __ΩSerializedTypeTypeParameter = any[];
+export declare type __ΩSerializedTypeInfer = any[];
+export declare type __ΩSerializedTypeTupleMember = any[];
+export declare type __ΩSerializedTypeTuple = any[];
+export declare type __ΩSerializedTypeRest = any[];
+export declare type __ΩSerializedType = any[];
+export declare type __ΩSerializedTypes = any[];
+export declare type __ΩSerializerState = any[];
+/**
+ * Make sure to change the id when a custom naming strategy is implemented, since caches are based on it.
+ */
+export declare class NamingStrategy {
+	id: string;
+	constructor(id?: string);
+	getPropertyName(type: TypeProperty | TypePropertySignature, forSerializer: string): string | undefined;
+}
+export declare const underscoreNamingStrategy: {
+	getPropertyName(type: TypeProperty | TypePropertySignature, forSerializer: string): string | undefined;
+	id: string;
+};
+/**
+ * Options that can be passed to the serialization/deserialization functions
+ * and change the behavior in runtime (not embedded in JIT).
+ */
+export interface SerializationOptions {
+	/**
+	 * Which groups to include. If a property is not assigned to
+	 * a given group, it will be excluded.
+	 * Use an empty array to include only non-grouped properties.
+	 */
+	groups?: string[];
+	/**
+	 * Which groups to exclude. If a property is assigned to at least
+	 * one given group, it will be excluded. Basically the opposite of
+	 * `groups`, but you can combine both.
+	 * Use an empty array to exclude only non-grouped properties.
+	 */
+	groupsExclude?: string[];
+	/**
+	 * Allows more loosely data for certain types. e.g.
+	 *
+	 * - '1', '0', 'true', 'false' will be converted to true|false for boolean type.
+	 * - '1' will be converted to number for number type.
+	 * - 1 will be converted to string for string type.
+	 *
+	 * This will activate all registered type guards with negative specifically.
+	 *
+	 * This is enabled by default.
+	 */
+	loosely?: boolean;
+}
+export type SerializeFunction<T = any, R = any> = (data: T, state?: SerializationOptions) => R;
+export declare function getPartialType(type: TypeClass | TypeObjectLiteral): any;
+/**
+ * Creates a (cached) Partial<T> of the given type and returns a (cached) serializer function for the given registry (serialize or deserialize).
+ */
+export declare function getPartialSerializeFunction(type: TypeClass | TypeObjectLiteral, registry: TemplateRegistry, namingStrategy?: NamingStrategy): SerializeFunction<any, any>;
+/**
+ * Returns a (cached) serializer function for the given registry (serialize or deserialize).
+ */
+export declare function getSerializeFunction(type: Type, registry: TemplateRegistry, namingStrategy?: NamingStrategy, path?: string, jitStack?: JitStack): SerializeFunction;
+export declare function createSerializeFunction(type: Type, registry: TemplateRegistry, namingStrategy?: NamingStrategy, path?: string | RuntimeCode | (string | RuntimeCode)[], jitStack?: JitStack): SerializeFunction;
+export type Guard<T> = (data: any, state?: {
+	errors?: ValidationErrorItem[];
+}) => data is T;
+export declare function createTypeGuardFunction(type: Type, stateIn?: Partial<TemplateState>, serializerToUse?: Serializer, withLoose?: boolean): undefined | Guard<any>;
+export declare class SerializationError extends CustomError {
+	originalMessage: string;
+	code: string;
+	path: string;
+	constructor(originalMessage: string, code?: string, path?: string);
+}
+export declare class RuntimeCode {
+	code: string;
+	constructor(code: string);
+}
+export declare function collapsePath(path: (string | RuntimeCode)[], prefix?: string): string;
+export declare function getPropertyNameString(propertyName?: string | RuntimeCode): string;
+/**
+ * internal: The jit stack cache is used in both serializer and guards, so its cache key needs to be aware of it
+ */
+export declare class JitStack {
+	protected stacks: {
+		registry?: TemplateRegistry;
+		map: Map<Type, {
+			fn: Function | undefined;
+			id: number;
+		}>;
+	}[];
+	protected id: number;
+	getStack(registry?: TemplateRegistry): Map<Type, {
+		fn: Function | undefined;
+		id: number;
+	}>;
+	has(registry: TemplateRegistry, type: Type): boolean;
+	get(registry: TemplateRegistry, type: Type): {
+		fn: Function | undefined;
+		id: number;
+	} | undefined;
+	prepare(registry: TemplateRegistry, type: Type): {
+		id: number;
+		prepare: (fn: Function) => {
+			fn: Function | undefined;
+		};
+	};
+	getOrCreate(registry: TemplateRegistry | undefined, type: Type, create: () => Function): {
+		fn: Function | undefined;
+		id: number;
+	};
+}
+export declare class ContainerAccessor {
+	container: string | ContainerAccessor;
+	property: string;
+	constructor(container: string | ContainerAccessor, property: string);
+	toString(): string;
+}
+export declare class TemplateState {
+	originalSetter: string | ContainerAccessor;
+	originalAccessor: string | ContainerAccessor;
+	compilerContext: CompilerContext;
+	registry: TemplateRegistry;
+	namingStrategy: NamingStrategy;
+	jitStack: JitStack;
+	path: (string | RuntimeCode)[];
+	/**
+	 * Before and after template content is rendered before/after all other templates.
+	 * When a template is put into its own function, before/after templates are run outside of this function.
+	 */
+	template: string;
+	ended: boolean;
+	setter: string | ContainerAccessor;
+	accessor: string | ContainerAccessor;
+	/**
+	 * Strict means only use type guards of specificality of 1 (used for is()/validation()).
+	 * For deserialization loose is used.
+	 */
+	validation?: "strict" | "loose";
+	/**
+	 * When this is set all specificalities are used (used in union type guards to detect which member to pick).
+	 */
+	allSpecificalities?: TypeGuardRegistry;
+	propertyName?: string | RuntimeCode;
+	setterDisabled: boolean;
+	parentTypes: Type[];
+	target: "serialize" | "deserialize";
+	protected handledAnnotations: AnnotationDefinition[];
+	constructor(originalSetter: string | ContainerAccessor, originalAccessor: string | ContainerAccessor, compilerContext: CompilerContext, registry: TemplateRegistry, namingStrategy?: NamingStrategy, jitStack?: JitStack, path?: (string | RuntimeCode)[]);
+	isValidation(): boolean;
+	withValidation(validation: this["validation"]): this;
+	includeAllSpecificalities(guardRegistry: TypeGuardRegistry): this;
+	replaceTemplate(template: string): void;
+	/**
+	 * Forks as state, with an empty propertyName.
+	 */
+	fork(setter?: string | ContainerAccessor, accessor?: string | ContainerAccessor, path?: (string | RuntimeCode)[]): TemplateState;
+	fullFork(): TemplateState;
+	forRegistry(registry: TemplateRegistry): this;
+	forPropertyName(name?: string | number | symbol | RuntimeCode): this;
+	disableSetter(): this;
+	enableSetter(): this;
+	/**
+	 * Can be used to track which annotation was already handled. Necessary to use with `isAnnotationHandled` to avoid infinite recursive loops
+	 * when a serializer template issues sub calls depending on annotation data.
+	 */
+	annotationHandled(annotation: AnnotationDefinition<any>): void;
+	isAnnotationHandled(annotation: AnnotationDefinition<any>): boolean;
+	get isSerialization(): boolean;
+	get isDeserialization(): boolean;
+	extendPath(path: string | RuntimeCode | number | symbol): this;
+	assignValidationError(code: string, message: string): string;
+	throwCode(type: Type | string, error?: string, accessor?: string | ContainerAccessor): string;
+	/**
+	 * Adds template code for setting the `this.setter` variable. The expression evaluated in `code` is assigned to `this.setter`.
+	 * `this.accessor` will point now to `this.setter`.
+	 */
+	addSetter(code: string | {
+		toString(): string;
+	}): void;
+	addSetterAndReportErrorIfInvalid(errorCode: string, message: string, code: string): void;
+	/**
+	 * Adds a converter function that is executed on the current `this.accessor` value.
+	 *
+	 * @example
+	 * ```typescript
+	 * serializer.deserializeRegistry.registerClass(Date, (type, state) => {
+	 *     // make sure to check `v` as it is any!
+	 *     state.convert((v: any) => {
+	 *         if ('number' !== typeof v) throw new SerializationError('Expected number');
+	 *         return new Date(v);
+	 *     });
+	 * });
+	 *
+	 * serializer.serializeRegistry.registerClass(Date, (type, state) => {
+	 *     // in serialization `v` is always the specific type
+	 *     state.convert((v: Date) => v.getTime());
+	 * });
+	 * ```
+	 */
+	convert(callback: (value: any) => any): void;
+	/**
+	 * Allows to add a custom code that is executed on the current `this.accessor` value.
+	 *
+	 * @example
+	 * ```typescript
+	 * serializer.deserializeRegistry.addDecorator(
+	 *     isCustomTypeClass,
+	 *     (type, state) => {
+	 *         state.touch((value) => {
+	 *              if ('onLoad' in value) value.onLoad();
+	 *         });
+	 *     }
+	 * );
+	 * ```
+	 */
+	touch(callback: (value: any) => void): void;
+	/**
+	 * Stop executing next templates.
+	 */
+	stop(): void;
+	setVariable(name: string, value?: any): string;
+	setContext(values: {
+		[name: string]: any;
+	}): void;
+	addCode(code: string): void;
+	/**
+	 * Adds template code for setting the `this.setter` variable manually, so use `${state.setter} = value`.
+	 * `this.accessor` will point now to `this.setter`.
+	 */
+	addCodeForSetter(code: string): void;
+	hasSetterCode(): boolean;
+}
+export type Template<T extends Type> = (type: T, state: TemplateState) => void;
+export type TemplateHook = (type: Type, state: TemplateState) => void;
+/**
+ * Just sets the state.setter to state.accessor without any modification.
+ */
+export declare function noopTemplate(type: Type, state: TemplateState): void;
+interface TemplateDecorator {
+	predicate: (type: Type) => boolean;
+	template: Template<any>;
+}
+export declare class TemplateRegistry {
+	serializer: Serializer;
+	protected static ids: number;
+	id: number;
+	protected templates: {
+		[kind in ReflectionKind]?: Template<any>[];
+	};
+	protected decorator: TemplateDecorator[];
+	preHooks: TemplateHook[];
+	postHooks: TemplateHook[];
+	classTemplates: Map<ClassType<any>, Template<any>[]>;
+	constructor(serializer?: Serializer);
+	clear(): void;
+	get(type: Type): Template<Type>[];
+	getDecorator(type: Type): Template<Type>[];
+	/**
+	 * Registers a template for all binary classes: ArrayBuffer, Uint8Array, Int8Array, etc.
+	 */
+	registerBinary(template: Template<TypeClass>): void;
+	/**
+	 * Registers a template for a given class type.
+	 *
+	 * As soon as a single template has registered for the given classType the template registry
+	 * only returns templates for this particular classType and omits all general purpose ReflectionKind.class templates for this particular classType.
+	 */
+	registerClass(classType: ClassType, template: Template<TypeClass>): void;
+	prependClass(classType: ClassType, template: Template<TypeClass>): void;
+	appendClass(classType: ClassType, template: Template<TypeClass>): void;
+	protected getClassTemplates(classType: ClassType): Template<TypeClass>[];
+	addPreHook(callback: TemplateHook): void;
+	addPostHook(callback: TemplateHook): void;
+	/**
+	 * Removes all registered templates.
+	 */
+	unregister(kind: ReflectionKind): void;
+	/**
+	 * Registers a new template and replaces all existing (added via register,prepend,append).
+	 */
+	register<T extends ReflectionKind>(kind: T, template: Template<FindType<Type, T>>): void;
+	/**
+	 * Registers additional templates that handle type decorators/annotations. The templates can safely assume that the given type in `state.accessor`
+	 * is already type-checked to be `T`.
+	 *
+	 * Decorator templates run last (after normal templates and postHook).
+	 *
+	 * This split between register and registerForDecorator is made to have a distinction between native type templates and additional user-made templates.
+	 * This allows to fetch only decorator templates and decide upon the result whether additional code is necessary or not. (this would not be possible
+	 * if everything is added to the `register` call that does always the basic checks).
+	 */
+	addDecorator(predicate: (type: Type) => boolean, template: Template<Type>): void;
+	/**
+	 * Removes all registered decorators for a certain type.
+	 */
+	removeDecorator(type: Type): void;
+	prepend<T extends ReflectionKind>(kind: T, template: Template<FindType<Type, T>>): void;
+	append<T extends ReflectionKind>(kind: T, template: Template<FindType<Type, T>>): void;
+}
+/**
+ * To avoid circular builds, class/object literal code is extract to its own function.
+ * if this returns true, code is put into state to call an already existing function.
+ */
+export declare function callExtractedFunctionIfAvailable(state: TemplateState, type: Type): boolean;
+export declare function extractStateToFunctionAndCallIt(state: TemplateState, type: Type): {
+	setFunction: (fn: Function) => {
+		fn: Function | undefined;
+	};
+	id: number;
+	state: TemplateState;
+};
+export declare function buildFunction(state: TemplateState, type: Type): Function;
+export declare function executeTemplates(state: TemplateState, type: Type, withLoose?: boolean, withCache?: boolean): string;
+export declare function createConverterJSForMember(property: ReflectionProperty | TypeProperty | TypePropertySignature | TypeIndexSignature, state: TemplateState, undefinedSetterCode?: string, nullSetterCode?: string): string;
+export declare function inAccessor(accessor: ContainerAccessor | string): string;
+export declare function deserializeEmbedded(type: TypeClass | TypeObjectLiteral, state: TemplateState, container?: string): string;
+export declare function getIndexCheck(context: CompilerContext, i: string, type: Type): string;
+/**
+ * Sort, so the order is literal, number, string, symbol.  literal comes first as its the most specific type.
+ * We need to do that for numbers since all keys are string|symbol in runtime, and we need to check if a string is numeric first before falling back to string.
+ */
+export declare function sortSignatures(signatures: TypeIndexSignature[]): void;
+export declare function getStaticDefaultCodeForProperty(member: TypeProperty | TypePropertySignature, setter: string | ContainerAccessor, state: TemplateState): string;
+export declare function getEmbeddedProperty(type: TypeClass | TypeObjectLiteral): TypeProperty | TypePropertySignature | undefined;
+export declare function serializeObjectLiteral(type: TypeObjectLiteral | TypeClass, state: TemplateState): void;
+export declare function typeGuardEmbedded(type: TypeClass | TypeObjectLiteral, state: TemplateState, embedded: EmbeddedOptions): void;
+export declare function typeGuardObjectLiteral(type: TypeObjectLiteral | TypeClass, state: TemplateState): void;
+export declare function serializeArray(type: TypeArray, state: TemplateState): void;
+export declare function typeGuardArray(elementType: Type, state: TemplateState): void;
+export declare function getSetTypeToArray(type: TypeClass): TypeArray;
+export declare function getMapTypeToArray(type: TypeClass): TypeArray;
+export declare function getNTypeToArray(type: TypeClass, n: number): TypeArray;
+export declare function executeTypeArgumentAsArray(type: TypeClass, typeIndex: number, state: TemplateState): void;
+export declare function forwardSetToArray(type: TypeClass, state: TemplateState): void;
+export declare function forwardMapToArray(type: TypeClass, state: TemplateState): void;
+export declare function serializePropertyOrParameter(type: TypePropertySignature | TypeProperty | TypeParameter, state: TemplateState): void;
+export declare function validatePropertyOrParameter(type: TypePropertySignature | TypeProperty | TypeParameter, state: TemplateState): void;
+export declare function handleUnion(type: TypeUnion, state: TemplateState): void;
+export declare function getNameExpression(name: string | number | symbol | undefined, state: TemplateState): string;
+export declare class TypeGuardRegistry {
+	serializer: Serializer;
+	registry: {
+		[specificality: number]: TemplateRegistry;
+	};
+	protected sorted?: [
+		specificality: number,
+		registry: TemplateRegistry
+	][];
+	/**
+	 * Lowest specificality first
+	 */
+	getSortedTemplateRegistries(): [
+		specificality: number,
+		registry: TemplateRegistry
+	][];
+	constructor(serializer: Serializer);
+	clear(): void;
+	/**
+	 *
+	 * @see register() for specificality explanation.
+	 */
+	getRegistry(specificality: number): TemplateRegistry;
+	/**
+	 * Registers a new template and replaces all existing (added via register,prepend,append).
+	 *
+	 * Specificality defines when the given template guard is executed.
+	 *
+	 * - 1 means its used for JS types - exact types. For example for type string `'string' ==== typeof v` is used. Same for number, bigint, and boolean.
+	 *   Guards of this specificality are used for the `is()` function.
+	 *
+	 * - >1 means it acts as a fallback. For example in a union `number | Date`, when a string is given, the Date can allow `string` type as well, so it gets converted to a Date.
+	 *
+	 * - >0 && <1 means its acts as a priority guard. For example in a `string | Date`, a string of date-format is converted to a Date instead of a string. This is necessary
+	 *   to support regular JSON.
+	 *
+	 * - <0, anything below 0 means it can optionally be used for loosely types. This is handy when data comes from a string-only encoding like URL query strings.
+	 *   In this specificality a numeric string is converted to a number or bigint, a 1|0|true|false string converted to boolean .
+	 */
+	register<T extends ReflectionKind>(specificality: number, kind: T, template: Template<FindType<Type, T>>): void;
+	/**
+	 * @see register
+	 */
+	registerClass(specificality: number, classType: ClassType, template: Template<TypeClass>): void;
+	/**
+	 * @see register
+	 */
+	registerBinary(specificality: number, template: Template<TypeClass>): void;
+}
+/**
+ * Default serializer that can convert JS data structures to the target type.
+ * It coerces types, converts object literals to class instances, and has type guards for JS types.
+ *
+ * JSONSerializer has the same but for JSON data structures.
+ */
+export declare class Serializer {
+	name: string;
+	serializeRegistry: TemplateRegistry;
+	deserializeRegistry: TemplateRegistry;
+	typeGuards: TypeGuardRegistry;
+	validators: TemplateRegistry;
+	constructor(name?: string);
+	setExplicitUndefined(type: Type, state: TemplateState): boolean;
+	protected registerValidators(): void;
+	clear(): void;
+	protected registerSerializers(): void;
+	protected registerTypeGuards(): void;
+}
+export declare const serializableKinds: ReflectionKind[];
+export declare class EmptySerializer extends Serializer {
+	constructor(name?: string);
+	protected registerValidators(): void;
+	protected registerSerializers(): void;
+}
+export declare const serializer: Serializer;
+export declare type __ΩSerializationOptions = any[];
+export declare type __ΩSerializeFunction = any[];
+export declare type __ΩGuard = any[];
+export declare type __ΩTemplate = any[];
+export declare type __ΩTemplateHook = any[];
+export type ValidatorMeta<Name extends string, Args extends [
+	...args: any[]
+] = [
+]> = TypeAnnotation<"validator", [
+	Name,
+	Args
+]>;
+export type ValidateFunction = (value: any, type: Type, options: any) => ValidatorError | void;
+export type Validate<T extends ValidateFunction, Options extends Parameters<T>[2] = unknown> = ValidatorMeta<"function", [
+	T,
+	Options
+]>;
+export type Pattern<T extends RegExp> = ValidatorMeta<"pattern", [
+	T
+]>;
+export type Alpha = ValidatorMeta<"alpha">;
+export type Alphanumeric = ValidatorMeta<"alphanumeric">;
+export type Ascii = ValidatorMeta<"ascii">;
+export type Decimal<MinDigits extends number = 1, MaxDigits extends number = 100> = ValidatorMeta<"decimal", [
+	MinDigits,
+	MaxDigits
+]>;
+export type MultipleOf<Num extends number> = ValidatorMeta<"multipleOf", [
+	Num
+]>;
+export type MinLength<Length extends number> = ValidatorMeta<"minLength", [
+	Length
+]>;
+export type MaxLength<Length extends number> = ValidatorMeta<"maxLength", [
+	Length
+]>;
+export type Includes<T extends string | number | boolean> = ValidatorMeta<"includes", [
+	T
+]>;
+export type Excludes<T extends string | number | boolean> = ValidatorMeta<"excludes", [
+	T
+]>;
+export type Minimum<T extends number | bigint> = ValidatorMeta<"minimum", [
+	T
+]>;
+export type Maximum<T extends number | bigint> = ValidatorMeta<"maximum", [
+	T
+]>;
+/**
+ Includes 0. Use PositiveNoZero to exclude 0.
+ */
+export type Positive = ValidatorMeta<"positive", unknown & [
+	true
+]>;
+/**
+ * Includes 0. Use NegativeNoZero to exclude 0.
+ */
+export type Negative = ValidatorMeta<"negative", [
+	true
+]>;
+export type PositiveNoZero = ValidatorMeta<"positive", [
+	false
+]>;
+export type NegativeNoZero = ValidatorMeta<"negative", [
+	false
+]>;
+export type ExclusiveMinimum<T extends number | bigint> = ValidatorMeta<"exclusiveMinimum", [
+	T
+]>;
+export type ExclusiveMaximum<T extends number | bigint> = ValidatorMeta<"exclusiveMaximum", [
+	T
+]>;
+export type BeforeDate<T extends number> = ValidatorMeta<"beforeDate", [
+	T
+]>;
+export type AfterDate<T extends number> = ValidatorMeta<"afterDate", [
+	T
+]>;
+export type BeforeNow = ValidatorMeta<"beforeNow">;
+export type AfterNow = ValidatorMeta<"afterNow">;
+export declare const EMAIL_REGEX: RegExp;
+export type Email = string & Pattern<typeof EMAIL_REGEX>;
+/**
+ * Used in validator functions.
+ */
+export declare class ValidatorError {
+	readonly code: string;
+	readonly message: string;
+	readonly path?: string | undefined;
+	constructor(code: string, message: string, path?: string | undefined);
+}
+/**
+ * The structure of a validation error.
+ *
+ * Path defines the shallow or deep path (using dots).
+ * Message is an arbitrary message in english.
+ *
+ * In validators please use and return `new ValidatorError('code', 'message')` instead.
+ */
+export declare class ValidationErrorItem {
+	/**
+	 * The path to the property. Might be a deep path separated by dot.
+	 */
+	readonly path: string;
+	/**
+	 * A lower cased error code that can be used to identify this error and translate.
+	 */
+	readonly code: string;
+	/**
+	 * Free text of the error.
+	 */
+	readonly message: string;
+	/**
+	 * Optional value that caused the error.
+	 */
+	readonly value?: any | undefined;
+	constructor(
+	/**
+	 * The path to the property. Might be a deep path separated by dot.
+	 */
+	path: string, 
+	/**
+	 * A lower cased error code that can be used to identify this error and translate.
+	 */
+	code: string, 
+	/**
+	 * Free text of the error.
+	 */
+	message: string, 
+	/**
+	 * Optional value that caused the error.
+	 */
+	value?: any | undefined);
+	toString(prefix?: string): string;
+}
+export declare class ValidationError extends CustomError {
+	readonly errors: ValidationErrorItem[];
+	constructor(errors: ValidationErrorItem[], type?: Type);
+	static from(errors: {
+		path: string;
+		message: string;
+		code?: string;
+		value?: any;
+	}[]): ValidationError;
+}
+/**
+ * Returns empty array when valid, or ValidationErrorItem[] with detailed error messages if not valid.
+ *
+ * Returns validation error items when failed. If successful returns an empty array.
+ */
+export declare function validate<T>(data: any, type?: ReceiveType<T>): ValidationErrorItem[];
+export declare function validateFunction<T>(serializerToUse?: Serializer, type?: ReceiveType<T>): (data: T) => ValidationErrorItem[];
+/**
+ * Returns true when valid, and false if not.
+ */
+export declare function validates<T>(data: any, type?: ReceiveType<T>): boolean;
+export declare type __ΩValidatorMeta = any[];
+export declare type __ΩValidateFunction = any[];
+export declare type __ΩValidate = any[];
+export declare type __ΩPattern = any[];
+export declare type __ΩAlpha = any[];
+export declare type __ΩAlphanumeric = any[];
+export declare type __ΩAscii = any[];
+export declare type __ΩDecimal = any[];
+export declare type __ΩMultipleOf = any[];
+export declare type __ΩMinLength = any[];
+export declare type __ΩMaxLength = any[];
+export declare type __ΩIncludes = any[];
+export declare type __ΩExcludes = any[];
+export declare type __ΩMinimum = any[];
+export declare type __ΩMaximum = any[];
+export declare type __ΩPositive = any[];
+export declare type __ΩNegative = any[];
+export declare type __ΩPositiveNoZero = any[];
+export declare type __ΩNegativeNoZero = any[];
+export declare type __ΩExclusiveMinimum = any[];
+export declare type __ΩExclusiveMaximum = any[];
+export declare type __ΩBeforeDate = any[];
+export declare type __ΩAfterDate = any[];
+export declare type __ΩBeforeNow = any[];
+export declare type __ΩAfterNow = any[];
+export declare type __ΩEmail = any[];
+export type RuntimeStackEntry = Type | Object | (() => ClassType | Object) | string | number | boolean | bigint;
+export type Packed = (RuntimeStackEntry | string)[] & {
+	__is?: (data: any) => boolean;
+} & {
+	__type?: Type;
+} & {
+	__unpack?: PackStruct;
+};
+export declare class PackStruct {
+	ops: ReflectionOp[];
+	stack: RuntimeStackEntry[];
+	constructor(ops?: ReflectionOp[], stack?: RuntimeStackEntry[]);
+}
+export declare function encodeOps(ops: ReflectionOp[]): string;
+/**
+ * Pack a pack structure (op instructions + pre-defined stack) and create a encoded version of it.
+ */
+export declare function pack(packOrOps: PackStruct | ReflectionOp[]): Packed;
+export declare function unpack(pack: Packed): PackStruct;
+export declare function resolvePacked(type: Packed, args?: any[], options?: ReflectOptions): Type;
+/**
+ * Computes a type of given object. This function caches the result on the object itself.
+ * This is the slow path, using the full type virtual machine to resolve the type.
+ * If you want to handle some fast paths (including cache), try using resolveReceiveType() instead.
+ */
+export declare function resolveRuntimeType(o: ClassType | Function | Packed | any, args?: any[], options?: ReflectOptions): Type;
+interface Frame {
+	index: number;
+	startIndex: number;
+	variables: number;
+	inputs: RuntimeStackEntry[];
+	previous?: Frame;
+	mappedType?: Loop;
+	distributiveLoop?: Loop;
+}
+declare class Loop {
+	fromType: Type;
+	private types;
+	private i;
+	constructor(fromType: Type);
+	next(): Type | undefined;
+}
+interface Program {
+	frame: Frame;
+	active: boolean;
+	stack: (RuntimeStackEntry | Type)[];
+	stackPointer: number;
+	program: number;
+	depth: number;
+	initialStack: (RuntimeStackEntry | Type)[];
+	resultType: Type;
+	ops: ReflectionOp[];
+	end: number;
+	inputs: RuntimeStackEntry[];
+	resultTypes?: Type[];
+	started: number;
+	typeParameters?: Type[];
+	previous?: Program;
+	directReturn?: boolean;
+	object?: ClassType | Function | Packed | any;
+}
+export interface ReflectOptions {
+	/**
+	 *
+	 */
+	reuseCached?: boolean;
+	inline?: boolean;
+	typeName?: string;
+}
+/**
+ * @reflection never
+ */
+export declare class Processor {
+	static typeProcessor?: Processor;
+	static get(): Processor;
+	private cache;
+	/**
+	 * Linked list of programs to execute. For each external call to external program will this be changed.
+	 */
+	protected program: Program;
+	reflect(object: ClassType | Function | Packed | any, inputs?: RuntimeStackEntry[], options?: ReflectOptions): Type;
+	_reflect(object: ClassType | Function | Packed | any, inputs?: RuntimeStackEntry[], options?: ReflectOptions): Type;
+	run(ops: ReflectionOp[], initialStack: RuntimeStackEntry[], inputs?: RuntimeStackEntry[], object?: ClassType | Function | Packed | any): Type;
+	runProgram(program: Program): Type;
+	/**
+	 * Semantic is important here: This triggers true only for the very last op of a program.
+	 * If it is checked in OP inline then it could be true or false:
+	 *
+	 * type t<T> = T; => false since we have nominal past the inline op
+	 * typeOf<T>() => true since we have no nominal past the inline op
+	 */
+	protected isEnded(): boolean;
+	/**
+	 * Runs all scheduled programs until termination.
+	 */
+	protected loop(until?: Program): Type | RuntimeStackEntry;
+	private handleTuple;
+	private handleIntersection;
+	private handleDistribute;
+	private handleIndexAccess;
+	private handleKeyOf;
+	private handleMappedType;
+	private handleTemplateLiteral;
+	protected push(entry: RuntimeStackEntry, program?: Program): void;
+	protected pop(): RuntimeStackEntry;
+	protected pushFrame(): void;
+	protected popFrame(): RuntimeStackEntry[];
+	/**
+	 * Create a new stack frame with the calling convention.
+	 */
+	protected call(program: number, jumpBackTo?: number): void;
+	/**
+	 * Removes the stack frame, and puts the latest entry on the stack.
+	 */
+	protected returnFrame(): void;
+	protected pushType(type: Type): void;
+	protected eatParameter(): RuntimeStackEntry;
+}
+export declare function typeInfer(value: any): Type;
+export declare function getEnumType(values: any[]): Type;
+export declare type __ΩRuntimeStackEntry = any[];
+export declare type __ΩPacked = any[];
+export declare type __ΩReflectOptions = any[];
+/**
+ * Receives the runtime type of template argument.
+ *
+ * Use
+ *
+ * ```typescript
+ *
+ * function f<T>(type?: ReceiveType<T>): Type {
+ *     return resolveReceiveType(type);
+ * }
+ *
+ * ```
+ */
+export type ReceiveType<T> = Packed | Type | ClassType<T>;
+export declare function resolveReceiveType(type?: Packed | Type | ClassType | AbstractClassType | ReflectionClass<any>): Type;
+export declare function reflect(o: any, ...args: any[]): Type;
+export declare function reflectOrUndefined(o: any, ...args: any[]): Type | undefined;
+export declare function valuesOf<T>(args?: any[], p?: ReceiveType<T>): (string | number | symbol | Type)[];
+export declare function propertiesOf<T>(args?: any[], p?: ReceiveType<T>): (string | number | symbol | Type)[];
+export declare function getNominalId<T>(args?: any[], p?: ReceiveType<T>): number | undefined;
+export declare function typeOf<T>(args?: any[], p?: ReceiveType<T>): Type;
+export declare function removeTypeName<T extends Type>(type: T): T;
+export declare function removeNominal<T extends Type | undefined | Type[]>(type: T): T;
+export declare function getProperty(type: TypeObjectLiteral | TypeClass, memberName: number | string | symbol): TypeProperty | TypePropertySignature | undefined;
+export declare function toSignature(type: TypeProperty | TypeMethod | TypePropertySignature | TypeMethodSignature): TypePropertySignature | TypeMethodSignature;
+export declare function hasCircularReference(type: Type): any;
+export declare function visit(type: Type, visitor: (type: Type, path: string) => false | void, onCircular?: () => void): void;
+/**
+ * @reflection never
+ */
+export declare class ReflectionParameter {
+	readonly parameter: TypeParameter;
+	readonly reflectionFunction: ReflectionMethod | ReflectionFunction;
+	type: Type;
+	constructor(parameter: TypeParameter, reflectionFunction: ReflectionMethod | ReflectionFunction);
+	getType(): Type;
+	getName(): string;
+	get name(): string;
+	isOptional(): boolean;
+	hasDefault(): boolean;
+	isValueRequired(): boolean;
+	getDefaultValue(): any;
+	setDefaultValue(value: any): void;
+	hasDefaultFunctionExpression(): boolean;
+	applyDecorator(t: TData): void;
+	getVisibility(): ReflectionVisibility | undefined;
+	isPublic(): boolean;
+	isProtected(): boolean;
+	isPrivate(): boolean;
+	isReadonly(): boolean;
+	setTags(tags: TagsReflection): void;
+	getTags(): TagsReflection;
+	isHidden(): boolean;
+	isIgnored(): boolean;
+	isInternal(): boolean;
+	getAlias(): string[];
+	getTitle(): string | undefined;
+	getPermission(): string[];
+	getDomain(): string | undefined;
+	/**
+	 * True if the parameter becomes a property in the class.
+	 * This is the case for parameters in constructors with visibility or readonly.
+	 *
+	 * ```typescript
+	 * class User {
+	 *    constructor(public name: string) {}
+	 * }
+	 */
+	isProperty(): boolean;
+}
+/**
+ * @reflection never
+ */
+export declare class ReflectionFunction {
+	readonly type: TypeMethod | TypeMethodSignature | TypeFunction;
+	parameters: ReflectionParameter[];
+	parameterAliases: Map<string, string>;
+	description: string;
+	constructor(type: TypeMethod | TypeMethodSignature | TypeFunction);
+	static from(fn: Function): ReflectionFunction;
+	getParameterNames(): string[];
+	hasParameter(name: string | number | symbol): boolean;
+	getParameterOrUndefined(name: string | number | symbol): ReflectionParameter | undefined;
+	getParameter(name: string | number | symbol): ReflectionParameter;
+	getParameterType(name: string | number | symbol): Type | undefined;
+	getParameters(): ReflectionParameter[];
+	getReturnType(): Type;
+	getName(): number | string | symbol;
+	getDescription(): string;
+	get name(): string;
+	setTags(tags: TagsReflection): void;
+	getTags(): TagsReflection;
+	isHidden(): boolean;
+	isReadonly(): boolean;
+	isIgnored(): boolean;
+	isInternal(): boolean;
+	getAlias(): string[];
+	getTitle(): string | undefined;
+	getPermission(): string[];
+	getDomain(): string | undefined;
+}
+/**
+ * @reflection never
+ */
+export declare class ReflectionMethod extends ReflectionFunction {
+	type: TypeMethod | TypeMethodSignature;
+	reflectionClass: ReflectionClass<any>;
+	/**
+	 * Whether this method acts as validator.
+	 */
+	validator: boolean;
+	constructor(type: TypeMethod | TypeMethodSignature, reflectionClass: ReflectionClass<any>);
+	setType(method: TypeMethod | TypeMethodSignature): void;
+	applyDecorator(data: TData): void;
+	clone(reflectionClass?: ReflectionClass<any>, method?: TypeMethod | TypeMethodSignature): ReflectionMethod;
+	isOptional(): boolean;
+	setTags(tags: TagsReflection): void;
+	getTags(): TagsReflection;
+	isHidden(): boolean;
+	isIgnored(): boolean;
+	isReadonly(): boolean;
+	isInternal(): boolean;
+	getAlias(): string[];
+	getTitle(): string | undefined;
+	getPermission(): string[];
+	getDomain(): string | undefined;
+}
+export declare function resolveForeignReflectionClass(property: ReflectionProperty): ReflectionClass<any>;
+/**
+ * Resolved the class/object ReflectionClass of the given TypeClass|TypeObjectLiteral
+ */
+export declare function resolveClassType(type: Type): ReflectionClass<any>;
+/**
+ * @reflection never
+ */
+export declare class ReflectionProperty {
+	property: TypeProperty | TypePropertySignature;
+	reflectionClass: ReflectionClass<any>;
+	jsonType?: Type;
+	serializer?: SerializerFn;
+	deserializer?: SerializerFn;
+	data: {
+		[name: string]: any;
+	};
+	/**
+	 * The type of the property, not the property itself.
+	 *
+	 * Note: If the property is optional via `property?: T`, this information
+	 * is not available here. It's on `property`.
+	 * Use `isOptional()` instead, which handles this case plus the case
+	 * where optionality is given via union of T and undefined.
+	 */
+	type: Type;
+	symbol: symbol;
+	protected cachedResolvedReflectionClass?: ReflectionClass<any>;
+	constructor(property: TypeProperty | TypePropertySignature, reflectionClass: ReflectionClass<any>);
+	setType(type: Type): void;
+	isPrimaryKey(): boolean;
+	isEmbedded(): boolean;
+	/**
+	 * Returns the sub type if available (for arrays for example).
+	 *
+	 * @throws Error if the property type does not support sub types.
+	 */
+	getSubType(): Type;
+	/**
+	 * If undefined, it's not an embedded class.
+	 */
+	getEmbedded(): {
+		prefix?: string;
+	} | undefined;
+	isBackReference(): boolean;
+	isDatabaseSkipped(database: string): boolean;
+	isDatabaseMigrationSkipped(database: string): boolean;
+	getBackReference(): BackReferenceOptionsResolved;
+	isAutoIncrement(): boolean;
+	isReference(): boolean;
+	isArray(): boolean;
+	isDate(): boolean;
+	isNumber(): boolean;
+	getForeignKeyName(): string;
+	getReference(): ReferenceOptions | undefined;
+	getGroups(): string[];
+	isInGroup(...group: string[]): boolean;
+	getExcluded(): string[];
+	isSerializerExcluded(name: string): boolean;
+	getData(): {
+		[name: string]: any;
+	};
+	/**
+	 * Returns the ReflectionClass of the reference class/object literal.
+	 *
+	 * @throws Error if the property is not from type TypeClass or TypeObjectLiteral
+	 */
+	getResolvedReflectionClass(): ReflectionClass<any>;
+	/**
+	 * If undefined the property is not an index.
+	 * A unique property is defined as index with IndexOptions.unique=true.
+	 */
+	getIndex(): IndexOptions | undefined;
+	/**
+	 * Returns database specific options, if defined
+	 *
+	 * ```typescript
+	 * interface User {
+	 *     logins: number & DatabaseField<{type: 'integer(8)'}>;
+	 *
+	 *     //of for a specific db engine
+	 *     logins: number & Sqlite<{type: 'integer(8)'}>;
+	 * }
+	 *
+	 * ```
+	 */
+	getDatabase<T extends DatabaseFieldOptions>(name: string): T | undefined;
+	clone(reflectionClass?: ReflectionClass<any>, property?: TypeProperty | TypePropertySignature): ReflectionProperty;
+	applyDecorator(data: TData): void;
+	getName(): number | string | symbol;
+	getNameAsString(): string;
+	get name(): string;
+	getKind(): ReflectionKind;
+	getType(): Type;
+	getDescription(): string;
+	/**
+	 * Whether a value is required from serialization point of view.
+	 * If this property has for example a default value (set via constructor or manually via t.default),
+	 * then the value is not required to instantiate the property value.
+	 */
+	isValueRequired(): boolean;
+	/**
+	 * Returns true when `undefined` or a missing value is allowed at the class itself.
+	 * This is now only true when `optional` is set, but also when type is `any`.
+	 */
+	isActualOptional(): boolean;
+	/**
+	 * If the property is actual optional or is an union with undefined in it.
+	 */
+	isOptional(): boolean;
+	setOptional(v: boolean): void;
+	isNullable(): boolean;
+	isReadonly(): boolean;
+	isAbstract(): boolean;
+	hasDefault(): boolean;
+	getDefaultValue(): any;
+	setDefaultValue(value: any): void;
+	hasDefaultFunctionExpression(): boolean;
+	getDefaultValueFunction(): (() => any) | undefined;
+	getVisibility(): ReflectionVisibility | undefined;
+	isPublic(): boolean;
+	isProtected(): boolean;
+	isPrivate(): boolean;
+	setTags(tags: TagsReflection): void;
+	getTags(): TagsReflection;
+	isHidden(): boolean;
+	isIgnored(): boolean;
+	isInternal(): boolean;
+	getAlias(): string[];
+	getTitle(): string | undefined;
+	getPermission(): string[];
+	getDomain(): string | undefined;
+}
+export declare const reflectionClassSymbol: unique symbol;
+export interface SerializerFn {
+	(value: any, property: ReflectionProperty): any;
+}
+export declare class TData {
+	validator: boolean;
+	validators: ValidateFunction[];
+	type?: Packed | Type | ClassType;
+	data: {
+		[name: string]: any;
+	};
+	serializer?: SerializerFn;
+	deserializer?: SerializerFn;
+}
+export declare class EntityData {
+	name?: string;
+	collectionName?: string;
+	databaseSchemaName?: string;
+	disableConstructor: boolean;
+	data: {
+		[name: string]: any;
+	};
+	indexes: {
+		names: string[];
+		options: IndexOptions;
+	}[];
+	singleTableInheritance?: true;
+}
+/**
+ * @reflection never
+ */
+export declare class ReflectionClass<T> {
+	readonly type: TypeClass | TypeObjectLiteral;
+	readonly parent?: ReflectionClass<any> | undefined;
+	/**
+	 * The description, extracted from the class JSDoc @description.
+	 */
+	description: string;
+	/**
+	 * The tags, extracted from the class JSDoc @tag.
+	 */
+	tags?: TagsReflection;
+	/**
+	 * A place where arbitrary data is stored, usually set via decorator t.data.
+	 */
+	data: {
+		[name: string]: any;
+	};
+	/**
+	 * The unique entity name.
+	 *
+	 * ```typescript
+	 * @entity.name('user')
+	 * class User {
+	 *
+	 * }
+	 * ```
+	 */
+	name?: string;
+	databaseSchemaName?: string;
+	disableConstructor: boolean;
+	/**
+	 * The collection name, used in database context (also known as table name).
+	 *
+	 * Usually, if this is not set, `name` will be used.
+	 *
+	 * ```typescript
+	 * @entity.collection('users').name('user')
+	 * class User {
+	 *
+	 * }
+	 * ```
+	 */
+	collectionName?: string;
+	/**
+	 * True when @entity.singleTableInheritance was set.
+	 */
+	singleTableInheritance: boolean;
+	/**
+	 * Contains all indexed, multi-field using entity.index and all indexes from properties.
+	 *
+	 * ```typescript
+	 * @entity
+	 *    .collection('users')
+	 *    .name('user')
+	 *    .index(['username', 'email'])
+	 *    .index(['email', 'region'], {unique: true})
+	 * class User {
+	 *     username: string;
+	 *     email: string;
+	 * }
+	 * ```
+	 */
+	indexes: {
+		names: string[];
+		options: IndexOptions;
+	}[];
+	protected propertyNames: string[];
+	protected methodNames: string[];
+	protected properties: ReflectionProperty[];
+	protected propertyAliases: Map<string, string>;
+	protected methods: ReflectionMethod[];
+	protected methodAliases: Map<string, string>;
+	/**
+	 * References and back references.
+	 */
+	protected references: ReflectionProperty[];
+	protected primaries: ReflectionProperty[];
+	protected autoIncrements: ReflectionProperty[];
+	/**
+	 * If a custom validator method was set via @t.validator, then this is the method name.
+	 */
+	validationMethod?: string | symbol | number | TypeTemplateLiteral;
+	/**
+	 * A class using @t.singleTableInheritance registers itself in this array in its super class.
+	 */
+	subClasses: ReflectionClass<any>[];
+	constructor(type: TypeClass | TypeObjectLiteral, parent?: ReflectionClass<any> | undefined);
+	clone(): ReflectionClass<any>;
+	toString(): string;
+	getPropertiesDeclaredInConstructor(): ReflectionProperty[];
+	clearJitContainer(): void;
+	getJitContainer(): any;
+	getClassType(): ClassType;
+	getClassName(): string;
+	createDefaultObject(): object;
+	getName(): string;
+	getDescription(): string;
+	getCollectionName(): string;
+	hasProperty(name: string | symbol | number): boolean;
+	hasMethod(name: string | symbol | number): boolean;
+	getPrimary(): ReflectionProperty;
+	getAutoIncrement(): ReflectionProperty | undefined;
+	isSchemaOf(classType: ClassType): boolean;
+	hasPrimary(): boolean;
+	getPrimaries(): ReflectionProperty[];
+	/**
+	 * Returns the ReflectionClass object from parent/super class, if available.
+	 */
+	getSuperReflectionClass(): ReflectionClass<any> | undefined;
+	removeProperty(name: string | number | symbol): void;
+	registerProperty(property: ReflectionProperty): void;
+	addProperty(prop: {
+		name: number | string | symbol;
+		optional?: true;
+		readonly?: true;
+		description?: string;
+		visibility?: ReflectionVisibility;
+		type: Type;
+		default?: any;
+		tags?: TagsReflection;
+	}): ReflectionProperty;
+	registerMethod(method: ReflectionMethod): void;
+	add(member: Type): void;
+	assignedSingleTableInheritanceSubClassesByIdentifier?: {
+		[id: string]: ReflectionClass<any>;
+	};
+	getAssignedSingleTableInheritanceSubClassesByIdentifier(): {
+		[id: string]: ReflectionClass<any>;
+	} | undefined;
+	hasSingleTableInheritanceSubClasses(): boolean;
+	getSingleTableInheritanceDiscriminantName(): string;
+	applyDecorator(data: EntityData): void;
+	static from<T>(classTypeIn?: ReceiveType<T> | AbstractClassType<T> | TypeClass | TypeObjectLiteral | ReflectionClass<any>, args?: any[]): ReflectionClass<T>;
+	getIndexSignatures(): void;
+	getPropertyNames(): (string | number | symbol)[];
+	getProperties(): ReflectionProperty[];
+	getPropertiesInGroup(...group: string[]): ReflectionProperty[];
+	getMethodNames(): (string | number | symbol)[];
+	getMethods(): ReflectionMethod[];
+	/**
+	 * Returns references and back references.
+	 */
+	getReferences(): ReflectionProperty[];
+	getConstructorOrUndefined(): ReflectionMethod | undefined;
+	getPropertyOrUndefined(name: string | number | symbol | TypeTemplateLiteral): ReflectionProperty | undefined;
+	getProperty(name: string | number | symbol): ReflectionProperty;
+	getMethodParameters(name: string | number | symbol): ReflectionParameter[];
+	getMethodOrUndefined(name: string | number | symbol | TypeTemplateLiteral): ReflectionMethod | undefined;
+	getMethod(name: string | number | symbol): ReflectionMethod;
+	hasCircularReference(): boolean;
+	serializeType(): SerializedTypes;
+	setTags(tags: TagsReflection): void;
+	getTags(): TagsReflection;
+	isHidden(): boolean;
+	isIgnored(): boolean;
+	isInternal(): boolean;
+	isReadonly(): boolean;
+	getAlias(): string[];
+	getTitle(): string | undefined;
+	getPermission(): string[];
+	getDomain(): string | undefined;
+	/**
+	 * All references have a counter-part. This methods finds it and errors if not possible.
+	 *
+	 * If the given reference is a owning reference it finds the correct backReference,
+	 *    which can be found by checking all reference options.mappedBy.
+	 *
+	 * If the given reference is a back reference it finds the owning reference,
+	 *    which can be found by using its options.mappedBy.
+	 *
+	 * Alternatively we simply check for resolvedClassType to be given `classType`, and if only one
+	 * found, we return it. When more than one found, we throw an error saying the user he
+	 * should make its relation mapping not ambiguous.
+	 */
+	findReverseReference(toClassType: ClassType, fromReference: ReflectionProperty): ReflectionProperty;
+	extractPrimaryKey(item: object): Partial<T>;
+}
+export declare type __ΩReceiveType = any[];
+export declare type __ΩSerializerFn = any[];
+/**
+ * This is a comparator function for the snapshots. They are either string, number, boolean, array, or objects.
+ * No date, moment, or custom classes involved here.
+ */
+export declare function genericEqual(a: any, b: any): boolean;
+export declare function getChangeDetector<T extends object>(classSchema: ReflectionClass<T>): (last: any, current: any, item: T) => ItemChanges<T> | undefined;
+export declare function buildChanges<T extends object>(classSchema: ReflectionClass<T>, lastSnapshot: any, item: T): Changes<T>;
+export declare enum UnpopulatedCheck {
+	None = 0,//returns undefined
+	Throw = 1,//throws regular error
+	ReturnSymbol = 2
+}
+export declare const unpopulatedSymbol: unique symbol;
+export interface TypeSettings {
+	registeredEntities: {
+		[name: string]: ClassType;
+	};
+	unpopulatedCheck: UnpopulatedCheck;
+}
+export declare const typeSettings: TypeSettings;
+export interface TypedArrayClassType<T> {
+	new (...args: any[]): T;
+	readonly BYTES_PER_ELEMENT: number;
+}
+export interface TypedArray {
+	/**
+	 * The size in bytes of each element in the array.
+	 */
+	readonly BYTES_PER_ELEMENT: number;
+	/**
+	 * The ArrayBuffer instance referenced by the array.
+	 */
+	readonly buffer: ArrayBufferLike;
+	/**
+	 * The length of the array.
+	 */
+	readonly length: number;
+	/**
+	 * The length in bytes of the array.
+	 */
+	readonly byteLength: number;
+	/**
+	 * The offset in bytes of the array.
+	 */
+	readonly byteOffset: number;
+}
+export declare function nodeBufferToTypedArray<K>(buf: Buffer, type: TypedArrayClassType<K>): K;
+/**
+ * When using Buffer.from() node is using a buffer from the buffer pool.
+ * This makes it necessary to create the given TypedArray using byteOffset and byteLength accordingly.
+ *
+ * Note: The created TypedArray.buffer is pointing probably to a larger Buffer. Make sure
+ * to use byteLength/byeOffset correctly or use typedArrayToArrayBuffer() if you want to use
+ * a raw ArrayBuffer that represents the actual data correctly.
+ */
+export declare function base64ToTypedArray<K>(base64: string, type: TypedArrayClassType<K>): K;
+/**
+ * Creates a new fresh ArrayBuffer with given data.
+ * Note: Regular Buffer.from(base64, 'base64) creates in Node a shared buffer, this function makes
+ * sure a copy happens and the ArrayBuffer is not shared.
+ */
+export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+/**
+ * When using Buffer.from() node is using a buffer from the buffer pool.
+ * This makes it necessary to create the a new ArrayType using slice to make a copy.
+ *
+ * This makes a copy.
+ */
+export declare function nodeBufferToArrayBuffer<K>(buf: Uint8Array | ArrayBuffer): ArrayBuffer;
+/**
+ * In node environment the TypedArray.buffer is probably a larger buffer from the buffer pool.
+ * This makes it necessary to create a Buffer with offset & length so that it accurately represents
+ * the given TypedArray.
+ */
+export declare function typedArrayToBuffer<K>(typedArray: TypedArray): Buffer;
+export declare function arrayBufferToBase64(arrayBuffer: ArrayBuffer): string;
+export declare function typedArrayToBase64(typedArray: TypedArray): string;
+/**
+ * Same as Buffer.from() but creates a ArrayBuffer that is not shared.
+ */
+export declare function arrayBufferFrom(data: string, encoding?: string): ArrayBuffer;
+/**
+ * Same as Buffer.from(arrayBuffer).toString(encoding), but more in line with the current API.
+ */
+export declare function arrayBufferTo(arrayBuffer: ArrayBuffer, encoding?: string | "utf8" | "base64" | "ascii"): string;
+export declare type __ΩUnpopulatedCheck = any[];
+export declare type __ΩTypeSettings = any[];
+export declare type __ΩTypedArrayClassType = any[];
+export declare type __ΩTypedArray = any[];
+export type ClassDecoratorFn = (classType: AbstractClassType, property?: string, parameterIndexOrDescriptor?: any) => void;
+export type PropertyDecoratorFn = (prototype: object, property?: number | string | symbol, parameterIndexOrDescriptor?: any) => void;
+export type FluidDecorator<T, D extends Function> = {
+	[name in keyof T]: T[name] extends (...args: infer K) => any ? (...args: K) => D & FluidDecorator<T, D> : D & FluidDecorator<T, D> & {
+		_data: ExtractApiDataType<T>;
+	};
+};
+export declare function createFluidDecorator<API extends APIClass<any> | APIProperty<any>, D extends Function>(api: API, modifier: {
+	name: string;
+	args?: any;
+	Ω?: any;
+}[], collapse: (modifier: {
+	name: string;
+	args?: any;
+}[], target: any, property?: string, parameterIndexOrDescriptor?: any) => void, returnCollapse?: boolean, fluidFunctionSymbol?: symbol): FluidDecorator<ExtractClass<API>, D>;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+export type Merge<U> = {
+	[K in keyof U]: U[K] extends ((...a: infer A) => infer R) ? R extends DualDecorator ? (...a: A) => PropertyDecoratorFn & R & U : (...a: A) => R : never;
+};
+/**
+ * A dual decorator is a decorator that can be used on a class and class property.
+ */
+export type DualDecorator = void & {
+	__DualDecorator?: true;
+};
+export declare function mergeDecorator<T extends any[]>(...args: T): Merge<Omit<UnionToIntersection<T[number]>, "_fetch" | "t">>;
+export interface ClassApiTypeInterface<T> {
+	t: T;
+	onDecorator?: (classType: ClassType, property?: string, parameterIndexOrDescriptor?: any) => void;
+}
+export type APIClass<T> = ClassType<ClassApiTypeInterface<T>>;
+export type ExtractClass<T> = T extends ClassType<infer K> ? K : never;
+export type ExtractApiDataType<T> = T extends AbstractClassType<infer K> ? K extends {
+	t: infer P;
+} ? P : never : (T extends {
+	t: infer P;
+} ? P : never);
+export type ClassDecoratorResult<API extends APIClass<any>> = FluidDecorator<ExtractClass<API>, ClassDecoratorFn> & DecoratorAndFetchSignature<API, ClassDecoratorFn>;
+export declare function createClassDecoratorContext<API extends APIClass<any>, T = ExtractApiDataType<API>>(apiType: API): ClassDecoratorResult<API>;
+export interface PropertyApiTypeInterface<T> {
+	t: T;
+	onDecorator?: (target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any) => void;
+}
+export type APIProperty<T> = ClassType<PropertyApiTypeInterface<T>>;
+export type DecoratorAndFetchSignature<API extends APIProperty<any>, FN extends (...args: any[]) => any> = FN & {
+	_fetch: (...args: Parameters<FN>) => ExtractApiDataType<API> | undefined;
+};
+export type PropertyDecoratorResult<API extends APIProperty<any>> = FluidDecorator<ExtractClass<API>, PropertyDecoratorFn> & DecoratorAndFetchSignature<API, PropertyDecoratorFn>;
+export declare function createPropertyDecoratorContext<API extends APIProperty<any>>(apiType: API): PropertyDecoratorResult<API>;
+export type FreeDecoratorFn<API> = {
+	(target?: any, property?: number | string | symbol, parameterIndexOrDescriptor?: any): ExtractApiDataType<API>;
+} & {
+	_data: ExtractApiDataType<API>;
+};
+export type FreeFluidDecorator<API> = {
+	[name in keyof ExtractClass<API>]: ExtractClass<API>[name] extends (...args: infer K) => any ? (...args: K) => FreeFluidDecorator<API> : FreeFluidDecorator<API>;
+} & FreeDecoratorFn<API>;
+export type FreeDecoratorResult<API extends APIClass<any>> = FreeFluidDecorator<API> & {
+	_fluidFunctionSymbol: symbol;
+};
+export declare function createFreeDecoratorContext<API extends APIClass<any>, T = ExtractApiDataType<API>>(apiType: API): FreeDecoratorResult<API>;
+export declare function isDecoratorContext<API extends APIClass<any>>(context: FreeDecoratorResult<API>, fn: Function): fn is FreeFluidDecorator<API>;
+export declare type __ΩClassDecoratorFn = any[];
+export declare type __ΩPropertyDecoratorFn = any[];
+export declare type __ΩFluidDecorator = any[];
+export declare type __ΩUnionToIntersection = any[];
+export declare type __ΩMerge = any[];
+export declare type __ΩDualDecorator = any[];
+export declare type __ΩClassApiTypeInterface = any[];
+export declare type __ΩAPIClass = any[];
+export declare type __ΩExtractClass = any[];
+export declare type __ΩExtractApiDataType = any[];
+export declare type __ΩClassDecoratorResult = any[];
+export declare type __ΩPropertyApiTypeInterface = any[];
+export declare type __ΩAPIProperty = any[];
+export declare type __ΩDecoratorAndFetchSignature = any[];
+export declare type __ΩPropertyDecoratorResult = any[];
+export declare type __ΩFreeDecoratorFn = any[];
+export declare type __ΩFreeFluidDecorator = any[];
+export declare type __ΩFreeDecoratorResult = any[];
+declare class TDecorator {
+	t: TData;
+	onDecorator(target: any, property?: string, parameterIndexOrDescriptor?: any): void;
+	type<T>(type: ReceiveType<T> | ClassType): void;
+	/**
+	 * Marks the method as validator. Is executed for each is/validate call.
+	 *
+	 * ```typescript
+	 *
+	 * class MyClass {
+	 *     field1: string;
+	 *     field2: string;
+	 *
+	 *     @t.validator
+	 *     validate(): ValidatorError | undefined {
+	 *          return new ValidatorError('invalid', 'MyClass is invalid');
+	 *     }
+	 * }
+	 *
+	 * ```
+	 */
+	get validator(): void;
+	validate(...validators: ValidateFunction[]): void;
+	serialize(serializer: SerializerFn): void;
+	deserialize(deserializer: SerializerFn): void;
+	data(name: string, value: any): void;
+}
+export declare const t: PropertyDecoratorResult<typeof TDecorator>;
+declare class EntityDecorator {
+	t: EntityData;
+	onDecorator(target: any): void;
+	name(name: string): void;
+	collection(name: string): void;
+	/**
+	 * Disables calling the constructor when deserializing.
+	 */
+	disableConstructor(): void;
+	databaseSchema(name: string): void;
+	index(names: string[], options?: IndexOptions): void;
+	singleTableInheritance(): void;
+	data(name: string, value: any): void;
+	/**
+	 * Exclude this entity from database migrations.
+	 */
+	excludeMigration(): void;
+}
+export declare const entity: ClassDecoratorResult<typeof EntityDecorator>;
+interface DeferredDecorator {
+	data: any;
+	target: any;
+	property?: string;
+	parameterIndexOrDescriptor?: any;
+}
+export declare function isWithDeferredDecorators(obj: any): obj is {
+	__decorators: DeferredDecorator[];
+};
+/**
+ * Returns a sensible default value for a given type.
+ * Sensible means it satisfies the type checker, but not necessarily attached validators.
+ */
+export declare function defaultValue(type: Type): any;
+type UnionToIntersection$1<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+/**
+ * Function to mixin multiple classes together and create a new class, which can be extended from.
+ *
+ * The first entry of the mixin() call will be used as base class.
+ *
+ * @example
+ * ```typescript
+ *
+ *   class Timestampable {
+ *       createdAt: Date = new Date;
+ *       updatedAt: Date = new Date;
+ *   }
+ *
+ *   class SoftDeleted {
+ *       deletedAt?: Date;
+ *       deletedBy?: string;
+ *   }
+ *
+ *   class User extends mixin(Timestampable, SoftDeleted) {
+ *       id: number = 0;
+ *       constructor(public username: string) {}
+ *   }
+ * ```
+ */
+export declare function mixin<T extends AbstractClassType[]>(...classTypes: T): ClassType<UnionToIntersection$1<ExtractClassType<T[number]>>>;
+export type Resolver = (path: string) => Type | undefined;
+export declare function resolvePath<T>(path: string, type?: ReceiveType<T>): Type;
+export declare function pathResolver<T>(type?: ReceiveType<T>, jitStack?: JitStack): Resolver;
+export declare type __ΩResolver = any[];
+export declare function isReferenceInstance(obj: any): boolean;
+export declare function getReferenceInfo<T>(obj: T): ReferenceInfo<T> | undefined;
+export declare function getReferenceItemInfo<T>(obj: T): ReferenceItemInfo<T> | undefined;
+export declare function getOrCreateReferenceItemInfo<T>(obj: T): ReferenceItemInfo<T>;
+export declare function isReferenceHydrated(obj: any): boolean;
+export declare function markAsHydrated(item: any): void;
+export interface ReferenceInfo<T> {
+	hydrator?: (item: T) => Promise<void>;
+}
+export interface ReferenceItemInfo<T> {
+	hydrated: boolean;
+}
+export declare const referenceSymbol: unique symbol;
+export declare const referenceItemSymbol: unique symbol;
+export declare function createReference<T>(type: ClassType<T> | Type | ReflectionClass<any>, pk: {
+	[name: string]: any;
+}): T;
+export declare function createReferenceClass<T>(reflection: ReflectionClass<any>): ClassType<T>;
+export declare type __ΩReferenceInfo = any[];
+export declare type __ΩReferenceItemInfo = any[];
+interface RegistryDecorator<T> {
+	predicate: (type: Type) => boolean;
+	v: T;
+}
+export declare class TypeRegistry<T> {
+	protected results: {
+		[kind in ReflectionKind]?: T;
+	};
+	classes: Map<ClassType<any>, T>;
+	protected decorators: RegistryDecorator<T>[];
+	clear(): void;
+	get(type: Type): T | undefined;
+	decorator(predicate: (type: Type) => boolean, v: T): void;
+	/**
+	 * Registers a template for all binary classes: ArrayBuffer, Uint8Array, Int8Array, etc.
+	 */
+	setBinary(v: T): void;
+	setNumeric(v: T): void;
+	/**
+	 * Registers a template for a given class type.
+	 *
+	 * As soon as a single template has registered for the given classType the template registry
+	 * only returns templates for this particular classType and omits all general purpose ReflectionKind.class templates for this particular classType.
+	 */
+	setClass(classType: ClassType, v: T): void;
+	/**
+	 * Removes all registered templates.
+	 */
+	remove(kind: ReflectionKind): void;
+	/**
+	 * Registers a new template and replaces all existing (added via register,prepend,append).
+	 */
+	set(kind: ReflectionKind | ReflectionKind[] | ((type: Type) => boolean), v: T): void;
+}
+export declare class NoTypeReceived extends Error {
+	constructor(message?: string);
+}
+/**
+ * Returns a new UUID v4 as string.
+ */
+export declare function uuid(): string;
+/**
+ * Writes a new uuid v4 into an existing buffer, and returns the same buffer.
+ */
+export declare function writeUuid(buffer: Uint8Array, offset?: number): Uint8Array;
+/**
+ * Stringify an exising Uint8Array buffer.
+ */
+export declare function stringifyUuid(buffer: Uint8Array, offset?: number): string;
+export type Binary = ArrayBuffer | Uint8Array | Int8Array | Uint8ClampedArray | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
+export type JSONPartial<T> = T extends Date ? string : T extends Array<infer K> ? Array<JSONPartial<K>> : T extends Binary ? string : T extends object ? JSONPartialObject<T> : T extends string ? number | T : T extends boolean ? number | string | T : T extends bigint ? number | string | T : T extends number ? bigint | string | T : T;
+export type JSONPartialObject<T> = {
+	[name in keyof T]?: T[name] | null;
+};
+export type JSONSingle<T> = T extends Date ? string | Date : T extends Array<infer K> ? Array<JSONSingle<K>> : T extends Binary ? string : T extends object ? JSONEntity<T> : T extends string ? string | number | boolean | undefined : T extends boolean ? T | number | string : T extends number ? T | string : T;
+export type JSONEntity<T> = {
+	[name in keyof T]: JSONSingle<T[name]>;
+};
+export declare function regExpFromString(v: string): RegExp;
+export declare type __ΩBinary = any[];
+export declare type __ΩJSONPartial = any[];
+export declare type __ΩJSONPartialObject = any[];
+export declare type __ΩJSONSingle = any[];
+export declare type __ΩJSONEntity = any[];
+/**
+ * Casts/coerces a given data structure to the target data type and validates all attached validators.
+ *
+ * Same as validatedDeserialize().
+ *
+ * @throws ValidationError if casting or validation fails
+ */
+export declare function cast<T>(data: JSONPartial<T> | unknown, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T;
+/**
+ * Same as cast but returns a ready to use function. Used to improve performance.
+ */
+export declare function castFunction<T>(serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown, options?: SerializationOptions) => T;
+/**
+ * Deserialize given data structure from JSON data objects to JavaScript objects, without running any validators.
+ *
+ * Types that are already correct will be used as-is.
+ *
+ * ```typescript
+ * interface Data {
+ *     created: Date;
+ * }
+ *
+ * const data = deserialize<Data>({created: '2009-02-13T23:31:30.123Z'});
+ * //data is {created: Date(2009-02-13T23:31:30.123Z)}
+ *
+ * @throws ValidationError when deserialization fails.
+ * ```
+ */
+export declare function deserialize<T>(data: JSONPartial<T> | unknown, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T;
+/**
+ * Same as deserialize but returns a ready to use function. Used to improve performance.
+ */
+export declare function deserializeFunction<T>(serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<any, T>;
+/**
+ * Patch serialization for deep dot paths, e.g. `{'user.shippingAddress.street': 'abc'}`
+ * If a naming strategy is used, it could be converted to `{'user.shipping_address.street': 'abc'}`.
+ */
+export declare function patch<T>(data: DeepPartial<T>, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): (data: JSONPartial<T> | unknown) => T;
+/**
+ * Create a serializer/deserializer function including validator for the given type for a patch structure.
+ * This is handy for deep patch structures like e.g '{user.address.street: "new street"}'.
+ */
+export declare function getPatchSerializeFunction(type: TypeClass | TypeObjectLiteral, registry: TemplateRegistry, namingStrategy?: NamingStrategy): (data: any, state?: SerializationOptions, patch?: {
+	normalizeArrayIndex: boolean;
+}) => any;
+/**
+ * Serialize given data structure to JSON data objects (not a JSON string).
+ *
+ * The resulting JSON object can be stringified using JSON.stringify().
+ *
+ * ```typescript
+ * interface Data {
+ *     created: Date;
+ * }
+ *
+ * const json = serialize<Data>({created: new Date(1234567890123)});
+ * //json is {created: '2009-02-13T23:31:30.123Z'}
+ *
+ * const jsonString = JSON.stringify(json);
+ * //jsonString is '{"created":"2009-02-13T23:31:30.123Z"}'
+ * ```
+ *
+ * @throws ValidationError when serialization or validation fails.
+ */
+export declare function serialize<T>(data: T, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): JSONSingle<T>;
+/**
+ * Same as serialize but returns a ready to use function. Used to improve performance.
+ */
+export declare function serializeFunction<T>(serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): SerializeFunction<T>;
+/**
+ * Clones a class instance deeply.
+ */
+export declare function cloneClass<T>(target: T, options?: SerializationOptions): T;
+/**
+ * Tries to deserialize given data as T, and throws an error if it's not possible or validation after conversion fails.
+ *
+ * @deprecated use cast() instead
+ *
+ * @throws ValidationError when serialization or validation fails.
+ */
+export declare function validatedDeserialize<T>(data: any, options?: SerializationOptions, serializerToUse?: Serializer, namingStrategy?: NamingStrategy, type?: ReceiveType<T>): T;
+declare class SnapshotSerializer extends Serializer {
+	name: string;
+	protected registerSerializers(): void;
+}
+export declare const snapshotSerializer: SnapshotSerializer;
+/**
+ * Creates a new JIT compiled function to convert the class instance to a snapshot.
+ * A snapshot is essentially the class instance as `plain` serialization while references are
+ * stored only as their primary keys.
+ *
+ * Generated function is cached.
+ */
+export declare function getConverterForSnapshot(reflectionClass: ReflectionClass<any>): (value: any) => any;
+/**
+ * Creates a snapshot using getConverterForSnapshot().
+ */
+export declare function createSnapshot<T>(reflectionClass: ReflectionClass<T>, item: T): any;
+/**
+ * Extracts the primary key of a snapshot and converts to class type.
+ */
+export declare function getPrimaryKeyExtractor<T>(reflectionClass: ReflectionClass<T>): (value: any) => Partial<T>;
+/**
+ * Creates a primary key hash generator that takes an item from any format
+ * converts it to class format, then to plain, then uses the primitive values to create a string hash.
+ *
+ * This function is designed to work on the plain values (db records or json values)
+ */
+export declare function getPrimaryKeyHashGenerator(reflectionClass: ReflectionClass<any>, serializerToUse?: Serializer): (value: any) => string;
+export declare function getSimplePrimaryKeyHashGenerator(reflectionClass: ReflectionClass<any>): (data: PrimaryKeyFields<any>) => string;
+/**
+ * ```typescript
+ * const validator = getValidatorFunction<MyType>();
+ *
+ * const errors: ValidationErrorItem[] = [];
+ * const valid = validator(data, {errors})
+ *
+ * if (errors.length) console.log(errors); //validation failed if not empty
+ * ```
+ */
+export declare function getValidatorFunction<T>(serializerToUse?: Serializer, receiveType?: ReceiveType<T>): Guard<T>;
+export declare function is<T>(data: any, serializerToUse?: Serializer, errors?: ValidationErrorItem[], receiveType?: ReceiveType<T>): data is T;
+export declare function guard<T>(serializerToUse?: Serializer, receiveType?: ReceiveType<T>): Guard<T>;
+/**
+ * @throws ValidationError when type is invalid.
+ */
+export declare function assert<T>(data: any, serializerToUse?: Serializer, receiveType?: ReceiveType<T>): asserts data is T;
+export type AutoId = number & PrimaryKey & AutoIncrement & Positive;
+export declare type __ΩAutoId = any[];
+export declare const validators: {
+	[name in string]?: (...args: any[]) => (value: any) => ValidatorError | undefined;
+};
+type AssignableType = Type | string | boolean | number | symbol | bigint | undefined | null;
+type StackEntry$1 = {
+	left: Type;
+	right: Type;
+};
+/**
+ * The check of `extends` in Typescript. This function can be read as `left extends right`.
+ *
+ * See https://www.typescriptlang.org/docs/handbook/type-compatibility.html#any-unknown-object-void-undefined-null-and-never-assignability
+ * This algo follows strict mode.
+ *
+ * Warning: If you do not pass Type objects, typeInfer() is used which does not use cache (it is designed to be called withing type processor)
+ */
+export declare function isExtendable(leftValue: AssignableType, rightValue: AssignableType, extendStack?: StackEntry$1[]): boolean;
+export declare function _isExtendable(left: Type, right: Type, extendStack?: StackEntry$1[]): boolean;
+/**
+ * We don't want to embed in each and every file the type definition of Promise<t>,
+ * so we do it ondemand at runtime instead. This saves bundle size.
+ */
+export declare function createPromiseObjectLiteral(type: TypePromise): TypeObjectLiteral;
+export declare function parametersToTuple(parameters: TypeParameter[]): TypeTuple;
+export declare function extendTemplateLiteral(left: TypeLiteral | TypeTemplateLiteral, right: TypeTemplateLiteral): boolean;
+
+export {
+	Partial$1 as Partial,
+	typeAnnotation as metaAnnotation,
+};
+
+export {};