import { UrlObject } from 'url';
import * as React from 'react';
import React__default, { ComponentType } from 'react';
import * as http from 'http';
import { IncomingMessage, ServerResponse } from 'http';
import { ZodError } from 'zod';
import { ISettingsParam, ILogObj, Logger } from 'tslog';
import c from 'chalk';
import { Table } from 'console-table-printer';
import ora from 'ora';
import Debug from 'debug';

interface Ctx {
}
type CodegenField = {
    component: string;
    inputType: string;
    zodType: string;
    prismaType: string;
    default?: string;
};
interface AuthenticatedCtx {
}
interface AuthenticatedCtx {
}
type EventHooks = {
    onSessionCreated?: OnSessionCreated;
    onRpcError?: OnRpcError;
};
type BeforeHttpRequest = (request: RequestInit) => RequestInit;
type BeforeHttpResponse = (response: Response) => Response;
type OnRpcError = (error: Error) => Promise<void>;
type OnSessionCreated = () => Promise<void>;
type MiddlewareHooks = {
    beforeHttpRequest?: BeforeHttpRequest;
    beforeHttpResponse?: BeforeHttpResponse;
};
type ResolverConfig = {
    httpMethod: "GET" | "POST";
};
type Codegen = {
    fieldTypeMap?: Partial<Record<"string" | "boolean" | "int" | "number" | "bigint" | "float" | "decimal" | "datetime" | "uuid" | "json", CodegenField>>;
};
type BlitzCliConfig = {
    codegen?: Codegen;
    customTemplates?: string;
};
type CodegenConfig = {
    templateDir?: string;
    fieldTypeMap?: Record<string, CodegenField>;
};
interface RouteUrlObject extends Pick<UrlObject, "pathname" | "query" | "href"> {
    pathname: string;
    href: string;
}
interface RouteUrlObject extends Pick<UrlObject, "pathname" | "query"> {
    pathname: string;
}
declare const isRouteUrlObject: (x: any) => x is RouteUrlObject;
type AsyncFunc = (...args: any) => Promise<any>;
/**
 * Infer the type of the parameter from function that takes a single argument
 */
type FirstParam<F extends (...args: any) => Promise<any>> = Parameters<F>[0];
/**
 * If type has a Promise, unwrap it. Otherwise return the original type
 */
type Await<T> = T extends PromiseLike<infer U> ? U : T;
/**
 * Ensure the type is a promise
 */
type EnsurePromise<T> = T extends PromiseLike<unknown> ? T : Promise<T>;
/**
 * Get the return type of a function which returns a Promise.
 */
type PromiseReturnType<T extends (...args: any) => Promise<any>> = Await<ReturnType<T>>;
interface CancellablePromise<T> extends Promise<T> {
    cancel?: Function;
}
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
type Simplify<T> = {
    [P in keyof T]: T[P];
};
type AddParameters<TFunction extends (...args: any) => any, TParameters extends [...args: any]> = (...args: [...Parameters<TFunction>, ...TParameters]) => ReturnType<TFunction>;

declare global {
    var _blitz_prismaClient: any;
    var __BLITZ_MIDDLEWARE_HOOKS: {
        beforeHttpRequest: BeforeHttpRequest;
        beforeHttpResponse: BeforeHttpResponse;
    };
    var __BLITZ_CLEAN_UP_LISTENERS: () => void;
}

declare class AuthenticationError extends Error {
    name: string;
    statusCode: number;
    constructor(message?: string);
    get _clearStack(): boolean;
}
declare class CSRFTokenMismatchError extends Error {
    name: string;
    statusCode: number;
    get _clearStack(): boolean;
}
declare class OAuthError extends Error {
    name: string;
    statusCode: number;
    redirect?: string;
    get _clearStack(): boolean;
    constructor(message: string, redirect?: string);
}
declare class AuthorizationError extends Error {
    name: string;
    statusCode: number;
    constructor(message?: string);
    get _clearStack(): boolean;
}
declare class NotFoundError extends Error {
    name: string;
    statusCode: number;
    constructor(message?: string);
    get _clearStack(): boolean;
}
declare class RedirectError extends Error {
    name: string;
    statusCode: number;
    url: UrlObject | string;
    constructor(url: UrlObject | string);
    get _clearStack(): boolean;
}
declare class PaginationArgumentError extends Error {
    name: string;
    statusCode: number;
    constructor(message?: string);
}
declare function registerBlitzErrorClasses(): void;

