type ResolverTargetFunction<Module> = (cradle: any) => Module;
type ResolverTargetClass<Module> = new (cradle: any) => Module;
type ResolverTarget<Module> = ResolverTargetFunction<Module> | ResolverTargetClass<Module>;
type ResolverStrategy = 'transient' | 'singleton';
interface ResolverInterface<Module> {
    target: ResolverTarget<Module>;
    strategy?: ResolverStrategy;
}
interface ResolverOptions {
    strategy?: ResolverStrategy;
}
type ResolverEntries = Record<string, [ResolverTarget<unknown>, ResolverOptions?]>;
interface ContainerInstance<Registrations extends object> {
    register: (entries: ResolverEntries) => void;
    resolve: <Key extends keyof Registrations>(key: Key) => Registrations[Key];
    inject: <Module>(target: ResolverTarget<Module>) => Module;
    createScope: <ScopeRegistrations extends object>() => ContainerInstance<Registrations & ScopeRegistrations>;
}
interface ContainerOptions {
    defaultStrategy?: ResolverStrategy;
}
interface RegistryInstance {
    registrationMap: Map<string, ResolverInterface<unknown>>;
}
interface RegistryOptions extends ContainerOptions {
    parentRegistry?: RegistryInstance;
}

declare const createContainer: <Registrations extends object>(options?: ContainerOptions) => ContainerInstance<Registrations>;

export { type ContainerInstance, type ContainerOptions, type RegistryInstance, type RegistryOptions, type ResolverEntries, type ResolverInterface, type ResolverOptions, type ResolverStrategy, type ResolverTarget, type ResolverTargetClass, type ResolverTargetFunction, createContainer };