import { NO_PROVIDER, type ServiceName, type Disposer, type FatalErrorPromise, type Provider, type Dependencies, type DependencyDeclaration, type AsyncInitializer, type Initializer } from './util.js';
import initFatalError, { type FatalErrorService } from './fatalError.js';
import initDispose from './dispose.js';
import { type Injector } from './injector.js';
import initInitializerBuilder from './build.js';
import './errors.js';
export type * from './build.js';
export * from './build.js';
export type * from './dispose.js';
export * from './dispose.js';
export type * from './fatalError.js';
export * from './fatalError.js';
export type * from './injector.js';
export type * from './overrides.js';
export * from './overrides.js';
export type * from './sequence.js';
export * from './sequence.js';
export type * from './util.js';
export * from './util.js';
export { initInitializerBuilder, initDispose, initFatalError };
export declare const RUN_DEPENDENT_NAME = "__run__";
export declare const SYSTEM_DEPENDENT_NAME = "__system__";
export declare const AUTO_LOAD_DEPENDENT_NAME = "__autoloader__";
export declare const INJECTOR_DEPENDENT_NAME = "__injector__";
export interface KnifecycleOptions {
    sequential?: boolean;
}
export type Autoloader<T extends Initializer<unknown, Record<string, unknown>>> = (name: DependencyDeclaration) => Promise<T>;
export type SiloIndex = string;
export interface BaseInitializerStateDescriptor<S, D extends Dependencies> {
    dependents: {
        silo?: SiloIndex;
        name: ServiceName;
        optional: boolean;
    }[];
    initializerLoadPromise?: Promise<Initializer<S, D>>;
    initializer?: Initializer<S, D>;
    autoloaded: boolean;
}
export type SiloedInitializerStateDescriptor<S, D extends Dependencies> = BaseInitializerStateDescriptor<S, D> & {
    silosInstances: Record<SiloIndex, {
        dependency?: ServiceName;
        provider?: NonNullable<Provider<S> | typeof NO_PROVIDER>;
        providerLoadPromise?: Promise<void>;
        instanceDisposePromise?: Promise<S>;
    }>;
};
export type SingletonInitializerStateDescriptor<S, D extends Dependencies> = BaseInitializerStateDescriptor<S, D> & {
    singletonProvider?: NonNullable<Provider<S> | typeof NO_PROVIDER>;
    singletonProviderLoadPromise?: Promise<void>;
    disposer?: Disposer;
    fatalErrorPromise?: FatalErrorPromise;
};
export type AutoloadedInitializerStateDescriptor<S, D extends Dependencies> = BaseInitializerStateDescriptor<S, D> & {
    autoloaded: true;
};
export type InitializerStateDescriptor<S, D extends Dependencies> = SingletonInitializerStateDescriptor<S, D> | SiloedInitializerStateDescriptor<S, D> | AutoloadedInitializerStateDescriptor<S, D>;
export interface SiloContext {
    index: SiloIndex;
    loadingServices: ServiceName[];
    loadingSequences: ServiceName[][];
    _shutdownPromise?: Promise<void>;
}
export interface InternalDependencies {
    $dispose: Disposer;
    $autoload: Autoloader<Initializer<unknown, Record<string, unknown>>>;
    $injector: Injector<Record<string, unknown>>;
    $instance: Knifecycle;
    $siloContext: SiloContext;
    $fatalError: FatalErrorService;
}
export declare const UNBUILDABLE_SERVICES: string[];
export declare const INTERNAL_SERVICES: string[];
export declare class Knifecycle {
    private _options;
    private _silosCounter;
    _silosContexts: Record<SiloIndex, SiloContext>;
    _initializersStates: Record<string, InitializerStateDescriptor<unknown, Dependencies>>;
    private _shutdownPromise?;
    /**
     * Create a new Knifecycle instance
     * @param {Object}  options
     * An object with options
     * @param {boolean} options.sequential
     * Allows to load dependencies sequentially (useful for debugging)
     * @return {Knifecycle}
     * The Knifecycle instance
     * @example
     *
     * import Knifecycle from 'knifecycle'
     *
     * const $ = new Knifecycle();
     */
    constructor(options?: KnifecycleOptions);
    /**
     * List registered initializers
     * @return {string[]}
     * The service names registered
     */
    registered(): ServiceName[];
    /**
     * Get a previously registered initializer
     * @param {string} serviceName
     * @return {Initializer}
     * The initializer registered
     */
    getRegisteredInitializer(serviceName: ServiceName): Initializer<unknown, Dependencies> | undefined;
    /**
     * Register an initializer
     * @param  {Function}   initializer
     * An initializer
     * @return {Knifecycle}
     * The Knifecycle instance (for chaining)
     */
    register<T extends Initializer<unknown, any>>(initializer: T): Knifecycle;
    _checkInitializerOverride(serviceName: ServiceName): void;
    _buildInitializerState(initializerState: InitializerStateDescriptor<any, any>, initializer: Initializer<unknown, any>): void;
    _checkInitializerDependencies(initializer: AsyncInitializer<any, any>): void;
    _lookupCircularDependencies(rootServiceName: ServiceName, dependencyDeclaration: DependencyDeclaration, declarationsStacks?: DependencyDeclaration[]): void;
    /**
     * Outputs a Mermaid compatible dependency graph of the declared services.
     * See [Mermaid docs](https://github.com/knsv/mermaid)
     * @param {Object} options
     * Options for generating the graph (destructured)
     * @param {Array<Object>} options.shapes
     * Various shapes to apply
     * @param {Array<Object>} options.styles
     * Various styles to apply
     * @param {Object} options.classes
     * A hash of various classes contents
     * @return {String}
     * Returns a string containing the Mermaid dependency graph
     * @example
     *
     * import Knifecycle, { inject, constant, service } from 'knifecycle';
     * import appInitializer from './app';
     *
     * const $ = new Knifecycle();
     *
     * $.register(constant('ENV', process.env));
     * $.register(constant('OS', require('os')));
     * $.register(service('app', inject(['ENV', 'OS'], appInitializer)));
     * $.toMermaidGraph();
     *
     * // returns
     * graph TD
     *   app-->ENV
     *   app-->OS
     */
    toMermaidGraph({ shapes, styles, classes, }?: {
        shapes?: MermaidShapes;
        styles?: MermaidStyles;
        classes?: MermaidClasses;
    }): string;
    /**
     * Creates a new execution silo
     * @param  {String[]}   dependenciesDeclarations
     * Service name.
     * @return {Promise}
     * Service descriptor promise
     * @example
     *
     * import Knifecycle, { constant } from 'knifecycle'
     *
     * const $ = new Knifecycle();
     *
     * $.register(constant('ENV', process.env));
     * $.run(['ENV'])
     * .then(({ ENV }) => {
     *  // Here goes your code
     * })
     */
    run<ID extends Record<string, unknown>>(dependenciesDeclarations: DependencyDeclaration[]): Promise<ID>;
    _getInitializer(serviceName: ServiceName): Initializer<unknown, Dependencies> | undefined;
    _getServiceProvider(siloContext: SiloContext, serviceName: ServiceName): Provider<unknown> | typeof NO_PROVIDER | undefined;
    _loadInitializerDependencies(siloContext: SiloContext, parentsNames: ServiceName[], dependenciesDeclarations: DependencyDeclaration[], additionalDeclarations: DependencyDeclaration[]): Promise<Dependencies>;
    _loadProvider(siloContext: SiloContext, serviceName: ServiceName, parentsNames: ServiceName[]): Promise<void>;
    _getAutoloader(siloContext: SiloContext, parentsNames: ServiceName[]): Promise<Autoloader<Initializer<unknown, Dependencies<unknown>>> | undefined>;
    _loadInitializer(siloContext: SiloContext, serviceName: ServiceName, parentsNames: ServiceName[]): Promise<void>;
    _resolveDependencies(siloContext: SiloContext, loadingServices: ServiceName[], parentsNames: ServiceName[]): Promise<void>;
    /**
     * Destroy the Knifecycle instance
     * @return {Promise}
     * Full destruction promise
     * @example
     *
     * import Knifecycle, { constant } from 'knifecycle'
     *
     * const $ = new Knifecycle();
     *
     * $.register(constant('ENV', process.env));
     * $.run(['ENV'])
     * .then(({ ENV }) => {
     *    // Here goes your code
     *
     *    // Finally destroy the instance
     *    $.destroy()
     * })
     */
    destroy(): Promise<void>;
}
type MermaidShapes = {
    pattern: RegExp;
    template: string;
}[];
type MermaidStyles = {
    pattern: RegExp;
    className: string;
}[];
type MermaidClasses = Record<string, string>;