interface Constructor<T = unknown> {
    new (...args: never[]): T;
}
interface EnhancedPrismaClientAddedMethods {
    $reset: () => Promise<void>;
}
interface EnhancedPrismaClientConstructor<TPrismaClientCtor extends Constructor> {
    new (...args: ConstructorParameters<TPrismaClientCtor>): InstanceType<TPrismaClientCtor> & EnhancedPrismaClientAddedMethods;
}
declare const enhancePrisma: <TPrismaClientCtor extends Constructor<unknown>>(client: TPrismaClientCtor) => EnhancedPrismaClientConstructor<TPrismaClientCtor>;

declare const runPrisma: (args: string[], silent?: boolean) => Promise<{
    success: boolean;
    stderr: string | undefined;
} | {
    success: boolean;
    stderr?: undefined;
}>;

declare function handleRequestWithMiddleware<Req extends IncomingMessage = IncomingMessage, Res extends ServerResponse = ServerResponse, MiddlewareResult = void | Promise<void>>(req: Req, res: Res, middleware: RequestMiddleware<Req, Res, MiddlewareResult>[], { throwOnError, stackPrintOnError, }?: {
    throwOnError?: boolean;
    stackPrintOnError?: boolean;
}): Promise<void>;
/**
 * If the middleware function doesn't declare receiving the `next` callback
 * assume that it's synchronous and invoke `next` ourselves
 */
declare function noCallbackHandler<Req extends IncomingMessage = IncomingMessage, Res = MiddlewareResponse>(req: Req, res: Res, next: MiddlewareNext, middleware: RequestMiddleware<Req, Res>): void | Promise<void>;
/**
 * The middleware function does include the `next` callback so only resolve
 * the Promise when it's called. If it's never called, the middleware stack
 * completion will stall
 */
declare function withCallbackHandler<Req extends IncomingMessage = IncomingMessage, Res = MiddlewareResponse>(req: Req, res: Res, next: MiddlewareNext, middleware: RequestMiddleware<Req, Res>): Promise<unknown>;
/**
 * Returns a Blitz middleware function that varies its async logic based on if the
 * given middleware function declares at least 3 parameters, i.e. includes
 * the `next` callback function
 */
declare function connectMiddleware<Req extends IncomingMessage = IncomingMessage, Res extends MiddlewareResponse = MiddlewareResponse>(middleware: RequestMiddleware<Req, Res>): RequestMiddleware<Req, Res>;
declare const secureProxyMiddleware: RequestMiddleware<IncomingMessage & {
    protocol?: string;
}, MiddlewareResponse>;

type PaginateArgs<QueryResult> = {
    skip?: number;
    take?: number;
    maxTake?: number;
    count: () => Promise<number>;
    query: (args: {
        skip: number;
        take: number;
    }) => Promise<QueryResult>;
};
declare function paginate<QueryResult>({ skip, take, maxTake, count: countQuery, query, }: PaginateArgs<QueryResult>): Promise<{
    items: Awaited<QueryResult>;
    nextPage: {
        take: number;
        skip: number;
    } | null;
    hasMore: boolean;
    pageCount: number;
    pageSize: number;
    from: number;
    to: number;
    count: number;
}>;

type BlitzLoggerSettings = ISettingsParam<ILogObj>;
type BlitzLogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
declare const baseLogger: (options?: BlitzLoggerSettings) => Logger<ILogObj>;
declare const BlitzLogger: (settings?: BlitzLoggerSettings) => Logger<ILogObj>;
declare const initializeLogger: (logger: Logger<ILogObj>) => void;
declare const table: typeof Table;
declare const chalk: c.Chalk & c.ChalkFunction & {
    supportsColor: false | c.ColorSupport;
    Level: c.Level;
    Color: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
    ForegroundColor: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
    BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
    Modifiers: "hidden" | "reset" | "bold" | "dim" | "italic" | "underline" | "inverse" | "strikethrough" | "visible";
    stderr: c.Chalk & {
        supportsColor: false | c.ColorSupport;
    };
};
declare const newLine: () => void;

