@azera/container/build/types.d.ts

import { HashMap } from "@azera/util/is";
export { HashMap };
export declare type Service = IDefinition | Function | any[];
export declare type Factory<T = {}> = Constructor<IFactory<T>> | FunctionOf<T>;
export declare type ContainerValue = any;
export declare type Constructor<T = {}> = new (...args: any[]) => T;
export interface IInjectable extends Function {
    $inject?: string[];
}
export declare type MockMethod<O extends object, K extends keyof O> = (...params: any[]) => ReturnType<O[K] extends ((...params: any[]) => any) ? O[K] : any>;
export declare type MockMethodAsync<O extends object, K extends keyof O> = (...params: any[]) => Promise<ReturnType<O[K] extends ((...params: any[]) => any) ? O[K] : any>>;
export declare type InjectableFunction<T = any> = {
    (...params: any[]): T;
    $inject?: string[];
};
export declare type FunctionOf<T> = (...params: any[]) => T;
export declare type Injectable<T = any> = InjectableFunction<T> | Function | Array<string | Function | FunctionOf<T>>;
export declare type InvokableFunctions<T> = Injectable<T> | Constructor<T> | Factory<T>;
export declare type Invokable<T> = InvokableFunctions<T> | string | T;
export declare type IServices = HashMap<IDefinition | Function | any[]>;
export interface IAutoTagger {
    (service: IDefinition): string[];
}
export declare type ServiceDefinitionCollection = HashMap<Service>;
export interface IContainer {
    set(values: {
        [name: string]: IDefinition | ContainerValue;
    }[]): this;
    set(name: string, value: IDefinition | ContainerValue): this;
    get<T>(name: string): T | undefined;
    invoke<T>(value: Invokable<T>): T | undefined;
}
export interface IDefinition<T = Function> {
    name: string;
    service?: T;
    parameters: (string | Function)[];
    properties: HashMap<string | Function | IPropertyInjection>;
    methods: {
        [name: string]: (string | Function)[];
    };
    calls: {
        [name: string]: (string | Function)[];
    };
    private: boolean;
    isFactory: boolean;
    factory?: Function | IFactory;
    tags: string[];
    invoke: boolean;
    imports: (string | Function)[];
    autoTags: ({
        class: Function;
        tags: string[];
    } | IAutoTagger)[];
}
export interface IInternalDefinition extends IDefinition {
    compiled?: boolean;
    inherited?: boolean;
    $target?: Function;
}
export interface IPropertyInjection {
    lateBinding?: boolean;
    name?: string | Function;
}
export interface IFactory<T = any> {
    create(...params: any[]): T;
}
export interface IMethod {
    context: any;
    method: string;
}