import { DecoratorSite, AnnotationDecoratorOptions, AnnotationDecorator, ClassDecoratorSite, MethodDecoratorSite, ParameterDecoratorSite, PropertyDecoratorSite, Decorator } from './annotations';
/**
 * Mutators are a way to define "mutation decorators" which in some way change the value
 * of the elements they are applied to, as opposed to "annotation decorators", which primarily
 * attach metadata.
 *
 * Create a mutator with Mutator.create().
 */
type MutatorFunction<SiteType extends DecoratorSite = DecoratorSite, Args extends any[] = any[]> = (target: SiteType, ...args: Args) => void;
export interface MutatorDefinition<SiteType extends DecoratorSite = DecoratorSite, Args extends any[] = any[]> {
    invoke: (site: SiteType, ...args: Args) => void;
    options?: AnnotationDecoratorOptions<void>;
}
export declare class Mutator {
    /**
     * Low-level method to ceate a new mutation decorator (mutator) based on the given function.
     * Use `Mutator.define()` instead.
     */
    static create<Args extends any[]>(mutator: MutatorFunction<ClassDecoratorSite, Args>, options?: AnnotationDecoratorOptions<void> & {
        validTargets: ['class'];
    }): AnnotationDecorator<Args>;
    static create<Args extends any[]>(mutator: MutatorFunction<MethodDecoratorSite, Args>, options?: AnnotationDecoratorOptions<void> & {
        validTargets: ['method'];
    }): AnnotationDecorator<Args>;
    static create<Args extends any[]>(mutator: MutatorFunction<PropertyDecoratorSite, Args>, options?: AnnotationDecoratorOptions<void> & {
        validTargets: ['property'];
    }): AnnotationDecorator<Args>;
    static create<Args extends any[]>(mutator: MutatorFunction<ParameterDecoratorSite, Args>, options?: AnnotationDecoratorOptions<void> & {
        validTargets: ['parameter'];
    }): AnnotationDecorator<Args>;
    static create<Args extends any[]>(mutator: MutatorFunction<DecoratorSite, Args>, options?: AnnotationDecoratorOptions<void>): AnnotationDecorator<Args>;
    /**
     * Define a new mutation decorator (mutator).
     * This should be called and returned from a
     * function definition. For example:
     *
     * ```
     * function Name() {
     *     return Mutator.define({
     *         invoke(site) {
     *             // ...
     *         }
     *     })
     * }
     * ```
     *
     * The `invoke()` function takes a DecoratorSite object which describes the particular
     * invocation that is being run, and importantly, access to the property descriptor
     * for the property being defined. If you wish to completely replace (or wrap) the
     * default value of the property or method you are replacing, set the `value`
     * property of the property descriptor with `site.propertyDescriptor.value`
     *
     * For example:
     * ```
     * export function RunTwice() {
     *     return Mutator.define(
     *         invoke(site) {
     *             let prop = site.propertyDescriptor;
     *             let original = prop.value;
     *             let replacement = function(...args) {
     *                 original.apply(this, args);
     *                 original.apply(this, args);
     *             }
     *             prop.value = replacement;
     *         }
     *     );
     * }
     * ```
     */
    static define(definition: MutatorDefinition<ClassDecoratorSite> & {
        options: {
            validTargets: ['class'];
        };
    }): Decorator;
    static define(definition: MutatorDefinition<MethodDecoratorSite> & {
        options: {
            validTargets: ['method'];
        };
    }): Decorator;
    static define(definition: MutatorDefinition<PropertyDecoratorSite> & {
        options: {
            validTargets: ['property'];
        };
    }): Decorator;
    static define(definition: MutatorDefinition<ParameterDecoratorSite> & {
        options: {
            validTargets: ['parameter'];
        };
    }): Decorator;
    static define(definition: MutatorDefinition): Decorator;
}
export {};
//# sourceMappingURL=mutator.d.ts.map