export declare const Type: FunctionConstructor;
export declare class InjectionToken<T> {
    private readonly _desc;
    constructor(desc: string);
    toString(): string;
}
export declare function isToken(v: any): v is InjectionToken<any>;
export declare function isType(v: any): v is Type<any>;
export interface AbstractType<T> extends Function {
    prototype: T;
}
export interface Type<T> extends Function {
    new (...args: any[]): T;
}
export interface ValueProvider<T> extends BaseProvider<T> {
    useValue: T;
}
export interface ClassProvider<T> extends BaseProvider<T> {
    useClass: Type<T>;
}
export type Factory<T> = (...args: any[]) => T;
export interface FactoryProvider<T> extends BaseProvider<T> {
    useFactory: Factory<T>;
    deps?: any[];
}
export interface BaseProvider<T> extends ProviderOptions {
    provide: Type<T> | InjectionToken<T> | AbstractType<T>;
}
export interface TypeProvider<T> extends Type<T> {
}
export type Provider<T = any> = TypeProvider<T> | ValueProvider<T> | ClassProvider<T> | FactoryProvider<T>;
type TokenValue<TToken> = TToken extends InjectionToken<infer TValue> | Type<infer TValue> | AbstractType<infer TValue> ? TValue : never;
type ValidateValueProvider<TProvider> = TProvider extends {
    provide: infer TToken;
    useValue: infer TValue;
} ? [TValue] extends [TokenValue<TToken>] ? TProvider : never : TProvider;
export type ValidatedProviders<TProviders extends readonly Provider[]> = TProviders & {
    [TIndex in keyof TProviders]: ValidateValueProvider<TProviders[TIndex]>;
};
/**
 * Preserves provider inference for separately declared provider arrays.
 */
export declare function defineProviders<const TProviders extends Provider[]>(providers: ValidatedProviders<TProviders>): TProviders;
export interface ProviderOptions {
    scope?: Scope;
    executionContextIn?: Array<string | symbol>;
    global?: boolean;
}
export declare enum Scope {
    Singleton = 0,
    Operation = 1
}
export declare function onlySingletonProviders(providers?: Provider[]): Provider[];
export declare function onlyOperationProviders(providers?: Provider[]): Provider[];
export declare function isClassProvider(provider: any): provider is ClassProvider<any>;
export declare function isFactoryProvider(provider: any): provider is FactoryProvider<any>;
export {};