/** A generic constructor */
type Constructor<T = any> = abstract new (...args: any) => T;
/** The _type_ for a binding, either a `Constructor` or a `string`. */
type Binding = Constructor | string;
/** The _type_ of a binding in the context of an `Injector`. */
type InjectorBinding<Components extends Constructor, Provisions extends Record<string, any>> = Components | (keyof Provisions & string) | PromisedBinding<Components | (keyof Provisions & string)>;
/** A tuple of `InjectorBinding`s (what's needed by `$inject`). */
type InjectTuple<Components extends Constructor, Provisions extends Record<string, any>> = readonly [InjectorBinding<Components, Provisions>, ...(InjectorBinding<Components, Provisions>)[]];
/**
 * Check that an `Injector`'s static `$inject` member matches the `Injector`'s
 * own components and provisions
 */
type CheckInject<Inject, // the tuple from "$inject"
Components extends Constructor, // the `Injector`'s components
Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends PromisedBinding<infer I2> ? I2 extends keyof Provisions ? readonly [PromisedBinding<I2>] : I2 extends Extract<Components, I2> ? readonly [PromisedBinding<I2>] : readonly [PromisedBinding<never>] : I1 extends keyof Provisions ? readonly [I1] : I1 extends Extract<Components, I1> ? readonly [I1] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
    ...CheckInject<[I1], Components, Provisions>,
    ...CheckInject<I2, Components, Provisions>
] : readonly [Components | keyof Provisions, ...(Components | keyof Provisions)[]];
/**
 * Map the contents of the static `$inject` member to their types, resolving
 * named provisions.
 */
type MapInject<Inject, // the tuple from "$inject"
Provisions extends Record<string, any>> = Inject extends readonly [] ? readonly [] : Inject extends readonly [infer I1] ? I1 extends PromisedBinding<infer I2> ? I2 extends keyof Provisions ? readonly [Promise<Provisions[I2]>] : I2 extends Constructor ? readonly [Promise<InstanceType<I2>>] : readonly [never] : I1 extends keyof Provisions ? readonly [Provisions[I1]] : I1 extends Constructor ? readonly [InstanceType<I1>] : readonly [never] : Inject extends readonly [infer I1, ...infer I2] ? readonly [
    ...MapInject<[I1], Provisions>,
    ...MapInject<I2, Provisions>
] : readonly [never];
/**
 * Check that an `Injectable` is valid for a given `Injector`.
 */
type CheckInjectable<I extends Injectable<Components, Provisions>, // the `Injectable` to check
Components extends Constructor, // the `Injector`'s components
Provisions extends Record<string, any>> = I extends {
    $inject: infer Inject;
} ? {
    $inject: CheckInject<Inject, Components, Provisions>;
    new (...args: MapInject<Inject, Provisions>): any;
} : I extends new () => any ? I : {
    $inject: InjectTuple<Components, Provisions>;
};
/**
 * Return the unrolled type of a `Promise`
 */
type UnrollPromise<T> = T extends Promise<infer T> ? UnrollPromise<T> : T;
/**
 * Override the type for an `Injector`'s existing provision, or add a new one
 */
type ExtendProvisions<Provisions extends Record<string, any>, // the `Injector`'s provisions
P extends string, // the new (string) key of the provision
T> = {
    [key in P | keyof Provisions]: key extends P ? UnrollPromise<T> : Provisions[key];
};
/** A constant symbol identifying a _promised binding_. */
declare const promisedBinding: unique symbol;
/** Declare a _binding_ to be _promised_ (inject its `Promise`). */
export declare function promise<B extends Binding>(binding: B): PromisedBinding<B>;
export interface PromisedBinding<B extends Binding = Binding> {
    [promisedBinding]: B;
}
/** An `Injectable` defines a constructor for an injectable class */
export interface Injectable<Components extends Constructor, Provisions extends Record<string, any>, T = any> {
    prototype: T;
    new (...args: any): T;
    $inject?: InjectTuple<Components, Provisions>;
}
/**
 * The `Injections` interface abstracts the idea of getting bound and
 * provisioned instances from an `Injector`, injecting new `Injectable`
 * instances, and creating sub-`Injector`s.
 */
