import { Annotation, IAnnotation } from "@alterior/annotations";
export type Constructor<T> = new (...args: any[]) => T;
export type AbstractConstructor<T> = abstract new (...args: any[]) => T;
export type AnyConstructor<T> = Constructor<T> | AbstractConstructor<T>;
export type Visibility = 'private' | 'public' | 'protected';
/**
 * Represents a property on a class. A property can also be a field or a method.
 */
export declare class Property<T> {
    private _type;
    private _name;
    private _isStatic;
    constructor(_type: Constructor<T>, _name: string, _isStatic?: boolean);
    private _visibility;
    defineMetadata(key: string, value: string): void;
    getMetadata(key: string): any;
    deleteMetadata(key: string): void;
    private _valueType;
    get valueType(): Type<any> | undefined;
    get isStatic(): boolean;
    protected get type(): Constructor<T>;
    private _annotations;
    get annotations(): IAnnotation[];
    annotationsOfType<T extends Annotation>(type: Constructor<T>): T[];
    annotationOfType<T extends Annotation>(type: Constructor<T>): T;
    private _descriptor;
    get descriptor(): PropertyDescriptor | undefined;
    get name(): string;
    get visibility(): Visibility;
}
/**
 * Represents a method on a class. A method can be a static or instance method, and has a set of parameters
 * and a return type.
 */
export declare class Method<T> extends Property<T> {
    constructor(type: Constructor<T>, name: string, isStatic?: boolean);
    private _returnType;
    get returnType(): Type<any> | undefined;
    private _parameterTypes;
    get parameterTypes(): (Type<any> | undefined)[];
    get implementation(): Function;
    private _parameterNames;
    get parameterNames(): string[];
    get parameters(): Parameter<T>[];
    private _parameterAnnotations;
    get parameterAnnotations(): IAnnotation[][];
}
export declare class Field<T> extends Property<T> {
    constructor(type: Constructor<T>, name: string, isStatic?: boolean);
}
export declare class ConstructorMethod<T> extends Method<T> {
    constructor(type: Constructor<T>);
    private _ctorParameterAnnotations;
    get parameterAnnotations(): IAnnotation[][];
}
export declare class Parameter<T> {
    private _method;
    private _index;
    private _name;
    constructor(_method: Method<T>, _index: number, _name?: string | undefined);
    get annotations(): IAnnotation[];
    annotationsOfType<T extends Annotation>(type: Constructor<T>): T[];
    annotationOfType<T extends Annotation>(type: Constructor<T>): T;
    protected get method(): Method<T>;
    get valueType(): Type<any> | undefined;
    get index(): number;
    get name(): string | undefined;
}
/**
 * Represents a class Type and it's metadata
 */
export declare class Type<T extends Object> {
    private _class;
    constructor(_class: Constructor<T>);
    private _methodNames;
    private _fieldNames;
    get name(): string;
    getMetadata(key: string): void;
    defineMetadata(key: string, value: any): void;
    deleteMetadata(key: string): void;
    private _metadataKeys;
    get metadataKeys(): string[];
    private _annotations;
    /**
     * Get all annotations attached to this class
     */
    get annotations(): IAnnotation[];
    annotationsOfType<T extends Annotation>(type: Constructor<T>): T[];
    annotationOfType<T extends Annotation>(type: Constructor<T>): T;
    private _staticPropertyNames;
    private _staticMethodNames;
    private _staticFieldNames;
    get staticPropertyNames(): string[];
    get staticMethodNames(): string[];
    get staticFieldNames(): string[];
    private _staticMethods;
    get staticMethods(): Method<T>[];
    private _staticFields;
    get staticFields(): Field<T>[];
    private _staticProperties;
    get staticProperties(): Property<T>[];
    private _propertyNames;
    get propertyNames(): string[];
    get methodNames(): string[];
    get fieldNames(): string[];
    private _ctor;
    get constructorMethod(): ConstructorMethod<T>;
    private _methods;
    get methods(): Method<T>[];
    private _properties;
    get properties(): Property<T>[];
    private _fields;
    get fields(): Field<T>[];
    get base(): Type<any>;
}
export declare class Reflector {
    getTypeFromInstance<T extends Object = any>(instance: T): Type<T>;
    getTypeFromClass<T extends object = any>(typeClass: Constructor<T>): Type<T>;
}
//# sourceMappingURL=reflector.d.ts.map