import { BeforeAdvice, AfterAdvice, AroundAdvice } from './aspect';
/**
 * For a given factory, return the names of the initialization functions that will be
 * invoked upon construction.
 *
 * @param factory The factory that the array of function names should be returned for
 */
export declare function getInitFunctionNames(factory: ComposeFactory<any, any>): string[] | undefined;
/**
 * A custom type guard that determines if the value is a ComposeFactory
 *
 * @param   value The target to check
 * @returns       Return true if it is a ComposeFactory, otherwise false
 */
export declare function isComposeFactory(value: any): value is ComposeFactory<any, any>;
/**
 * Used to adapt any consructor functions or classes to a compose factory
 */
export interface GenericClass<T> {
    new (...args: any[]): T;
    readonly prototype: T;
}
/**
 * Used to adapt functions within compose
 */
export interface GenericFunction<T> {
    (...args: any[]): T;
}
/**
 * A basic string index map of options
 */
export interface Options {
    [options: string]: any;
}
export interface ComposeInitializationFunction<T, O extends Options> {
    /**
     * A callback function use to initialize a new created instance
     *
     * @param instance The newly constructed instance
     * @param options Any options that were passed to the factory
     * @template T The type of the instance
     * @template O The type of the options being passed
     */
    (instance: T, options?: O): void;
    /**
     * A string name of the function, used for debugging purposes
     */
    readonly name?: string;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * Extend the factory prototype with the supplied object literal, class, or factory
     *
     * @deprecated
     * @param extension The object literal, class or factory to extend
     * @template T The original type of the factory
     * @template U The type of the extension
     * @template O The type of the factory options
     * @template P The type of the extension factory options
     */
    extend<U>(extension: U | GenericClass<U>): ComposeFactory<T & U, O>;
    extend<U>(className: string, extension: U | GenericClass<U>): ComposeFactory<T & U, O>;
    extend<U, P>(extension: ComposeFactory<U, P>): ComposeFactory<T & U, O & P>;
    extend<U, P>(className: string, extension: ComposeFactory<U, P>): ComposeFactory<T & U, O & P>;
}
export interface Compose {
    /**
     * Extend a compose factory prototype with the supplied object literal, class, or
     * factory.
     *
     * @deprecated
     * @param base The base compose factory to extend
     * @param extension The object literal, class or factory that is the extension
     * @template T The base type of the factory
     * @template U The type of the extension
     * @template O The type of the base factory options
     * @template P The type of the extension factory options
     */
    extend<T, O, U>(base: ComposeFactory<T, O>, extension: U | GenericClass<U>): ComposeFactory<T & U, O>;
    extend<T, O, U>(base: ComposeFactory<T, O>, className: string, extension: U | GenericClass<U>): ComposeFactory<T & U, O>;
    extend<T, O, U, P>(base: ComposeFactory<T, O>, extension: ComposeFactory<U, P>): ComposeFactory<T & U, O & P>;
    extend<T, O, U, P>(base: ComposeFactory<T, O>, className: string, extension: ComposeFactory<U, P>): ComposeFactory<T & U, O & P>;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * Override certain properties on the existing factory, returning a new factory.  If the properties
     * are not present in the existing factory, override will throw.
     *
     * @param properties The properties to override
     */
    override(properties: any): this;
    /**
     * Override certain properties on the existing factory, returning a new factory.  If the properties
     * are not present in the existing factory, override with throw.
     *
     * @param className The class name for the factory
     * @param properties The properties to override
     */
    override(className: string, properties: any): this;
}
export interface Compose {
    /**
     * Override properties on a compose factory, returning a new factory.  If the properties are not
     * present on the base factory, override will throw.
     *
     * @param baseFactory The base compose factory to override
     * @param properties The properties to override
     */
    override<T, O>(baseFactory: ComposeFactory<T, O>, properties: any): ComposeFactory<T, O>;
    /**
     * Override properties on a compose factory, returning a new factory.  If the properties are not
     * present on the base factory, override will throw.
     *
     * @param baseFactory The base compose factory to override
     * @param className The class name for the factory
     * @param properties The properties to override
     */
    override<T, O>(baseFactory: ComposeFactory<T, O>, className: string, properties: any): ComposeFactory<T, O>;
}
export interface OverlayFunction<T> {
    /**
     * A function that takes a factories prototype, allowing it to change the prototype without
     * mutating the type structure.
     *
     * @param proto The object literal that should be overlayed on the factories prototype.
     * @template T The type of the factories prototype
     */
    (proto: T): void;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * Provide a function that mutates the factories prototype but does not change the factory's class
     * structure.
     *
     * @param overlayFunction The function which receives the factory's prototype
     * @template T The type of the factory's prototype
     */
    overlay(overlayFunction: OverlayFunction<T>): this;
}
export interface Compose {
    /**
     * A static method that takes a compose factory and applies an overlay function to the factory,
     * returning a new compose factory with a mutated prototype.
     *
     * @param base The base ComposeFactory
     * @param overlayFunction The function which receives the base factory's prototype
     * @template T The type of the factory's prototype
     * @template O The options for the factory's creation
     */
    overlay<T, O>(base: ComposeFactory<T, O>, overlayFunction: OverlayFunction<T>): ComposeFactory<T, O>;
}
/**
 * A descriptor for applying advice to a set of methods
 */
