import { ConstructorType as ConstructorType$1, Prototype, MethodPropertyDescriptor } from '@aspectjs/common/utils';

/**
 * An annotation is identified by its name and its group id.
 * An AnnotationRef represents the identity of an annotation.
 */
declare class AnnotationRef {
    private static readonly registry;
    /**
     * The value of the annotation reference.
     */
    readonly value: string;
    /**
     * The name of the referenced annotation.
     */
    readonly name: string;
    /**
     * The group id of the referenced annotation.
     */
    readonly groupId: string;
    /**
     * @internal
     * @param ref
     */
    private constructor();
    /**
     * @internal
     * @param groupId
     * @param name
     */
    private constructor();
    /**
     * Get the string representation of the annotation in the format: `@<groupId>:<name>`
     * @returns The string representation of the annotation.
     */
    toString(): string;
    /**
     * Create a new Annotation Reference out of an Annotation, a string, or an AnnotationRef.
     * @param obj
     * @returns
     */
    static of(groupId: string, name: string): AnnotationRef;
    static of(obj: Pick<AnnotationRef, 'groupId' | 'name'> | string): AnnotationRef;
    private static register;
    private static get;
}

/**
 * Type of an annotation.
 */
declare enum AnnotationKind {
    CLASS = 1,
    PROPERTY = 2,
    METHOD = 4,
    PARAMETER = 8
}
/**
 * @internal
 */
type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction;
/**
 * @internal
 */
type MethodDecorator = <X>(target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<X>) => TypedPropertyDescriptor<X>;
/**
 * @internal
 */
type AnnotationStub<T extends AnnotationKind = AnnotationKind> = (...args: any[]) => Decorator<T> | void;
/**
 * An Annotation is an EcmaScript decorator with no behavior.
 * It is identified by a name and a group ID.
 *
 * @typeParam T - The type of the annotation, derived from `AnnotationKind`.
 * @typeParam S - The type of the annotation stub, derived from `AnnotationStub<T>`.
 */
type Annotation<T extends AnnotationKind = any, S extends AnnotationStub<T> = AnnotationStub<T>> = {
    /**
     * The reference to the annotation
     */
    ref: AnnotationRef;
} & {
    /**
     * The name of the annotation.
     */
    readonly name: string;
    /**
     * The group ID of the annotation.
     */
    readonly groupId: string;
} & ((...args: Parameters<S>) => Decorator<T>);
/**
 * @internal
 */
type Decorator<T extends AnnotationKind = AnnotationKind> = T extends AnnotationKind.CLASS ? ClassDecorator : T extends AnnotationKind.METHOD ? MethodDecorator : T extends AnnotationKind.PARAMETER ? ParameterDecorator : T extends AnnotationKind.PROPERTY ? PropertyDecorator : any;
/**
 * @internal
 */
type AnyDecorator = ClassDecorator & MethodDecorator & ParameterDecorator & PropertyDecorator;

interface BoundClassAnnotationTarget<X = unknown> extends ClassAnnotationTarget<X> {
    eval(): X;
}
interface BoundParameterAnnotationTarget<X = unknown> extends ParameterAnnotationTarget<X> {
    eval(): unknown;
}
interface BoundMethodAnnotationTarget<X = unknown> extends MethodAnnotationTarget<X> {
    eval(): (...args: unknown[]) => unknown;
}
interface BoundPropertyAnnotationTarget<X = unknown> extends PropertyAnnotationTarget<X> {
    eval(): unknown;
}
/**
 * Represents the symbol (Class, Method, Parameter, Property) annotated by an annotation.
 * This symbol is bound to an actual instance, and has a "value" attribute.
 * @param T The kind of annotation
 * @param X The type of the class that target belongs to.
 */
type BoundAnnotationTarget<T extends AnnotationKind = AnnotationKind, X = unknown> = T extends AnnotationKind.CLASS ? BoundClassAnnotationTarget<X> : T extends AnnotationKind.PARAMETER ? BoundParameterAnnotationTarget<X> : T extends AnnotationKind.METHOD ? BoundMethodAnnotationTarget<X> : T extends AnnotationKind.PROPERTY ? BoundPropertyAnnotationTarget<X> : never;