declare const log: {
    withBrand: (str: string) => string;
    withCaret: (str: string) => string;
    branded: (msg: string) => void;
    clearLine: (msg?: string) => void;
    clearConsole: () => void;
    progress: (msg: string) => void;
    spinner: (str: string) => ora.Ora;
    success: (msg: string) => void;
    greenText: (str: string) => string;
    error: (msg: string) => void;
    variable: (val: any) => string;
    debug: Debug.Debugger;
    Table: typeof Table;
    chalk: c.Chalk & c.ChalkFunction & {
        supportsColor: false | c.ColorSupport;
        Level: c.Level;
        Color: ("black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright") | ("bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright");
        ForegroundColor: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "grey" | "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright";
        BackgroundColor: "bgBlack" | "bgRed" | "bgGreen" | "bgYellow" | "bgBlue" | "bgMagenta" | "bgCyan" | "bgWhite" | "bgGray" | "bgGrey" | "bgBlackBright" | "bgRedBright" | "bgGreenBright" | "bgYellowBright" | "bgBlueBright" | "bgMagentaBright" | "bgCyanBright" | "bgWhiteBright";
        Modifiers: "hidden" | "reset" | "bold" | "dim" | "italic" | "underline" | "inverse" | "strikethrough" | "visible";
        stderr: c.Chalk & {
            supportsColor: false | c.ColorSupport;
        };
    };
    box: (mes: string, title: string) => Promise<string>;
};

declare function merge<T, U>([...fns]: Array<(args: T) => U>): (args: T) => U[];
declare function pipe<T>(...fns: Array<(x: T) => T>): (x: T) => T;
declare function reduceBlitzClientPlugins<TPlugins extends readonly ClientPlugin<object>[]>({ plugins, }: {
    plugins: TPlugins;
}): {
    exports: Simplify<UnionToIntersection<{ [I in keyof TPlugins & number]: ReturnType<TPlugins[I]["exports"]>; }[number]>>;
    middleware: {
        beforeHttpRequest: (x: RequestInit) => RequestInit;
        beforeHttpResponse: (x: Response) => Response;
    };
    events: {
        onRpcError: (args: Error) => Promise<void>[];
        onSessionCreated: (args: void) => Promise<void>[];
    };
    withPlugins: (x: React.ComponentType<any>) => React.ComponentType<any>;
};
declare function reduceBlitzServerPlugins<TPlugins extends readonly BlitzServerPlugin<object>[]>({ plugins, }: {
    plugins: TPlugins;
}): {
    pluginExports: Simplify<UnionToIntersection<{ [I in keyof TPlugins & number]: ReturnType<TPlugins[I]["exports"]>; }[number]>>;
    middlewares: RequestMiddleware<any, any, void | Promise<void>>[];
    contextMiddleware: (((ctx: Ctx) => Ctx) | undefined)[];
};

declare function findNodeModulesRoot(src?: string): Promise<string>;
declare function findNodeModulesRootSync(src?: string): string;

declare function startWatcher(pagesDir?: string): Promise<void>;
declare function stopWatcher(): Promise<void>;

interface MiddlewareResponse<C extends Ctx = Ctx> extends ServerResponse {
    blitzCtx: C;
    blitzResult: unknown;
}
type MiddlewareNext = (error?: Error) => Promise<void> | void;
type RequestMiddleware<TRequest extends IncomingMessage = IncomingMessage, TResponse = ServerResponse, TResult = Promise<void> | void> = {
    (req: TRequest, res: TResponse, next: MiddlewareNext): TResult;
    type?: string;
    config?: Record<any, any>;
};
type BlitzServerPlugin<TExports extends object, RequestMiddlewareType = RequestMiddleware<any, any>, TCtx extends Ctx = Ctx> = {
    requestMiddlewares: RequestMiddlewareType[];
    contextMiddleware?: (ctx: TCtx) => TCtx;
    exports: () => TExports;
};
declare function createServerPlugin<TPluginOptions, TCtx extends Ctx, TPluginExports extends object, TMiddleware>(pluginConstructor: (options: TPluginOptions) => BlitzServerPlugin<TPluginExports, TMiddleware, TCtx>): (options: TPluginOptions) => BlitzServerPlugin<TPluginExports, TMiddleware, TCtx>;
declare function createSetupServer<TMiddleware extends RequestMiddleware, TExports extends object>(setupServerConstructor: (plugins: BlitzServerPlugin<TMiddleware>) => TExports): (plugins: BlitzServerPlugin<TMiddleware>) => TExports;
declare const BlitzServerMiddleware: <TMiddleware extends RequestMiddleware<any, any, void | Promise<void>> = RequestMiddleware<IncomingMessage, ServerResponse<IncomingMessage>, void | Promise<void>>>(middleware: TMiddleware) => BlitzServerPlugin<{}>;

