/**
 * Helper type to represent any callable that can be used as a dependency source
 * This accepts:
 * - Concrete classes (new (...args) => T)
 * - Abstract classes (abstract new (...args) => T)
 * - Plain functions ((...args) => T)
 */
export type Callable<T = any> = (new (...args: any[]) => T) | (abstract new (...args: any[]) => T) | ((...args: any[]) => T);
export interface Tagged<TAG> {
    _type: TAG;
}
/**
 * Primitive type constructors
 */
export type PrimitiveType = typeof String | typeof Number | typeof Boolean | typeof Symbol | typeof BigInt;
/**
 * TypeTag - An ADT representing a type identifier for dependency injection
 *
 * Can be one of:
 * - CallableTag: A class, abstract class, or function
 * - PrimitiveTag: A JavaScript primitive type (String, Number, Boolean, Symbol, BigInt)
 * - TokenTag: A Symbol instance used to represent an interface
 * - SetTag: A set of elements of a given type
 */
export type TypeTag<T = any> = {
    kind: 'tagged';
    value: Tagged<T>;
} | {
    kind: 'callable';
    value: Callable<T>;
} | {
    kind: 'primitive';
    value: PrimitiveType;
    name: string;
} | {
    kind: 'token';
    value: symbol;
    description: string;
} | {
    kind: 'set';
    elementTag: TypeTag<any>;
};
/**
 * Helper functions to create TypeTags
 */
export declare const TypeTag: {
    /**
     * Create a TypeTag from a callable (class or function)
     */
    callable<T>(callable: Callable<T>): TypeTag<T>;
    tagged<TAG>(tagged: Tagged<TAG>): TypeTag<TAG>;
    /**
     * Create a TypeTag from a symbol token (for representing interfaces)
     */
    token<T>(token: symbol): TypeTag<T>;
    /**
     * Create a TypeTag for String type
     */
    string(): TypeTag<string>;
    /**
     * Create a TypeTag for Number type
     */
    number(): TypeTag<number>;
    /**
     * Create a TypeTag for Boolean type
     */
    boolean(): TypeTag<boolean>;
    /**
     * Create a TypeTag for Symbol type
     */
    symbol(): TypeTag<symbol>;
    /**
     * Create a TypeTag for BigInt type
     */
    bigint(): TypeTag<bigint>;
    /**
     * Get a string representation of a TypeTag
     */
    toString(tag: TypeTag): string;
    /**
     * Create a TypeTag for a set of elements
     */
    set<T>(elementTag: TypeTag<T>): TypeTag<Set<T>>;
};
/**
 * Unique identifier for a dependency in the dependency injection graph.
 * Can identify types by constructor, named bindings using @Id, or set bindings.
 */
export declare class DIKey<T = any> {
    readonly type: TypeTag<T>;
    readonly id?: string | undefined;
    private readonly _brand;
    constructor(type: TypeTag<T>, id?: string | undefined);
    /**
     * Create a DIKey for a type
     */
    static of<T>(type: Callable<T>): DIKey<T>;
    /**
     * Create a named DIKey (for @Id bindings)
     */
    static named<T>(type: Callable<T>, id: string): DIKey<T>;
    /**
     * Create a DIKey for a symbol token (for interface bindings)
     */
    static token<T>(token: symbol): DIKey<T>;
    /**
     * Create a named DIKey for a symbol token
     */
    static namedToken<T>(token: symbol, id: string): DIKey<T>;
    /**
     * Create a DIKey for a set binding
     */
    static set<T>(type: Callable<T>): DIKey<Set<T>>;
    /**
     * Create a DIKey for a named set binding
     */
    static namedSet<T>(type: Callable<T>, id: string): DIKey<Set<T>>;
    /**
     * Create a DIKey for a set binding using a symbol token
     */
    static setToken<T>(token: symbol): DIKey<Set<T>>;
    /**
     * Create a DIKey for a named set binding using a symbol token
     */
    static namedSetToken<T>(token: symbol, id: string): DIKey<Set<T>>;
    /**
     * Get the raw callable from this key (for callable types)
     * Returns undefined for primitive types
     */
    getCallable(): Callable<T> | undefined;
    /**
     * Check if this key matches another key
     */
    equals(other: DIKey): boolean;
    /**
     * Deep equality check for TypeTags
     */
    private typeTagEquals;
    /**
     * Get a string representation of this key for debugging and error messages
     */
    toString(): string;
    /**
     * Get a hashable key for use in Maps
     */
    toMapKey(): string;
}
/**
 * Metadata key for storing @Id annotations
 */
export declare const ID_METADATA_KEY: unique symbol;
/**
 * Store for named parameter annotations
 */
export declare const PARAM_IDS_METADATA_KEY: unique symbol;
//# sourceMappingURL=DIKey.d.ts.map