/**
 * Create {@link AnnotationTarget}
 */
declare class AnnotationTargetFactory {
    of<X = unknown>(target: ConstructorType$1<X>): AnnotationTarget<AnnotationKind.CLASS, X>;
    of<X = unknown>(target: X): BoundAnnotationTarget<AnnotationKind.CLASS, X>;
    of<X = unknown>(target: ConstructorType$1<X>, propertyKey: keyof X): AnnotationTarget<AnnotationKind.PROPERTY, X>;
    of<X = unknown>(target: X, propertyKey: keyof X): BoundAnnotationTarget<AnnotationKind.PROPERTY, X>;
    of<X = unknown>(target: ConstructorType$1<X>, propertyKey: keyof X, descriptor: PropertyDescriptor): AnnotationTarget<AnnotationKind.METHOD, X>;
    of<X = unknown>(target: X, propertyKey: keyof X, descriptor: PropertyDescriptor): BoundAnnotationTarget<AnnotationKind.METHOD, X>;
    of<X = unknown>(target: ConstructorType$1<X>, propertyKey: keyof X, parameterIndex: number): AnnotationTarget<AnnotationKind.PARAMETER, X>;
}
declare function inferTypeFromArgs(...args: unknown[]): AnnotationKind;
declare function inferTypeFromArgs<X = unknown>(decoree: ConstructorType$1<X> | Prototype<X>, propertyKey?: string | symbol, parameterIndex?: number, descriptor?: PropertyDescriptor): AnnotationKind;

declare class _AnnotationContextSet {
    private buckets;
    getAnnotations(decoratorTypes: AnnotationKind[], annotationRefs?: Set<AnnotationRef>, classTargetRef?: AnnotationTargetRef | undefined, propertyKey?: string | number | symbol | undefined): AnnotationContext[];
    addAnnotation(ctxt: AnnotationContext): void;
}

interface BoundAnnotationContext<T extends AnnotationKind = AnnotationKind, S extends AnnotationStub = AnnotationStub, X = unknown> extends AnnotationContext<T, S, X> {
    readonly target: BoundAnnotationTarget<T, X>;
}

interface AnnotationSelectorOptions {
    /**
     * Search for the annotation in parent classes.
     */
    searchParents: boolean;
}
declare class AnnotationsSelector<T extends AnnotationKind = AnnotationKind, S extends AnnotationStub = AnnotationStub, X = unknown> {
    private readonly targetFactory;
    private readonly annotationSet;
    private readonly annotationsRefs;
    private readonly decoratorTypes;
    private readonly type?;
    private readonly propertyKey?;
    private readonly parameterIndex?;
    constructor(selector: AnnotationsSelector<T, S, X>);
    constructor(targetFactory: AnnotationTargetFactory, annotationSet: _AnnotationContextSet, annotationsRefs: Set<AnnotationRef> | undefined, decoratorTypes: T[], type?: ConstructorType$1<X> | X, propertyKey?: string | symbol, parameterIndex?: number);
    find(options?: AnnotationSelectorOptions): AnnotationContext<T, S, X>[];
}
declare class BoundAnnotationsSelector<T extends AnnotationKind = AnnotationKind, S extends AnnotationStub = AnnotationStub, X = unknown> extends AnnotationsSelector<T, S, X> {
    private instance;
    private args?;
    constructor(selector: AnnotationsSelector<T, S, X>, instance: unknown, args?: unknown[] | undefined);
    find(options?: AnnotationSelectorOptions): BoundAnnotationContext<T, S, X>[];
}

/**
 * @internal
 */
declare class AnnotationTargetRef {
    readonly value: string;
    constructor(value: string);
    toString(): string;
}
/**
 * @internal
 */