declare function assert(condition: any, message: string): asserts condition;
declare const isServer: boolean;
declare const isClient: boolean;
declare const isPast: (date: Date) => boolean;
declare function differenceInMilliseconds(dateLeft: Date, dateRight: Date): number;
declare function differenceInMinutes(dateLeft: Date, dateRight: Date): number;
declare function addMilliseconds(date: Date, amount: number): Date;
declare function addMinutes(date: Date, amount: number): Date;
declare function addYears(date: Date, amount: number): Date;
declare function readCookie(name: string): any;
declare const setCookie: (name: string, value: string, expires: string) => void;
declare const deleteCookie: (name: string) => void;
declare function compose(middleware: RequestMiddleware<any, any, any>[]): RequestMiddleware<http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, void | Promise<void>>;
/**
 * Formats milliseconds to a string
 * If more than 1s, it'll return seconds instead
 * @example
 * prettyMs(100) // -> `100ms`
 * prettyMs(1200) // -> `1.2s`
 * @param ms
 */
declare function prettyMs(ms: number): string;
declare function interopDefault(mod: any): any;
declare function truncateString(str: string, maxLength: number): string;
declare function isNotInUserTestEnvironment(): boolean;

type ParserType = "sync" | "async";
declare function recursiveFormatZodErrors(errors: any): Record<string, any>;
declare function formatZodError(error: ZodError): Record<string, any>;
declare function validateZodSchema(schema: any, parserType: "sync"): (values: any) => any;
declare function validateZodSchema(schema: any, parserType: "async"): (values: any) => Promise<any>;
declare function validateZodSchema(schema: any): (values: any) => Promise<any>;

type BlitzProviderComponentType = <TProps = any>(component: ComponentType<TProps>) => {
    (props: TProps): React__default.JSX.Element;
    displayName: string;
};
type BlitzPluginWithProvider = (x: React__default.ComponentType<any>) => React__default.ComponentType<any>;
interface ClientPlugin<Exports extends object> {
    events: EventHooks;
    middleware: MiddlewareHooks;
    exports: () => Exports;
    withProvider?: BlitzProviderComponentType;
}
declare function createClientPlugin<TPluginOptions, TPluginExports extends object>(pluginConstructor: (options: TPluginOptions) => ClientPlugin<TPluginExports>): (options: TPluginOptions) => ClientPlugin<TPluginExports>;

export { AddParameters, AsyncFunc, AuthenticatedCtx, AuthenticationError, AuthorizationError, Await, BeforeHttpRequest, BeforeHttpResponse, BlitzCliConfig, BlitzLogLevel, BlitzLogger, BlitzLoggerSettings, BlitzPluginWithProvider, BlitzProviderComponentType, BlitzServerMiddleware, BlitzServerPlugin, CSRFTokenMismatchError, CancellablePromise, ClientPlugin, CodegenConfig, CodegenField, Constructor, Ctx, EnhancedPrismaClientAddedMethods, EnhancedPrismaClientConstructor, EnsurePromise, EventHooks, FirstParam, MiddlewareHooks, MiddlewareNext, MiddlewareResponse, NotFoundError, OAuthError, OnRpcError, OnSessionCreated, PaginateArgs, PaginationArgumentError, ParserType, PromiseReturnType, RedirectError, RequestMiddleware, ResolverConfig, RouteUrlObject, Simplify, UnionToIntersection, addMilliseconds, addMinutes, addYears, assert, baseLogger, chalk, compose, connectMiddleware, createClientPlugin, createServerPlugin, createSetupServer, deleteCookie, differenceInMilliseconds, differenceInMinutes, enhancePrisma, findNodeModulesRoot, findNodeModulesRootSync, formatZodError, handleRequestWithMiddleware, initializeLogger, interopDefault, isClient, isNotInUserTestEnvironment, isPast, isRouteUrlObject, isServer, log, merge, newLine, noCallbackHandler, paginate, pipe, prettyMs, readCookie, recursiveFormatZodErrors, reduceBlitzClientPlugins, reduceBlitzServerPlugins, registerBlitzErrorClasses, runPrisma, secureProxyMiddleware, setCookie, startWatcher, stopWatcher, table, truncateString, validateZodSchema, withCallbackHandler };