/**
 * The one place a binding key is derived for an artifact class - shared by the decorators, the
 * registration path and any framework that registers artifacts itself, so no copy drifts.
 */
export declare class ArtifactBindingKeys {
    /**
     * The key a class registers under: the `binding` it pins, or `<namespace>.<ClassName>`. Only the
     * second is `isDerived` - it follows the class name, which a minified build renames.
     */
    static resolve(opts: {
        target: Function;
        namespace: string;
        binding?: {
            namespace: string;
            key: string;
        };
    }): {
        key: string;
        isDerived: boolean;
    };
    /**
     * The keys two DIFFERENT classes derive alike in one registration. A minified build gives classes
     * in different chunks the same short name; a module evaluated twice (hot reload) does too. A pinned
     * `binding` is a deliberate choice and is never counted, nor is a subclass registered after its
     * parent under the parent's name - the override pattern, where the subclass is meant to win.
     */
    static findDerivedCollisions(opts: {
        entries: Array<{
            target: Function;
            namespace: string;
            binding?: {
                namespace: string;
                key: string;
            };
        }>;
    }): Array<string>;
    /** Throws on the first derived collision - the second binding would silently replace the first. */
    static assertNoDerivedCollision(opts: {
        entries: Array<{
            target: Function;
            namespace: string;
            binding?: {
                namespace: string;
                key: string;
            };
        }>;
        caller: string;
    }): void;
    static describeCollision(opts: {
        key: string;
        caller: string;
    }): string;
}
//# sourceMappingURL=artifact-keys.d.ts.map