interface BaseAnnotationTarget<T extends AnnotationKind = AnnotationKind, X = unknown> {
    readonly kind: T;
    readonly proto: Prototype<X>;
    readonly name: string;
    readonly label: string;
    readonly ref: AnnotationTargetRef;
    readonly declaringClass: ClassAnnotationTarget<X>;
    readonly parentClass: ClassAnnotationTarget<unknown> | undefined;
    readonly static: boolean;
    asDecoratorArgs(): any[];
    eval(): unknown;
    defineMetadata(key: string, value: any): void;
    getMetadata<T>(key: string, defaultvalue: () => T): T;
    getMetadata<T>(key: string, defaultvalue?: () => T): T | undefined;
    annotations<T extends AnnotationKind, S extends AnnotationStub = AnnotationStub>(annotation: S): AnnotationsSelector<T, S>;
    annotations(...annotation: Annotation[]): AnnotationsSelector<AnnotationKind, AnnotationStub>;
}
/**
 * Target for an annotated class.
 * @param X the type of the class
 */
interface ClassAnnotationTarget<X = unknown> extends BaseAnnotationTarget<AnnotationKind.CLASS, X> {
    readonly parentClass: ClassAnnotationTarget<unknown> | undefined;
    readonly static: boolean;
}
/**
 * Target for an annotated property.
 * @param X the type of the property's class
 */
interface PropertyAnnotationTarget<X = unknown> extends BaseAnnotationTarget<AnnotationKind.PROPERTY, X> {
    readonly propertyKey: string | symbol;
    readonly declaringClass: ClassAnnotationTarget<X>;
    readonly descriptor?: TypedPropertyDescriptor<unknown>;
    readonly static: boolean;
}
/**
 * Target for an annotated method.
 * @param X the type of the method's class
 */
interface MethodAnnotationTarget<X = unknown> extends BaseAnnotationTarget<AnnotationKind.METHOD, X> {
    readonly propertyKey: string | symbol;
    readonly descriptor: MethodPropertyDescriptor;
    readonly declaringClass: ClassAnnotationTarget<X>;
    readonly static: boolean;
}
/**
 * Target for an annotated parameter.
 * @param X the type of the parameter's class
 */
interface ParameterAnnotationTarget<X = unknown> extends BaseAnnotationTarget<AnnotationKind.PARAMETER, X> {
    readonly propertyKey: string | symbol;
    readonly parameterIndex: number;
    readonly descriptor: MethodPropertyDescriptor;
    readonly declaringMethod: MethodAnnotationTarget<X>;
    readonly declaringClass: ClassAnnotationTarget<X>;
    readonly static: boolean;
}
/**
 * Represents the symbol (Class, Method, Parameter, Property) annotated by an annotation.
 * @param T The kind of annotation
 * @param X The type of the class that target belongs to.
 */
type AnnotationTarget<T extends AnnotationKind = AnnotationKind, X = unknown> = T extends AnnotationKind.CLASS ? ClassAnnotationTarget<X> : T extends AnnotationKind.PARAMETER ? ParameterAnnotationTarget<X> : T extends AnnotationKind.METHOD ? MethodAnnotationTarget<X> : T extends AnnotationKind.PROPERTY ? PropertyAnnotationTarget<X> : never;

/**
 * Holds data about the execution context where the annotation is being invoked.
 */
declare class AnnotationContext<T extends AnnotationKind = AnnotationKind, S extends AnnotationStub = AnnotationStub, X = unknown> {
    /**
     * The arguments passed to the annotation.
     */
    readonly args: Parameters<S>;
    /**
     * The target of the annotation.
     */
    readonly target: AnnotationTarget<T, X>;
    /**
     * The reference to the annotation being invked.
     */
    readonly ref: AnnotationRef;
    /**
     * @param ref @internal
     */
    constructor(
    /**
     * The annotation, or its reference, that is being invoked.
     */
    ref: Annotation | AnnotationRef, 
    /**
     * The arguments passed to the annotation.
     */
    args: Parameters<S>, 
    /**
     * The target of the annotation.
     */
    target: AnnotationTarget<T, X>);
    /**
     *
     * @returns The signature of the annotation, in the form `@<groupId>:<name> on <target>`.
     */
    toString(): string;
}