export interface Injections<Components extends Constructor = never, Provisions extends Record<string, any> = {}> {
    /** Get a _bound_ instance from an `Injector`. */
    get<C extends Components>(component: C): Promise<InstanceType<C>>;
    /** Get a _provisioned_ instance from an `Injector`. */
    get<P extends keyof Provisions>(provision: P): Promise<Provisions[P]>;
    /**
     * Create a new instance of the specified `Injectable`, providing it with all
     * necessary injections.
     *
     * @param injectable The constructor of the instance to create.
     */
    inject<I extends Injectable<Components, Provisions>>(injectable: I & CheckInjectable<I, Components, Provisions>): Promise<InstanceType<I>>;
    /** Create a sub-`Injector` child of the current one. */
    injector(): Injector<Components, Provisions>;
}
/** A `Factory` is a _function_ creating instances of a given type. */
export type Factory<Components extends Constructor = Constructor, Provisions extends Record<string, any> = Record<string, any>, T = any> = (injections: Injections<Components, Provisions>) => T | Promise<T>;
/**
 * The `Injector` class acts as a registry of components and provisions,
 * creating instances and injecting dependencies.
 */
export declare class Injector<Components extends Constructor = never, Provisions extends Record<string, any> = {}> implements Injections<Components, Provisions> {
    #private;
    /** Bind an `Injectable` to this `Injector`. */
    bind<I extends Injectable<Components, Provisions>>(injectable: I & CheckInjectable<I, Components, Provisions>): Injector<Components | I, Provisions>;
    /** Bind an `Injectable` to a `Constructor` in this `Injector`. */
    bind<C extends Constructor, I extends Injectable<Components, Provisions, InstanceType<C>>>(component: C, injectable: I & CheckInjectable<I, Components, Provisions>): Injector<Components | C, Provisions>;
    /** Bind an `Injectable` to a name in this `Injector`. */
    bind<P extends string, I extends Injectable<Components, Provisions>>(provision: P, injectable: I & CheckInjectable<I, Components, Provisions>): Injector<Components, ExtendProvisions<Provisions, P, InstanceType<I>>>;
    /** Use a `Factory` to create instances bound to the given `Constructor`. */
    create<C extends Constructor>(component: C, factory: Factory<Components, Provisions, InstanceType<C>>): Injector<Components | C, Provisions>;
    /** Use a `Factory` to create instances bound to the given name. */
    create<P extends string, F extends Factory<Components, Provisions>>(provision: P, factory: F): Injector<Components, ExtendProvisions<Provisions, P, ReturnType<F>>>;
    /** Provision an environment variable. */
    env<E extends string>(variable: E, defaultValue?: string): Injector<Components, ExtendProvisions<Provisions, E, string>>;
    /** Use the given instance binding it to to the given `Constructor`. */
    use<C extends Constructor>(component: C, instance: InstanceType<C> | PromiseLike<InstanceType<C>>): Injector<Components | C, Provisions>;
    /** Use the given instance binding it to to the given name. */
    use<P extends string, T>(provision: P, instance: T | PromiseLike<T>): Injector<Components, ExtendProvisions<Provisions, P, T>>;
    /** Get a _bound_ instance from an `Injector` */
    get<C extends Components>(component: C): Promise<InstanceType<C>>;
    /** Get a _provisioned_ instance from an `Injector` */
    get<P extends keyof Provisions>(provision: P): Promise<Provisions[P]>;
    /**
     * Create a new instance of the specified `Injectable`, providing all
     * necessary injections.
     *
     * @param injectable The constructor of the instance to create.
     */
    inject<I extends Injectable<Components, Provisions>>(injectable: I & CheckInjectable<I, Components, Provisions>): Promise<InstanceType<I>>;
    /**
     * Simple utility method to invoke the factory with the correct `Injections`
     * and return its result.
     *
     * This can be used to alleviate issues when top-level await is not available.
     */
    make<F extends Factory<Components, Provisions>>(factory: F): ReturnType<F>;
    /** Create a sub-`Injector` child of this one. */
    injector(): Injector<Components, Provisions>;
}
export {};