import { Type } from '@neoskop/annotation-factory';
export declare type Cls<T> = {
    new?(...args: any[]): T;
    readonly prototype: T;
};
export declare type MethodProperty<T> = string | string[] | keyof T | keyof T[] | RegExp;
export declare type Property<T> = string | string[] | keyof T | keyof T[];
export interface InstanceMethodPointcutDecorator {
    <T>(cls: Cls<T>, property: MethodProperty<T>): any;
    new <T>(cls: Cls<T>, property: MethodProperty<T>): InstanceMethodPointcut<T>;
}
export interface StaticMethodPointcutDecorator {
    <T>(cls: T, property: MethodProperty<T>): any;
    new <T>(cls: T, property: MethodProperty<T>): StaticMethodPointcut<T>;
}
export interface InstancePropertyPointcutDecorator {
    <T>(cls: Cls<T>, property: Property<T>): any;
    new <T>(cls: Cls<T>, property: Property<T>): InstancePropertyPointcut<T>;
}
export interface StaticPropertyPointcutDecorator {
    <T>(cls: T, property: Property<T>): any;
    new <T>(cls: T, property: Property<T>): StaticPropertyPointcut<T>;
}
export declare abstract class Pointcut<T> {
    abstract readonly cls: Cls<T> | T;
    abstract readonly property: Property<T> | MethodProperty<T>;
}
export declare abstract class InstanceMethodPointcut<T> extends Pointcut<T> {
    abstract readonly cls: Type<T>;
    abstract readonly property: MethodProperty<T>;
}
export declare abstract class StaticMethodPointcut<T> extends Pointcut<T> {
    abstract readonly cls: T;
    abstract readonly property: MethodProperty<T>;
}
export declare abstract class InstancePropertyPointcut<T> extends Pointcut<T> {
    abstract readonly cls: Type<T>;
    abstract readonly property: Property<T>;
}
export declare abstract class StaticPropertyPointcut<T> extends Pointcut<T> {
    abstract readonly cls: T;
    abstract readonly property: Property<T>;
}
/**
 * Defines a before advice
 * @example
 * ```
 * class Aspect {
 *     @Before(ExampleClass, 'exampleMethod')
 *     advice(jp : JoinpointContext) {}
 * }
 * ```
 */
export declare const Before: InstanceMethodPointcutDecorator;
/**
 * Defines a after advice
 * @example
 * ```
 * class Aspect {
 *     @After(ExampleClass, 'exampleMethod')
 *     advice(jp : JoinpointContext) {}
 * }
 * ```
 */
export declare const After: InstanceMethodPointcutDecorator;
/**
 * Defines a around advice
 * @example
 * ```
 * class Aspect {
 *     @Around(ExampleClass, 'exampleMethod')
 *     advice(jp : JoinpointContext) {
 *         return jp.proceed()
 *     }
 * }
 * ```
 */
export declare const Around: InstanceMethodPointcutDecorator;
/**
 * Defines a getter advice
 * @example
 * ```
 * class Aspect {
 *     @Getter(ExampleClass, 'exampleProperty')
 *     advice(jp : GetterJoinpointContext) {
 *         return jp.getValue()
 *     }
 * }
 * ```
 */
export declare const Getter: InstancePropertyPointcutDecorator;
/**
 * Defines a setter advice
 * @example
 * ```
 * class Aspect {
 *     @Setter(ExampleClass, 'exampleProperty')
 *     advice(jp : SetterJoinpointContext) {
 *         jp.proceed()
 *     }
 * }
 * ```
 */
export declare const Setter: InstancePropertyPointcutDecorator;
/**
 * Defines a static before advice
 * @example
 * ```
 * class Aspect {
 *     @BeforeStatic(ExampleClass, 'exampleMethod')
 *     advice(jp : JoinpointContext) {}
 * }
 * ```
 */
export declare const BeforeStatic: StaticMethodPointcutDecorator;
/**
 * Defines a static after advice
 * @example
 * ```
 * class Aspect {
 *     @AfterStatic(ExampleClass, 'exampleMethod')
 *     advice(jp : JoinpointContext) {}
 * }
 * ```
 */
export declare const AfterStatic: StaticMethodPointcutDecorator;
/**
 * Defines a static around advice
 * @example
 * ```
 * class Aspect {
 *     @AroundStatic(ExampleClass, 'exampleMethod')
 *     advice(jp : JoinpointContext) {
 *         return jp.proceed()
 *     }
 * }
 * ```
 */
export declare const AroundStatic: StaticMethodPointcutDecorator;
/**
 * Defines a static getter advice
 * @example
 * ```
 * class Aspect {
 *     @StaticGetter(ExampleClass, 'exampleProperty')
 *     advice(jp : GetterJoinpointContext) {
 *         return jp.getValue()
 *     }
 * }
 * ```
 */
export declare const StaticGetter: StaticPropertyPointcutDecorator;
/**
 * Defines a static setter advice
 * @example
 * ```
 * class Aspect {
 *     @StaticSetter(ExampleClass, 'exampleProperty')
 *     advice(jp : SetterJoinpointContext) {
 *         jp.proceed()
 *     }
 * }
 * ```
 */
export declare const StaticSetter: StaticPropertyPointcutDecorator;
/**
 * Marks a method explicit as joinpoint shadow
 * Required for annotated methods!
 * @example
 * ```
 * class Controller {
 *     @Get('/')
 *     @JoinpointShadow() // IMPORTANT: as last annotation!
 *     method() {
 *         return 'foo';
 *     }
 * }
 * ```
 */
export declare function JoinpointShadow(): MethodDecorator;