type AnnotationSelectionFilter = {
    target: AnnotationTarget<AnnotationKind, any>;
    /**
     * Which kind of annotation to select ?
     */
    types?: AnnotationKind[];
};

/**
 * Selects annotations based on their type or target.
 */
declare class AnnotationByTargetSelector<S extends AnnotationStub = AnnotationStub> {
    private readonly targetFactory;
    private readonly annotationSet;
    private readonly annotationsRefs;
    constructor(targetFactory: AnnotationTargetFactory, annotationSet: _AnnotationContextSet, annotationsRefs: Set<AnnotationRef> | undefined);
    all<X = unknown>(type?: ConstructorType$1<X>): AnnotationsSelector<AnnotationKind, S, X>;
    all<X = unknown>(type?: X): BoundAnnotationsSelector<AnnotationKind, S, X>;
    onClass<X = unknown>(type?: ConstructorType$1<X>): AnnotationsSelector<AnnotationKind.CLASS, S, X>;
    onClass<X = unknown>(type?: X): BoundAnnotationsSelector<AnnotationKind.CLASS, S, X>;
    onMethod<X = any, K extends keyof X = keyof X>(type?: ConstructorType$1<X> | X, propertyKey?: K): AnnotationsSelector<AnnotationKind.METHOD, S, X>;
    onProperty<X, K extends keyof X = keyof X>(type?: ConstructorType$1<X>, propertyKey?: K): AnnotationsSelector<AnnotationKind.PROPERTY, S, X>;
    onProperty<X, K extends keyof X = keyof X>(type?: X, propertyKey?: K): BoundAnnotationsSelector<AnnotationKind.PROPERTY, S, X>;
    onParameters<X, K extends keyof X = keyof X>(type?: ConstructorType$1<X> | X, propertyKey?: K): AnnotationsSelector<AnnotationKind.PARAMETER, S, X>;
    onParameter<X, K extends keyof X = keyof X>(type: ConstructorType$1<X> | X, propertyKey: K, parameterIndex: number): AnnotationsSelector<AnnotationKind.PARAMETER, S, X>;
    private createSelector;
    on<X>(filter: AnnotationSelectionFilter): AnnotationsSelector<AnnotationKind, S, X>;
}

declare function getAnnotations<S extends AnnotationStub>(annotation: S): AnnotationByTargetSelector<S>;
declare function getAnnotations(...annotations: (Annotation | AnnotationRef | string)[]): AnnotationByTargetSelector;

/**
 * Store all registered annotations
 */
declare class AnnotationContextRegistry {
    private targetFactory;
    private readonly annotationSet;
    constructor(targetFactory: AnnotationTargetFactory);
    register(annotationContext: AnnotationContext): void;
    select(...annotations: (Pick<AnnotationRef, 'groupId' | 'name'> | Annotation | string)[]): AnnotationByTargetSelector;
}

interface AnnotationsByTypeSelectionOptions {
    /**
     * Search for the annotation in parent classes.
     */
    searchParents: boolean;
}
declare class AnnotationsByRefSelector<T extends AnnotationKind = AnnotationKind, S extends AnnotationStub = AnnotationStub, X = unknown> {
    private readonly targetFactory;
    private readonly annotationSet;
    private readonly annotationsRefs;
    private readonly decoratorTypes;
    private readonly type?;
    private readonly propertyKey?;
    constructor(selection: AnnotationsByRefSelector<T, S, X>);
    constructor(targetFactory: AnnotationTargetFactory, annotationSet: _AnnotationContextSet, annotationsRefs: Set<AnnotationRef> | undefined, decoratorTypes: T[], type?: ConstructorType$1<X> | X, propertyKey?: string | symbol);
    annotations<S2 extends AnnotationStub>(annotation: Annotation<AnnotationKind, S2>): AnnotationsSelector<T, S2, X>;
    annotations(...annotations: (AnnotationRef | Annotation<AnnotationKind, AnnotationStub>)[]): AnnotationsSelector<T, S, X>;
    find(options?: AnnotationsByTypeSelectionOptions): AnnotationContext<T, S, X>[];
}

