import { ComponentType, PropsWithChildren, ReactElement, ReactNode } from 'react';
import { SetOptional } from 'type-fest';

declare global {
    interface ArrayConstructor {
        isArray(arg: any): arg is readonly any[];
    }
}
type BaseProps = object;
type CreateChainOfResponsibilityOptions = {
    /**
     * Allows one component to pass different set of props to its downstream component. Default is false.
     *
     * It is recommended to keep this settings as default to prevent newly added component from unexpectedly changing behavior of downstream components.
     */
    readonly allowOverrideProps?: boolean | undefined;
    /**
     * Allows a middleware to pass another request object when calling its next middleware. Default is false.
     *
     * It is recommended to keep this settings as default ot prevent newly added middleware from unexpectedly changing behavior of downstream middleware.
     *
     * To prevent upstream middleware from modifying the request, the request object should be set to be immutable through `Object.freeze`.
     */
    readonly passModifiedRequest?: boolean | undefined;
};
type ChainOfResponsibility<Request, Props extends BaseProps, Init> = {
    readonly Provider: ComponentType<ProviderProps<Request, Props, Init>> & InferenceHelper<Request, Props, Init>;
    readonly Proxy: ComponentType<ProxyProps<Request, Props>>;
    readonly reactComponent: ReactComponentHandlerResult<Props>;
    readonly useBuildRenderCallback: () => UseBuildRenderCallback<Request, Props>;
};
declare const DO_NOT_CREATE_THIS_OBJECT_YOURSELF: unique symbol;
type ComponentRenderer<Props> = (props: Props) => ReactElement | null;
interface ComponentHandlerResult<Props extends BaseProps> {
    readonly [DO_NOT_CREATE_THIS_OBJECT_YOURSELF]: undefined;
    readonly render: (overridingProps?: Partial<Props> | undefined) => ReactElement | null;
}
type ComponentHandler<Request, Props extends BaseProps> = (request: Request) => ComponentHandlerResult<Props> | undefined;
type ComponentEnhancer<Request, Props extends BaseProps> = (next: ComponentHandler<Request, Props>) => ComponentHandler<Request, Props>;
type ComponentMiddleware<Request, Props extends BaseProps, Init = undefined> = (init: Init) => ComponentEnhancer<Request, Props>;
type ReactComponentInit<Props extends BaseProps, W extends (BaseProps & {
    children?: ReactNode | undefined;
}) | void = void> = W extends void ? {
    wrapperComponent?: undefined;
    wrapperProps?: undefined;
} : {
    wrapperComponent: ComponentType<W>;
    wrapperProps: W | ((props: Props) => W);
};
type ReactComponentHandlerResult<Props extends BaseProps> = <P extends Props, W extends (BaseProps & {
    children?: ReactNode | undefined;
}) | void = void>(component: ComponentType<P>, bindProps?: SetOptional<P, keyof Props> | ((props: Props) => SetOptional<P, keyof Props>) | undefined, init?: ReactComponentInit<Props, W>) => ComponentHandlerResult<Props>;
type UseBuildRenderCallbackOptions<Props> = {
    readonly fallbackComponent?: ComponentType<Props> | undefined;
};
interface UseBuildRenderCallback<Request, Props extends BaseProps> {
    (request: Request, options?: undefined | UseBuildRenderCallbackOptions<Props>): ComponentRenderer<Props> | undefined;
}
type ProviderProps<Request, Props extends BaseProps, Init> = PropsWithChildren<{
    readonly 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 BaseProps> = Props & {
    readonly fallbackComponent?: ComponentType<Props> | undefined;
    readonly request: Request;
};
type InferenceHelper<Request, Props extends BaseProps, Init> = {
    readonly '~types': {
        readonly init: Init;
        readonly middleware: ComponentMiddleware<Request, Props, Init>;
        readonly props: Props;
        readonly proxyProps: ProxyProps<Request, Props>;
        readonly providerProps: ProviderProps<Request, Props, Init>;
        readonly request: Request;
    };
};
type InferInit<T extends InferenceHelper<any, any, any>> = T['~types']['init'];
type InferMiddleware<T extends InferenceHelper<any, any, any>> = T['~types']['middleware'];
type InferProps<T extends InferenceHelper<any, any, any>> = T['~types']['props'];
type InferProxyProps<T extends InferenceHelper<any, any, any>> = T['~types']['proxyProps'];
type InferProviderProps<T extends InferenceHelper<any, any, any>> = T['~types']['providerProps'];
type InferRequest<T extends InferenceHelper<any, any, any>> = T['~types']['request'];
declare function createChainOfResponsibility<Request = void, Props extends BaseProps = {
    readonly children?: never;
}, Init = void>(options?: CreateChainOfResponsibilityOptions): ChainOfResponsibility<Request, Props, Init>;

export { type ChainOfResponsibility, type ComponentEnhancer, type ComponentHandler, type ComponentHandlerResult, type ComponentMiddleware, type ComponentRenderer, type CreateChainOfResponsibilityOptions, type InferInit, type InferMiddleware, type InferProps, type InferProviderProps, type InferProxyProps, type InferRequest, type InferenceHelper, type ProviderProps, type ProxyProps, type ReactComponentHandlerResult, type UseBuildRenderCallback, type UseBuildRenderCallbackOptions, createChainOfResponsibility };