import { EntityOptions, ReflectionKind, ReflectionVisibility, Type } from './reflection/type.js';
export interface SerializedTypeAnnotations {
    entityOptions?: EntityOptions;
    typeName?: string;
    typeArguments?: SerializedTypeReference[];
    indexAccessOrigin?: {
        container: SerializedTypeReference;
        index: SerializedTypeReference;
    };
    decorators?: SerializedTypeReference[];
}
interface SerializedTypeObjectLiteral extends SerializedTypeAnnotations {
    kind: ReflectionKind.objectLiteral;
    types: SerializedTypeReference[];
}
interface SerializedTypeClassType extends SerializedTypeAnnotations {
    kind: ReflectionKind.class;
    name?: string;
    globalObject?: true;
    classType: string;
    extendsArguments?: SerializedTypeReference[];
    arguments?: SerializedTypeReference[];
    superClass?: SerializedTypeReference;
    types: SerializedTypeReference[];
}
interface SerializedTypeFunction extends SerializedTypeAnnotations {
    kind: ReflectionKind.function;
    name?: number | string | symbol;
    parameters: SerializedTypeParameter[];
    return: SerializedTypeReference;
}
type SerializedTypeReference = number;
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;
}
interface SerializedTypeLiteral extends SerializedTypeAnnotations {
    kind: ReflectionKind.literal;
    literal: {
        type: 'symbol';
        name: string;
    } | string | number | boolean | {
        type: 'bigint';
        value: string;
    } | {
        type: 'regex';
        regex: string;
    };
}
interface SerializedTypeTemplateLiteral extends SerializedTypeAnnotations {
    kind: ReflectionKind.templateLiteral;
    types: SerializedTypeReference[];
}
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?: true;
}
export interface SerializedTypeBaseMember extends SerializedTypeAnnotations {
    visibility: ReflectionVisibility;
    abstract?: true;
    optional?: true;
    readonly?: true;
}
export interface SerializedTypeMethod extends SerializedTypeBaseMember {
    kind: ReflectionKind.method;
    visibility: ReflectionVisibility;
    name: number | string | symbol;
    parameters: SerializedTypeParameter[];
    optional?: true;
    abstract?: true;
    return: SerializedTypeReference;
}
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?: true;
}
interface SerializedTypePromise extends SerializedTypeAnnotations {
    kind: ReflectionKind.promise;
    type: SerializedTypeReference;
}
interface SerializedTypeEnum extends SerializedTypeAnnotations {
    kind: ReflectionKind.enum;
    enum: {
        [name: string]: string | number | undefined | null;
    };
    values: (string | number | undefined | null)[];
    indexType: SerializedTypeReference;
}
export interface SerializedTypeUnion extends SerializedTypeAnnotations {
    kind: ReflectionKind.union;
    types: SerializedTypeReference[];
}
export interface SerializedTypeIntersection extends SerializedTypeAnnotations {
    kind: ReflectionKind.intersection;
    types: SerializedTypeReference[];
}
interface SerializedTypeArray extends SerializedTypeAnnotations {
    kind: ReflectionKind.array;
    type: SerializedTypeReference;
}
interface SerializedTypeIndexSignature extends SerializedTypeAnnotations {
    kind: ReflectionKind.indexSignature;
    index: SerializedTypeReference;
    type: SerializedTypeReference;
}
interface SerializedTypePropertySignature extends SerializedTypeAnnotations {
    kind: ReflectionKind.propertySignature;
    name: number | string | symbol;
    optional?: true;
    readonly?: true;
    description?: string;
    type: SerializedTypeReference;
}
interface SerializedTypeMethodSignature extends SerializedTypeAnnotations {
    kind: ReflectionKind.methodSignature;
    name: number | string | symbol;
    optional?: true;
    parameters: SerializedTypeParameter[];
    return: SerializedTypeReference;
}
export interface SerializedTypeTypeParameter extends SerializedTypeAnnotations {
    kind: ReflectionKind.typeParameter;
    name: string;
}
interface SerializedTypeInfer extends SerializedTypeAnnotations {
    kind: ReflectionKind.infer;
}
interface SerializedTypeTupleMember extends SerializedTypeAnnotations {
    kind: ReflectionKind.tupleMember;
    type: SerializedTypeReference;
    optional?: true;
    name?: string;
}
interface SerializedTypeTuple extends SerializedTypeAnnotations {
    kind: ReflectionKind.tuple;
    types: SerializedTypeTupleMember[];
}
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 {};
export declare type __ΩSerializedTypeAnnotations = any[];
export declare type __ΩSerializedTypeBaseMember = any[];
export declare type __ΩSerializedTypeMethod = any[];
export declare type __ΩSerializedTypeUnion = any[];
export declare type __ΩSerializedTypeIntersection = any[];
export declare type __ΩSerializedTypeTypeParameter = any[];
export declare type __ΩSerializedType = any[];
export declare type __ΩSerializedTypes = any[];
export declare type __ΩSerializerState = any[];