/**
 * Options given to decoree.annotations {@link AnnotationFactory} to create a new annotation.
 * @typeParam T the type of annotation to create
 * @typeParam S the signature of the annotation to create. It defines the name of the annotation and the set of accepted parameters.
 */
interface AnnotationCreateOptions<T extends AnnotationKind> {
    /**
     * The name of the annotation to create.
     */
    name: string;
    /**
     * The type of annotation to create.
     */
    kind: T;
}
/**
 * Factory to create an {@link Annotation}.
 */
declare class AnnotationFactory {
    /**
     * The group of this factory.
     * All annotations created by this factory will belong to this group.
     */
    readonly groupId: string;
    /**
     * Create a new AnnotationFactory with the given `groupId`.
     * You generaly have to choose a `groupId` that identifies your project or is unique to your organisation.
     * The `groupId` will be used as a part of the signature for the created annotations.
     * @param groupId The groupId of this factory.
     */
    constructor(
    /**
     * The group of this factory.
     * All annotations created by this factory will belong to this group.
     */
    groupId: string);
    /**
     * Create with the a n annotation.
     * @param options The options for the annotation to create.
     * @param annotationStub The signature of the annotation to create.
     * @typeParam T the type of annotation to create
     * @typeParam S the signature of the annotation to create. It defines the name of the annotation and the set of accepted parameters.
     */
    create<T extends AnnotationKind, S extends AnnotationStub<T>>(options?: AnnotationCreateOptions<T>, annotationStub?: S): Annotation<T, S>;
    /**
     * Create a new annotation with the given `name` and `type`.
     * If no annotation type is given, the annotation could be used above classes, methods, properties, attributes and parameters.
     *
     * @param name The name of the annotation to create.
     * @typeParam S the signature of the annotation to create. It defines the name of the annotation and the set of accepted parameters.
     * @example
     * ```ts
     * const LogErrors = new AnnotationFactory('demo').create('LogErrors');
     * ```
     */
    create<S extends AnnotationStub>(name: string): Annotation<any, S>;
    /**
     * Create a new annotation wwith the given type and signature. The created annotation accepts the same parameters as with the the provid function.
     * If no annotation type is given, the annotation could be used above classes, methods, properties, attributes and parameters.
     *
     * @param type The type of annotation to create.
     * @param name The name of the annotation to create.
     * @param annotationStub The signature of the annotation to create.
     * @typeParam T the type of annotation to create
     * @typeParam S the signature of the annotation to create. It defines the name of the annotation and the set of accepted parameters.
     * @example
     * ```ts
     * const LogErrors = new AnnotationFactory('demo').create(
     *    AnnotationKind.METHOD,
     *    'Log',
     *    function Log(
     *      level: 'info' | 'warn' | 'error' | 'debug' = 'error',
     * ) {});
     * ```
     */
    create<T extends AnnotationKind, S extends AnnotationStub<T>>(type: T, name?: string, annotationStub?: S): Annotation<T, S>;
    /**
     * Create a new annotation with the given signature.
     * The created annotation has the same name as the given function, and accepts the same parameters.
     * If no annotation type is given, the annotation could be used above classes, methods, properties, attributes and parameters.
     *
     * @param name The name of the annotation to create.
     * @param annotationStub The signature of the annotation to create.
     * @typeParam S the signature of the annotation to create. It defines the name of the annotation and the set of accepted parameters.
     * @example
     * ```ts
     * const LogErrors = new AnnotationFactory('demo').create(
     *    'Log',
     *    function Log(
     *      level: 'info' | 'warn' | 'error' | 'debug' = 'error',
     * ) {});
     * ```
     */
    create<S extends AnnotationStub>(name?: string, annotationStub?: S): Annotation<any, S>;
    private _createDecorator;
    private _createAnnotationContext;
    private _createAnnotation;
}

