declare const HTTP_CONTEXT_TOKEN: unique symbol;
export type HttpContextToken<T> = (() => T) & {
	readonly [HTTP_CONTEXT_TOKEN]: () => T;
};
export declare function makeHttpContextToken<T>(defaultValue: () => T): HttpContextToken<T>;
export declare function isHttpContextToken(value: unknown): value is HttpContextToken<unknown>;
declare const HTTP_CONTEXT: unique symbol;
export type HttpContext = {
	set<T>(token: HttpContextToken<T>, value: T): HttpContext;
	get<T>(token: HttpContextToken<T>): T;
	del(token: HttpContextToken<unknown>): HttpContext;
	has(token: HttpContextToken<unknown>): boolean;
	keys(): IterableIterator<HttpContextToken<unknown>>;
	get length(): number;
	readonly [HTTP_CONTEXT]: Map<HttpContextToken<unknown>, unknown>;
};
export declare function makeHttpContext(): HttpContext;
export declare function makeHttpContext(entries?: readonly (readonly [
	HttpContextToken<unknown>,
	unknown
])[]): HttpContext;
export declare function makeHttpContext(context?: HttpContext): HttpContext;
export type ValidatorFn<T = unknown> = (value: T) => void;
export type AsyncValidatorFn<T = unknown> = (value: T) => Promise<void>;
export declare const required: ValidatorFn;
export declare const requiredTrue: ValidatorFn;
export declare const minLength: (min: number) => ValidatorFn;
export declare const maxLength: (max: number) => ValidatorFn;
export declare const min: (min: number) => ValidatorFn;
export declare const max: (max: number) => ValidatorFn;
export declare const pattern: (pattern: RegExp) => ValidatorFn;
declare const FIELD: unique symbol;
declare enum FieldType {
	Json = 0,
	Query = 1,
	Param = 2,
	Header = 3,
	Form = 4,
	Body = 5,
	UrlForm = 6
}
export interface FieldMetadata<T = undefined> {
	required: boolean;
	alias: Map<FieldType, string | undefined>;
	validators: ValidatorFn<T>[];
	asyncValidator: AsyncValidatorFn<T>[];
}
export type Field<T = undefined> = (() => T) & {
	withJson(alias?: string): Field<T>;
	withForm(alias?: string): Field<T>;
	withQuery(alias?: string): Field<T>;
	withParam(alias?: string): Field<T>;
	withHeader(alias?: string): Field<T>;
	withUrlForm(alias?: string): Field<T>;
	withBody(): Field<T>;
	withValidators(...fn: ValidatorFn<T>[]): Field<T>;
	withAsyncValidators(...fn: AsyncValidatorFn<T>[]): Field<T>;
	readonly [FIELD]: FieldMetadata<T>;
};
export declare function field(): Field;
export declare function field<T>(): Field<T | undefined>;
export declare function field<T>(defaultValue: T): Field<T>;
export declare function doValid<T>(validators: (ValidatorFn<T> | AsyncValidatorFn<T>)[], value: T): Promise<void>;
export declare function isField(value: unknown): value is Field;
export declare function isFieldGroup(value: unknown): value is Record<PropertyKey, Field>;
export declare const ERR_ABORTED: Error;
export declare const ERR_TIMEOUT: Error;
export declare const ERR_NETWORK: Error;
export declare const ERR_NOT_FOUND_HANDLER: Error;
export declare const ERR_OBSERVE: Error;
export declare const ERR_NOT_SET_ALIAS: Error;
export declare const ERR_UNSUPPORTED_FIELD_TYPE: Error;
export declare const ERR_INVALID_CLIENT: Error;
export declare const ERR_NOT_FOUND_GLOBAL_CLIENT: Error;
export declare const ERR_INVALID_HTTP_CONTEXT_TOKEN: Error;
export declare const ERR_UNKNOWN: Error;
export type HttpResponseBody = string | ArrayBuffer | Blob | object | null;
export type HttpResponse<R> = {
	readonly url: string;
	readonly status: number;
	readonly statusText: string;
	readonly headers: Headers;
	readonly body: R | null;
	readonly error?: Error | string | unknown;
};
export type MakeResponseOptions<R> = {
	status?: number;
	statusText?: string;
	url?: string;
	headers?: Headers;
	body?: R | null;
	error?: Error | string | unknown;
};
export type InterceptorFn = (req: HttpRequest, next: HttpHandler) => Promise<HttpResponse<unknown>>;
export type BasicCredential = {
	username: string;
	password: string;
};
export type BasicAuthInterceptorOptions = {
	encode?: (credential: BasicCredential) => string;
};
export declare function basicAuthInterceptor(fn: () => BasicCredential, options?: BasicAuthInterceptorOptions): InterceptorFn;
export type HttpResponseType = "arraybuffer" | "blob" | "json" | "text";
export interface HttpProgressEvent {
	/**
	 * Indicates whether the resources associated with Progress have a computable length.
	 * Otherwise, the Progress.total attribute will be a meaningless value.
	 */
	readonly lengthComputable: boolean;
	/** Indicates the workload of the underlying process. */
	readonly loaded: number;
	/**
	 * The total size of the data being processed or transmitted.
	 * If the Progress.lengthComputable attribute is false, this value is meaningless and should be ignored.
	 */
	readonly total: number;
}
export type HttpProgressFn = (event: HttpProgressEvent) => void;
export type TransformResponseFn<Output = unknown> = (response: HttpResponse<unknown>) => Output;
export interface HttpRequest {
	host?: string;
	method: string;
	endpoint: string;
	body?: Blob | ArrayBuffer | FormData | URLSearchParams | object | string | number | boolean | null;
	headers?: Headers;
	queryParams?: URLSearchParams;
	/** default：json */
	responseType?: HttpResponseType;
	context?: HttpContext;
	timeout?: number;
	withCredentials?: boolean;
	/** when use fetch handler, no upload progress */
	uploadProgress?: HttpProgressFn;
	downloadProgress?: HttpProgressFn;
	abort?: AbortSignal;
}
export type RequestInputValue<T> = T extends {
	[K in keyof T]: Field<any>;
} ? {
	[K in keyof T]: T[K] extends Field<infer V> ? V : never;
} : never;
export type UseRequestOptions = {
	abort?: AbortSignal;
	handler?: HttpHandler;
	client?: Client;
	timeout?: number;
};
export type UseRequestFn<Input, Output> = {
	doRequest: undefined extends RequestInputValue<Input> ? (input?: RequestInputValue<Input>) => Promise<HttpResponse<Output>> : (input: RequestInputValue<Input>) => Promise<HttpResponse<Output>>;
	cancel: () => void;
	getInitValue: () => RequestInputValue<Input>;
	setUploadProgress: (fn: HttpProgressFn) => void;
	setDownloadProgress: (fn: HttpProgressFn) => void;
};
export interface DefineRequest<Input extends Record<PropertyKey, Field<any>> | undefined = undefined, Output = unknown> {
	(options?: UseRequestOptions): UseRequestFn<Input, Output>;
	withField<I extends Record<PropertyKey, Field<any>>>(value: I): DefineRequest<I, Output>;
	withInterceptors(value: InterceptorFn[]): DefineRequest<Input, Output>;
	withContext(value: HttpContext): DefineRequest<Input, Output>;
	withCredentials(value: boolean): DefineRequest<Input, Output>;
	withValidators(...fn: (ValidatorFn<RequestInputValue<Input>> | AsyncValidatorFn<RequestInputValue<Input>>)[]): DefineRequest<Input, Output>;
	withTransformResponse<O>(fn: TransformResponseFn<O>): DefineRequest<Input, O>;
	withResponseType(value: "json"): DefineRequest<Input, Output>;
	withResponseType(value: "text"): DefineRequest<Input, string>;
	withResponseType(value: "blob"): DefineRequest<Input, Blob>;
	withResponseType(value: "arraybuffer"): DefineRequest<Input, ArrayBuffer>;
}
export declare function defineRequest<Output>(endpoint: string): DefineRequest<undefined, Output>;
export declare function defineRequest<Output>(method: string, endpoint: string): DefineRequest<undefined, Output>;
export type HttpHandler = (req: HttpRequest) => Promise<HttpResponse<unknown>>;
export declare function fetchHandler(httpRequest: HttpRequest): Promise<HttpResponse<unknown>>;
export interface ClientOptions {
	host: string;
	interceptors?: InterceptorFn[];
	handler?: HttpHandler;
}
export type ClientConfig = {
	host: string;
	handler: HttpHandler;
	interceptors: InterceptorFn[];
};
declare const CLIENT: unique symbol;
export type Client = {
	readonly [CLIENT]: ClientConfig;
};
export declare function isClient(value: unknown): value is Client;
export declare function createClient(options: ClientOptions): Client;
export declare function cloneClient(client: Client, options: Partial<ClientOptions>): Client;
export declare function getGlobalClient(): Client;
export declare function setGlobalClient(client: Client): void;
export declare function restGlobalClient(): void;
export declare function createGlobalClient(options: ClientOptions): void;

export {};