export interface AspectAdvice {
    /**
     * Any methods where the supplied advice should be applied *before* the base method is invoked
     */
    before?: {
        [method: string]: BeforeAdvice;
    };
    /**
     * Any methods where the supplied advice should be applied *after* the base method is invoked
     */
    after?: {
        [method: string]: AfterAdvice<any>;
    };
    /**
     * Any methods where the supplied advice should be applied *around* the base method
     */
    around?: {
        [method: string]: AroundAdvice<any>;
    };
}
/**
 * Either a class, object literal, or a factory
 */
export declare type ComposeMixinItem<T, O extends Options> = GenericClass<T> | T | ComposeFactory<T, O>;
/**
 * An object which provides information on how to mixin into a compose factory
 */
export interface ComposeMixinDescriptor<T, O, U, P> {
    /**
     * The class, object literal, or factory to be mixed in
     */
    mixin?: ComposeMixinItem<U, P>;
    /**
     * An initialize function to be executed upon construction
     */
    initialize?: ComposeInitializationFunction<T & U, O & P>;
    /**
     * Aspect Oriented Advice to be mixed into the factory
     */
    aspectAdvice?: AspectAdvice;
    /**
     * An optional class name which is used when labelling different parts of a factory for
     * debugging purposes
     */
    className?: string;
}
/**
 * Identifies a compose factory or other object that can be transformed into a
 * ComposeMixinDescriptor
 */
