import { AbstractResolvable, IInjections } from 'metaf-resolvable';
import React from 'react';
import { IRequirements } from './Resolver';
export declare type Component<I extends IInjections = {}> = new <P = {}, S = {}, SS = any>(props: Readonly<P>) => AbstractResolvable</* ISyncDependencies< */ I> & React.Component<P, S, SS>;
export interface IComponent {
    /**
     * Resolvable component factory
     * @description creates new class with resolved `injections` as `dependencies` and
     * inform `ApplicationRoot` that it should fit specific `requirements`
     * @template I type of injections' dictionary
     * @template R type of requirements' tuple
     * @param injections dependencies that will be used by component directly
     * @param requirements dependencies that should exist in code that use this component
     * @returns react `Component` class to extend
     */
    <I extends IInjections = {}, R extends IRequirements = []>(injections: I, ...requirements: R): Component<I>;
    /**
     * Resolvable component factory
     * @description creates new class without `dependencies` but with
     * informing `ApplicationRoot` that it should fit specific `requirements`
     * @template R type of requirements' tuple
     * @param requirements dependencies that should exist in code that use this class
     * @returns component class to extend
     */
    <R extends IRequirements = []>(...requirements: R): Component;
}
/**
 * @description Component factory
 */
export declare const Component: IComponent;
export declare type ResolvableComponent<I extends IInjections = {}> = Component;
/**
 * @deprecated please, use `Component` instead
 */
export declare const ResolvableComponent: IComponent;
//# sourceMappingURL=Component.d.ts.map