import { type AbstractClass, type Class } from "./utils.ts";
import { type Provider } from "./providers.ts";
import type { Container } from "./container.ts";
/**
 * A token is a reference to a service in the dependency injection (DI) container.
 * When obtaining a service from the container, you should use this token.
 */
export type Token<T> = Class<T> | AbstractClass<T> | string | symbol | InjectionToken<T>;
/**
 * A unique injection token object, that is used by reference. Can hold a generic type.
 * Can optionally hold an (async) factory.
 */
export declare class InjectionToken<T> {
    private description;
    options?: InjectionTokenOptions<T> | undefined;
    constructor(description: string | symbol, options?: InjectionTokenOptions<T> | undefined);
    toString(): string;
}
type InjectionTokenOptions<T> = {
    async: true;
    factory: (container: Container) => Promise<T>;
} | {
    async?: false;
    factory: (container: Container) => T;
};
/**
 * Type-guard to check if a token is a class reference.
 *
 * @internal
 */
export declare function isClassToken<T>(token: Token<T>): token is Class<T>;
/**
 * Type-guard to check if a token is an InjectionToken
 *
 * @internal
 */
export declare function isInjectionToken<T>(token: Token<T>): token is InjectionToken<T>;
/**
 * Describes a token, useful for error messages.
 *
 * @internal
 */
export declare function toString<T>(token: Token<T>): string;
/**
 * Returns the token for a provider.
 *
 * @internal
 */
export declare function getToken<T>(provider: Provider<T>): Token<T>;
export {};