export interface ComposeMixinable<U extends Options, P> {
    /**
     * A method that offers up a ComposeMixinDescriptor to allow complex mixin in of factories
     */
    factoryDescriptor<T, O extends Options>(): ComposeMixinDescriptor<T, O, U, P>;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * Mixin additional mixins, initialization logic, and aspect advice into the factory
     *
     * @param mixin An object literal that describes what to mixin
     */
    mixin<U, P>(mixin: ComposeMixinable<U, P>): ComposeFactory<T & U, O & P>;
    mixin<U, P>(mixin: ComposeMixinDescriptor<T, O, U, P>): ComposeFactory<T & U, O & P>;
}
export interface Compose {
    /**
     * Mixin additional mixins, initialization logic, and aspect advice into a factory
     *
     * @param base The base factory that is the target of the mixin
     * @param mixin An object literal that describes what to mixin
     */
    mixin<T, O, U, P>(base: ComposeFactory<T, O>, mixin: ComposeMixinable<U, P>): ComposeFactory<T & U, O & P>;
    mixin<T, O, U, P>(base: ComposeFactory<T, O>, mixin: ComposeMixinDescriptor<T, O, U, P>): ComposeFactory<T & U, O & P>;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * Extract a method from another Class or Factory and add it to the returned factory
     *
     * @param base The base Class or Factory
     * @param method The name of the method to extract
     */
    from(base: GenericClass<any> | ComposeFactory<any, any>, method: string): this;
    /**
     * Apply advice *before* the named method (join-point)
     *
     * @param method The method to apply the advice to
     * @param advice The advice to be applied
     */
    before(method: string, advice: BeforeAdvice): this;
    /**
     * Apply advice *after* the named method (join-point)
     *
     * @param method The method to apply the advice to
     * @param advice The advice to be applied
     */
    after<P>(method: string, advice: AfterAdvice<P>): this;
    /**
     * Apply advice *around* the named method (join-point)
     *
     * @param method The method to apply the advice to
     * @param advice The advice to be applied
     */
    around<P>(method: string, advice: AroundAdvice<P>): this;
    /**
     * Provide an object literal which can contain a map of advice to apply
     *
     * @param advice An object literal which contains the maps of advice to apply
     */
    aspect(advice: AspectAdvice): this;
}
export interface Compose {
    /**
     * Extract a method from another Class or Factory and return it
     *
     * @param base The Class or Factory to extract from
     * @param method The method name to be extracted
     */
    from<T extends Function>(base: GenericClass<any> | ComposeFactory<any, any>, method: string | symbol): T;
    /**
     * Apply advice *before* the named method (join-point)
     *
     * @param base The Class or Factory to extract the method from
     * @param method The method name to apply the advice to
     * @param advice The advice to apply
     */
    before<T>(base: GenericClass<any> | ComposeFactory<any, any>, method: string | symbol, advice: BeforeAdvice): GenericFunction<T>;
    before<T>(method: GenericFunction<T>, advice: BeforeAdvice): GenericFunction<T>;
    /**
     * Apply advice *after* the named method (join-point)
     *
     * @param base The Class or Factory to extract the method from
     * @param method The method name to apply the advice to
     * @param advice The advice to apply
     */
    after<T>(base: GenericClass<any> | ComposeFactory<any, any>, method: string | symbol, advice: AfterAdvice<T>): GenericFunction<T>;
    after<T>(method: GenericFunction<T>, advice: AfterAdvice<T>): GenericFunction<T>;
    /**
     * Apply advice *around* the named method (join-point)
     *
     * @param base The Class or Factory to extract the method from
     * @param method The method name to apply the advice to
     * @param advice The advice to apply
     */
    around<T>(base: GenericClass<any> | ComposeFactory<any, any>, method: string | symbol, advice: AroundAdvice<T>): GenericFunction<T>;
    around<T>(method: GenericFunction<T>, advice: AroundAdvice<T>): GenericFunction<T>;
    /**
     * Apply advice to methods that exist in the base factory using the supplied advice map
     *
     * @param base The Factory that contains the methods the advice will be applied to
     * @param advice The map of advice to be applied
     */
    aspect<O, A>(base: ComposeFactory<O, A>, advice: AspectAdvice): ComposeFactory<O, A>;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * Create a new instance
     *
     * @param options Options that are passed to the initialization functions of the factory
     */
    (options?: O): T;
    /**
     * The read only prototype of the factory
     */
    readonly prototype: T;
}
export interface Compose {
    /**
     * Create a new factory based on a supplied Class, Factory or Object prototype with an optional
     * initalization function
     *
     * @param base The base Class, Factory or Object prototype to use
     * @param initFunction An optional function that will be passed the instance and any creation options
     * @param className An optional class name that is used to label the factory for debug purposes
     */
    <T, O extends Options, P extends Options>(className: string, base: ComposeFactory<T, O>, initFunction?: ComposeInitializationFunction<T, O & P>): ComposeFactory<T, O & P>;
    <T, O extends Options>(className: string, base: GenericClass<T> | T, initFunction?: ComposeInitializationFunction<T, O>): ComposeFactory<T, O>;
    <T, O extends Options, P extends Options>(base: ComposeFactory<T, O>, initFunction?: ComposeInitializationFunction<T, O & P>): ComposeFactory<T, O & P>;
    <T, O extends Options>(base: GenericClass<T> | T, initFunction?: ComposeInitializationFunction<T, O>): ComposeFactory<T, O>;
    /**
     * Create a new factory based on a supplied Class, Factory or Object prototype with an optional
     * initialization function
     *
     * @param base The base Class, Facotry or Object prototype to use
     * @param initFunction An optional function that will be passed the instance and nay creation options
     */
    create<T, O, P>(className: string, base: ComposeFactory<T, O>, initFunction?: ComposeInitializationFunction<T, O & P>): ComposeFactory<T, O & P>;
    create<T, O>(className: string, base: GenericClass<T> | T, initFunction?: ComposeInitializationFunction<T, O>): ComposeFactory<T, O>;
    create<T, O, P>(base: ComposeFactory<T, O>, initFunction?: ComposeInitializationFunction<T, O & P>): ComposeFactory<T, O & P>;
    create<T, O>(base: GenericClass<T> | T, initFunction?: ComposeInitializationFunction<T, O>): ComposeFactory<T, O>;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * Add static properties to a factory
     *
     * @param staticProperties An object literal that contains methods and properties that should be "static" (e.g. added to
     *                         the factory, instead of the factory's prototype)
     */
    static<S>(staticProperties: S): this & S;
}
export interface Compose {
    /**
     * Add static properties to a factory
     *
     * @param staticProperties An object literal that contains methods and properties that should be "static" (e.g. added to
     *                         the factory, instead of the factory's prototype)
     */
    static<T, O, S>(factory: ComposeFactory<T, O>, staticProperties: S): ComposeFactory<T, O> & S;
}
export interface ComposeFactory<T, O extends Options> extends ComposeMixinable<T, O> {
    /**
     * The class name of the ComposeFactory
     */
    readonly name?: string;
}
/**
 * A factory construction utility
 *
 * @param base An ES6 Class, ComposeFactory or Object literal to use as the base for the new factory
 * @param initFunction An optional initialization function for the factory
 */
declare const compose: Compose;
export default compose;