import { Container as Container_2 } from 'inversify';
import { FC } from 'react';
import { inject as inject_2 } from 'inversify';
import { injectable } from 'inversify';
import { interfaces } from 'inversify';
import * as inversifyReact from 'inversify-react';
import { ReactNode } from 'react';

export declare type AsyncModuleRegistry = (container: Container) => Promise<void>;

export declare class Container {
    protected parent?: Container | undefined;
    protected container: Container_2;
    constructor(parent?: Container | undefined);
    bindConstant<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, value: T): this;
    bindDynamic<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, func: (context: interfaces.Context) => T): this;
    bindTransient<T>(constructor: {
        new (...args: any[]): T;
    }): this;
    bindTransient<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, constructor: {
        new (...args: any[]): T;
    }): this;
    bindSingleton<T>(constructor: {
        new (...args: any[]): T;
    }): this;
    bindSingleton<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, constructor: {
        new (...args: any[]): T;
    }): this;
    associateWith<T>(serviceIdentifierFrom: interfaces.ServiceIdentifier<T>, serviceIdentifierTo: interfaces.ServiceIdentifier<T>): this;
    load(...moduleRegistries: Array<ModuleRegistry>): void;
    loadAsync(...asnycModuleRegistries: Array<AsyncModuleRegistry>): Promise<void>;
    get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
    getAll<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): Array<T>;
    takeSnapshot(): void;
    restoreSnapshot(): void;
    _diContainer(): interfaces.Container;
}

export declare const ContainerProvider: FC<ContainerProviderProps>;

export declare interface ContainerProviderProps {
    container: Container;
    children: ReactNode;
}

export declare function inject<T = unknown>(serviceIdentifier: interfaces.ServiceIdentifier<T>): ReturnType<typeof inject_2<T>>;

export declare namespace inject {
    var optional: <T = unknown>(serviceIdentifier: interfaces.ServiceIdentifier<T>) => ReturnType<typeof inject_2<T>>;
}

export { injectable }

export declare type ModuleRegistry = (container: Container) => void;

export declare const service: typeof injectable;

export declare const store: typeof injectable;

export declare const useInjection: typeof inversifyReact.useInjection;

export { }