import { ComponentType, PropsWithChildren } from 'react';
import { Middleware } from 'handler-chain';

type ComponentResult<Props = {
    children?: never;
}> = ComponentType<Props> | false | null | undefined;
type ComponentMiddleware<Request, Props = {
    children?: never;
}, Init = undefined> = Middleware<ComponentResult<Props>, Request, Init>;

type ResultComponent<Props> = ComponentType<Props> | false | null | undefined;
type UseBuildComponentCallbackOptions<Props> = {
    fallbackComponent?: ResultComponent<Props> | undefined;
};
interface UseBuildComponentCallback<Request, Props> {
    (request: Request, options?: undefined | UseBuildComponentCallbackOptions<Props>): ComponentType<Props> | undefined;
}
type ProviderProps<Request, Props, Init> = PropsWithChildren<{
    middleware: readonly ComponentMiddleware<Request, Props, Init>[];
}> & (Init extends never | void ? {
    readonly init?: undefined;
} : Init extends undefined | void ? {
    readonly init?: Init;
} : {
    readonly init: Init;
});
type ProxyProps<Request, Props extends object> = Props & {
    readonly fallbackComponent?: ComponentType<Props> | undefined;
    readonly request: Request;
};
type CreateChainOfResponsibilityOptions = {
    /**
     * Allows a middleware to pass another request object when calling its next middleware. Default is false.
     *
     * However, middleware could modify the request object before calling its next middleware. It is recommended
     * to use Object.freeze() to prevent middleware from modifying the request object.
     */
    readonly passModifiedRequest?: boolean | undefined;
};
type AsMiddlewareProps<Request, Props, Init> = {
    readonly init: Init;
    readonly Next: ComponentType<Partial<Props>>;
    readonly request: Request;
};
type AsMiddlewareComponentProps<Request, Props, Init> = Props & {
    readonly middleware: AsMiddlewareProps<Request, Props, Init>;
};
type ChainOfResponsibility<Request, Props extends object, Init> = {
    readonly asMiddleware: (middlewareComponent: ComponentType<AsMiddlewareComponentProps<Request, Props, Init>>) => ComponentMiddleware<Request, Props, Init>;
    readonly Provider: ComponentType<ProviderProps<Request, Props, Init>>;
    readonly Proxy: ComponentType<ProxyProps<Request, Props>>;
    readonly types: {
        readonly init: Init;
        readonly middleware: ComponentMiddleware<Request, Props, Init>;
        readonly middlewareComponentProps: AsMiddlewareComponentProps<Request, Props, Init>;
        readonly props: Props;
        readonly proxyProps: ProxyProps<Request, Props>;
        readonly request: Request;
    };
    readonly useBuildComponentCallback: () => UseBuildComponentCallback<Request, Props>;
};
declare function createChainOfResponsibility<Request = void, Props extends object = {
    readonly children?: never;
}, Init = void>(options?: CreateChainOfResponsibilityOptions): ChainOfResponsibility<Request, Props, Init>;

export { type CreateChainOfResponsibilityOptions as C, type ComponentMiddleware as a, createChainOfResponsibility as c };