/**
 * @internal
 * Type provided by a ReflectProvider
 */
type ReflectProviderType<T> = ConstructorType$1<T> & {
    __providerName?: string;
};
/**
 * @internal
 * Provide a service to the Reflect Context
 */
type ReflectProvider<T = unknown> = {
    deps?: (ConstructorType$1<unknown> | string)[];
    provide: ReflectProviderType<T> | string;
    factory: (...args: any[]) => T;
};

/**
 * @internal
 *
 * The ReflectContext is a container for the global values and services of the framework.
 * The services are added to the context in the form of {@link ReflectProvider}s,
 * through the use of {@link ReflectModuleConfiguration}s.
 */
declare class ReflectContext {
    protected providersToResolve: Map<string, ReflectProvider[]>;
    protected providersRegistry: Map<string, {
        component: unknown;
        provider: ReflectProvider;
    }[]>;
    protected addedProviders: Set<ReflectProvider>;
    protected modules: Set<ConstructorType$1>;
    /**
     * @internal
     * @param context
     */
    constructor(context?: ReflectContext);
    /**
     * Adds a module to the context. Modules are unique by their name.
     * Adding the same module twice has no effect.
     * @param module The module to add
     */
    registerModules(...modules: ConstructorType$1<unknown>[]): ReflectContext;
    private addProviders;
    /**
     * Get a provider by its name or type.
     * @param provider The provider name or type.
     * @param T the provider type
     * @return The provider, if registered, undefined otherwise.
     */
    get<T>(providerType: ReflectProvider<T>['provide']): T;
    private _get;
    /**
     * Know if a provider is registered.
     * @param providerType The provider name or type.
     * @param T the provider type
     * @returns true if the provider is registered, false otherwise.
     */
    has<T>(providerType: ReflectProvider<T>['provide']): boolean;
    protected assign(context: ReflectContext): this;
    private _tryResolveProvider;
}

/**
 * @internal
 * A DecoratorHook is a configuration for the {@link AnnotationFactory}
 * to create typescript decorators that corresponds to a given annotation.
 */
type DecoratorHook<T extends AnnotationKind = AnnotationKind, S extends AnnotationStub<T> = AnnotationStub<T>> = {
    createDecorator: (reflect: ReflectContext, context: AnnotationContext<T, S>, annotationStub: S) => Decorator<T> | void;
    order?: number;
    name: string;
};

/**
 * @internal
 */
declare class DecoratorHookRegistry {
    protected readonly hooks: Map<string, DecoratorHook>;
    static readonly __providerName = "DecoratorHookRegistry";
    values(): IterableIterator<DecoratorHook>;
    add(annotationsHook: DecoratorHook): this;
    remove(annotationsHook: DecoratorHook | string): this;
}

declare const BOUND_INSTANCE_SYMBOL: unique symbol;
declare const BOUND_VALUE_SYMBOL: unique symbol;
/**
 * @internal
 */
declare abstract class _AnnotationTargetImpl<T extends AnnotationKind = AnnotationKind, X = unknown> implements BaseAnnotationTarget<T, X> {
    readonly kind: T;
    readonly proto: Prototype<X>;
    readonly name: string;
    readonly label: string;
    readonly ref: AnnotationTargetRef;
    abstract readonly declaringClass: ClassAnnotationTarget<X>;
    abstract readonly parentClass: ClassAnnotationTarget<unknown> | undefined;
    protected readonly [BOUND_INSTANCE_SYMBOL]?: X;
    protected readonly [BOUND_VALUE_SYMBOL]?: unknown;
    readonly ['static']: boolean;
    eval(): unknown;
    constructor(kind: T, proto: Prototype<X>, name: string, label: string, ref: AnnotationTargetRef, staticAttribute?: boolean);
    annotations<T extends AnnotationKind, S extends AnnotationStub = AnnotationStub>(annotation: S): AnnotationsSelector<T, S>;
    annotations(...annotation: (Annotation | AnnotationRef | string)[]): AnnotationsSelector<AnnotationKind, AnnotationStub>;
    abstract asDecoratorArgs(): any[];
    abstract defineMetadata(key: string, value: any): void;
    abstract getMetadata<T>(key: string, defaultvalue?: (() => T) | undefined): T | undefined;
    toString(): string;
    /**
     * Binds a value to this AnnotationTarget. The value is either the class instance for ClassAnnotationTarget, the property value for PropertyAnnotationTarget, MethodAnnotationTarget or ParameterAnnotationTarget.
     * In addition, in case of ParameterAnnotationTarget, the bind() method accepts a 2nd argument to bind the parameter value.
     *
     * @param instance The class instance to bind this target to.
     * @param value the value of this target
     */
    abstract _bind(instance: X, args?: unknown[]): AnnotationTarget<T, X>;
}

/**
 * @internal
 */
type AbstractConstructorType<X = unknown> = abstract new (...args: any[]) => X;
type ConcreteConstructorType<X = unknown> = new (...value: any[]) => X;
type ConstructorType<X = unknown> = ConcreteConstructorType<X> | AbstractConstructorType<X>;

interface AbstractToken<T = unknown> {
    readonly template?: T | ConstructorType<T>;
}

/**
 * Disables errors when calling ${@link abstract} method.
 * @param receipe the function to be executed without throwing an error in case ${@link abstract} method is called.
 * @returns
 */
declare const _defuseAbstract: (receipe: () => unknown) => unknown;
/**
 * Annotating abstract methods is not allowed in TypeScript.
 * Instead, we have to define concrete, empty methods, awaiting for an annotation to actually define its behaviour.
 * However, typescript will throw a compilation error if that method declares a return value but the body is empty.
 * The abstract function is a placeholder that stands for a return value.
 * It will throw if called as is, but it is intended to be bypassed by the action of an annotation.
 *
 * @param T the type of the value to be replaced.
 */
declare function abstract<T>(): T;
declare function abstract<T>(template: [ConstructorType<T>]): T[];
declare function abstract<T>(template: ConstructorType<T>): T;
declare function abstract<T>(template: T): T;
declare const isAbstractToken: (val: any) => boolean;

interface ReflectModuleConfiguration {
    providers: ReflectProvider[];
}

declare const ReflectModule: (config: ReflectModuleConfiguration) => <TFunction extends Function>(target: any) => any;

/**
 * Get the reflect context.
 * @internal
 * @returns The reflect context.
 */
declare const reflectContext: () => ReflectContext;
/**
 * @internal
 * Replace the current reflect context. Internally called by {@link ./../../testing/src/setup#configureTesting}
 * @param context
 * @returns
 */
declare const _setReflectContext: (context: ReflectContext) => ReflectContext;

declare class ReflectError extends Error {
}

export { type AbstractToken, type Annotation, AnnotationByTargetSelector, AnnotationContext, AnnotationContextRegistry, type AnnotationCreateOptions, AnnotationFactory, AnnotationKind, AnnotationRef, type AnnotationSelectorOptions, type AnnotationStub, type AnnotationTarget, AnnotationTargetFactory, AnnotationTargetRef, AnnotationsByRefSelector, type AnnotationsByTypeSelectionOptions, AnnotationsSelector, type AnyDecorator, BOUND_INSTANCE_SYMBOL, BOUND_VALUE_SYMBOL, type BaseAnnotationTarget, type BoundAnnotationContext, type BoundAnnotationTarget, BoundAnnotationsSelector, type BoundClassAnnotationTarget, type ClassAnnotationTarget, type Decorator, type DecoratorHook, DecoratorHookRegistry, type MethodAnnotationTarget, type ParameterAnnotationTarget, type PropertyAnnotationTarget, ReflectContext, ReflectError, ReflectModule, type ReflectModuleConfiguration, type ReflectProvider, type ReflectProviderType, _AnnotationTargetImpl, _defuseAbstract, _setReflectContext, abstract, getAnnotations, inferTypeFromArgs, isAbstractToken, reflectContext };