keq 2.8.14 → 2.9.0

package/packages/keq/dist/index.d.ts

@@ -1,8 +1,962 @@
-export { createRequest, Keq, request, KeqRequest, type KeqOptions, type KeqApiSchema, type KeqOperation, type KeqDefaultOperation, type KeqQueryInit, type KeqPathParameterInit, type KeqQueryOptions, type ServerSentEvent, } from './request';
-export { type KeqBodyInit, } from './request-init';
-export { composeMiddleware, type KeqMiddleware, type KeqNext, } from './middleware';
-export { type KeqRoute, composeRoute, } from './router';
-export { createProxyResponse, KeqExecutionContext, KeqSharedContext, type KeqSharedContextOptions, type KeqContext, type KeqContextData, type KeqContextEmitter, type KeqGlobal, type KeqGlobalCore, type KeqContextOptions, type KeqMiddlewareOptions, type KeqEvents, type KeqRetryDelay, type KeqRetryOn, } from './context';
-export { Exception, TypeException, TimeoutException, AbortException, RequestException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundedException, MethodNotAllowedException, NotAcceptableException, ProxyAuthenticationRequiredException, RequestTimeoutException, ConflictException, PreconditionFailedException, ContentTooLargeException, UriTooLongException, ImATeapotException, TooManyRequestsException, UnsupportedMediaTypeException, InternalServerErrorException, NotImplementedException, BadGatewayException, ServiceUnavailableException, GatewayTimeoutException, } from './exception';
-export { KeqMiddlewareOrchestrator, KeqMiddlewareExecutor, } from './orchestrator';
+import { ConditionalExcept, ConditionalPick, IsUnion, Primitive, Promisable } from "type-fest";
+import { UriTemplateContext } from "@opendoc/uri-template";
+import { Emitter } from "mitt";
+import { IStringifyBaseOptions } from "qs";
+import { EventSourceMessage } from "eventsource-parser";
+import { queueAsPromised } from "fastq";
+import { CustomError } from "ts-custom-error";
+
+//#region src/middleware/types/keq-next.d.ts
+type KeqNext = () => Promise<void>;
+//#endregion
+//#region src/middleware/types/keq-middleware.d.ts
+interface KeqMiddleware {
+  (ctx: KeqExecutionContext, next: KeqNext): Promisable<void>;
+  __keqMiddlewareName__?: string;
+}
+//#endregion
+//#region src/middleware/utils/compose-middleware.d.ts
+interface ComposeMiddlewareOptions {
+  name?: string;
+}
+declare function composeMiddleware(middlewares: KeqMiddleware[], options?: ComposeMiddlewareOptions): KeqMiddleware;
+//#endregion
+//#region src/context/middleware-context.d.ts
+declare const ExecutorProperty$1 = "__KeyProtectedProperty(context.orchestration.middlewares)__";
+declare class KeqMiddlewareContext {
+  readonly [ExecutorProperty$1]: KeqMiddlewareExecutor;
+  constructor(executor: KeqMiddlewareExecutor);
+  get name(): string;
+  get status(): KeqMiddlewareExecutor['status'];
+  get finished(): boolean;
+}
+//#endregion
+//#region src/orchestrator/executor.d.ts
+declare class KeqMiddlewareExecutor {
+  readonly middleware: KeqMiddleware;
+  readonly name: string;
+  status: 'idle' | 'pending' | 'canceled' | 'fulfilled' | 'rejected';
+  context: KeqMiddlewareContext;
+  constructor(middleware: KeqMiddleware);
+  execute(context: KeqExecutionContext, next: KeqNext): Promise<void>;
+}
+//#endregion
+//#region src/orchestrator/orchestrator.d.ts
+interface KeqMiddlewareOrchestratorPointer {
+  orchestrator: KeqMiddlewareOrchestrator;
+  index: number;
+}
+type KeqMiddlewareOrchestratorStatus = 'idle' | 'pending' | 'fulfilled' | 'rejected';
+declare class KeqMiddlewareOrchestrator {
+  main?: KeqMiddlewareOrchestratorPointer;
+  status: KeqMiddlewareOrchestratorStatus;
+  context: KeqSharedContext;
+  executors: KeqMiddlewareExecutor[];
+  current: number;
+  constructor(context: KeqSharedContext, middlewares?: KeqMiddleware[], inherit?: {
+    main?: KeqMiddlewareOrchestratorPointer;
+  });
+  private cancelNotFinished;
+  private run;
+  execute(): Promise<void>;
+  fork(): KeqMiddlewareOrchestrator;
+  merge(source: KeqMiddlewareOrchestrator): void;
+}
+//#endregion
+//#region src/request-init/types/keq-body-init.d.ts
+type KeqBodyInit = BodyInit | object | Array<any> | undefined;
+//#endregion
+//#region src/request-init/types/keq-request-method.d.ts
+type KeqRequestMethod = 'get' | 'post' | 'put' | 'delete' | 'head' | 'patch' | 'options';
+//#endregion
+//#region src/request-init/request-init.d.ts
+interface KeqRequestInitOptions {
+  url: URL;
+  pathParameters: UriTemplateContext;
+  method: KeqRequestMethod;
+  headers: Headers;
+  body: KeqBodyInit;
+  cache?: RequestCache;
+  credentials?: RequestCredentials;
+  integrity?: string;
+  keepalive?: boolean;
+  mode?: RequestMode;
+  redirect?: RequestRedirect;
+  referrer?: string;
+  referrerPolicy?: ReferrerPolicy;
+}
+declare const AbortControllerProperty = "__KeqProtectedProperty(context.request.abortController)__";
+declare class KeqRequestInit {
+  url: URL;
+  pathParameters: UriTemplateContext;
+  method: KeqRequestMethod;
+  headers: Headers;
+  body: KeqBodyInit;
+  cache?: RequestCache;
+  credentials?: RequestCredentials;
+  integrity?: string;
+  keepalive?: boolean;
+  mode?: RequestMode;
+  redirect?: RequestRedirect;
+  referrer?: string;
+  referrerPolicy?: ReferrerPolicy;
+  [AbortControllerProperty]: AbortController;
+  constructor(options: KeqRequestInitOptions);
+  get __url__(): Readonly<URL>;
+  get signal(): AbortSignal;
+  abort(reason: any): void;
+  private getContentType;
+  private toFetchBody;
+  toFetchArguments(): [string, RequestInit];
+}
+//#endregion
+//#region src/context/orchestrator-context.d.ts
+declare const OrchestratorProperty = "__KeyProtectedProperty(context.orchestration.orchestrator)__";
+declare const ExecutorProperty = "__KeyProtectedProperty(context.orchestration.executor)__";
+declare class KeqOrchestratorContext {
+  readonly [OrchestratorProperty]: KeqMiddlewareOrchestrator;
+  readonly [ExecutorProperty]: KeqMiddlewareExecutor;
+  constructor(orchestrator: KeqMiddlewareOrchestrator, executor: KeqMiddlewareExecutor);
+  get middlewares(): KeqMiddlewareContext[];
+  /**
+   * The middleware context of the current middleware
+   */
+  get middleware(): KeqMiddlewareContext;
+  fork(): KeqMiddlewareOrchestrator;
+  merge(source: KeqMiddlewareOrchestrator): void;
+}
+//#endregion
+//#region src/context/shared-context.d.ts
+interface KeqSharedContextOptions {
+  locationId?: string;
+  request: KeqRequestInitOptions;
+  global: KeqGlobal;
+  options?: KeqContextOptions;
+  data?: KeqContextData;
+  emitter?: KeqContextEmitter;
+}
+declare const ContextLocationIdProperty = "__KeqProtectedProperty(context.locationId)__";
+declare const ContextRequestProperty = "__KeqProtectedProperty(context.request)__";
+declare const ContextGlobalProperty = "__KeqProtectedProperty(context.global)__";
+declare const ContextEmitterProperty = "__KeqProtectedProperty(context.emitter)__";
+declare const ContextOptionsProperty = "__KeqProtectedProperty(context.options)__";
+declare const ContextDataProperty = "__KeqProtectedProperty(context.data)__";
+declare const ContextOutputProperty = "__KeqProtectedProperty(context.output)__";
+declare class KeqSharedContext implements KeqContext {
+  readonly [ContextLocationIdProperty]?: string;
+  [ContextRequestProperty]: KeqRequestInit;
+  [ContextGlobalProperty]: Record<string, any>;
+  [ContextEmitterProperty]: KeqContextEmitter;
+  [ContextOptionsProperty]: KeqContextOptions;
+  [ContextOutputProperty]?: any;
+  [ContextDataProperty]: KeqContextData;
+  /**
+   * original response
+   */
+  res?: Response;
+  constructor(options: KeqSharedContextOptions);
+  /**
+   * The unique identifier of the request's location in the code
+   */
+  get locationId(): string | undefined;
+  get request(): KeqRequestInit;
+  get global(): KeqGlobal;
+  get emitter(): KeqContextEmitter;
+  get options(): KeqContextOptions;
+  set output(value: any);
+  get response(): Response | undefined;
+  get data(): KeqContextData;
+}
+//#endregion
+//#region src/context/types/keq-context-emitter.d.ts
+interface KeqEvents {
+  retry: {
+    context: KeqSharedContext;
+  };
+  error: {
+    context: KeqSharedContext;
+  };
+  abort: {
+    context: KeqSharedContext;
+    reason: any;
+  };
+  timeout: {
+    context: KeqExecutionContext;
+  };
+  'fetch:before': {
+    context: KeqExecutionContext;
+  };
+  'fetch:after': {
+    context: KeqExecutionContext;
+  };
+  'middleware:before': {
+    context: KeqExecutionContext;
+  };
+  'middleware:after': {
+    context: KeqExecutionContext;
+  };
+}
+type KeqListeners = { [K in keyof KeqEvents]?: ((data: KeqEvents[K]) => void)[] };
+type KeqContextEmitter = Emitter<Omit<KeqEvents, never>>;
+//#endregion
+//#region src/middlewares/timeout-middleware/index.d.ts
+interface KeqTimeoutOptions {
+  millisecond: number;
+}
+//#endregion
+//#region src/middlewares/flow-control-middleware/types/keq-flow-control.d.ts
+interface KeqFlowControlOptions {
+  mode: 'abort' | 'serial' | 'concurrent' | 'mutex';
+  concurrencyLimit?: number;
+  signal: string | ((ctx: KeqExecutionContext) => string);
+}
+type KeqFlowControlSignal = KeqFlowControlOptions['signal'];
+//#endregion
+//#region src/request/types/keq-query-value.d.ts
+type KeqQueryPrimitive = string | number | bigint | null | undefined;
+type KeqQueryObject<K extends string = string> = { [key in K]: KeqQueryValue };
+type KeqQueryArray = KeqQueryValue[];
+type KeqQueryValue = KeqQueryPrimitive | KeqQueryArray | KeqQueryObject;
+type KeqQueryInit = KeqQueryValue;
+//#endregion
+//#region src/request/types/keq-param-value.d.ts
+type KeqPathParameterInit = UriTemplateContext[string];
+//#endregion
+//#region src/request/types/api-schema/operation.d.ts
+interface KeqOperation {
+  requestParams: { [key in string]: KeqPathParameterInit };
+  requestQuery: { [key in string]: KeqQueryInit };
+  requestHeaders: { [key in string]: string | number };
+  requestBody: KeqBodyInit;
+  responseBody: any;
+}
+//#endregion
+//#region src/request/types/api-schema/api-schema.d.ts
+interface KeqApiSchema {
+  [pathname: string]: { [method in KeqRequestMethod]?: KeqOperation };
+}
+//#endregion
+//#region src/types/literal-keys.d.ts
+/**
+ * Extracts only the literal keys from an object type T.
+ *
+ * @example
+ * ```ts
+ * type Example = {
+ *   [key: string]: number;
+ *   knownProp: string;
+ * }
+ *
+ * type Result = LiteralKeys<Example>;
+ * // Result is { knownProp: string; }
+ * ```
+ */
+type LiteralKeys<T> = { [K in keyof T as K extends string ? (string extends K ? never : K) : K extends number ? (number extends K ? never : K) : K extends symbol ? (symbol extends K ? never : K) : never]: T[K] };
+//#endregion
+//#region src/types/string-index-value-of.d.ts
+/**
+ * Extracts the value type of string index signatures from an object type.
+ *
+ * @example
+ * ```ts
+ * type Example = {
+ *   [key: string]: number | string;
+ *   knownProp: number;
+ * }
+ *
+ * type Result = StringIndexValueOf<Example>;
+ * // Result is number | string
+ * ```
+ */
+type StringIndexValueOf<T> = string extends keyof T ? T extends {
+  [key: string]: infer V;
+} ? V : never : never;
+//#endregion
+//#region src/types/enabled-if-string-index.d.ts
+/**
+ * A utility type that evaluates to `unknown` if the type `T` has a string index signature,
+ * otherwise it evaluates to `never`.
+ *
+ * @example
+ * ```ts
+ * type WithStringIndex = {
+ *   [key: string]: number;
+ *   knownProp: string;
+ * }
+ *
+ * type WithoutStringIndex = {
+ *   knownProp: string;
+ *   anotherProp: number;
+ * }
+ *
+ * type Result1 = EnabledIfStringIndex<WithStringIndex>;
+ * // Result1 is unknown
+ * type Result2 = EnabledIfStringIndex<WithoutStringIndex>;
+ * // Result2 is never
+ * ```
+ */
+type EnabledIfStringIndex<T> = string extends keyof T ? unknown : never;
+//#endregion
+//#region src/types/loose-nested-like.d.ts
+/**
+ * Recursively maps a nested structure `T` so that every leaf value becomes `V`.
+ * Arrays and objects are traversed recursively; primitive leaves are replaced with `V`.
+ *
+ * @example
+ * ```ts
+ * // Scalar → replaced by V
+ * type A = LooseNestedLike<string, number>;
+ * // string
+ *
+ * // Array → each element is recursively mapped
+ * type B = LooseNestedLike<string, [number, boolean]>;
+ * // [string, string]
+ *
+ * // Nested object → every leaf becomes V
+ * type C = LooseNestedLike<string, { a: number; b: { c: boolean } }>;
+ * // { a: string; b: { c: string } }
+ * ```
+ */
+type LooseNestedLike<V, T> = T extends any[] ? { [I in keyof T]: LooseNestedLike<V, T[I]> } : T extends object ? { [K in keyof T]: LooseNestedLike<V, T[K]> } : V;
+/**
+ * Conditional guard that resolves to `unknown` when `T` is structurally compatible
+ * with `LooseNestedLike<V, T>`, and `never` otherwise.
+ * Useful as a constraint in generic parameters to ensure a value matches
+ * the expected nested shape.
+ *
+ * @example
+ * ```ts
+ * // T's leaves are all assignable to string → passes
+ * type Ok = EnableLooseNestedLike<string, { a: string; b: { c: string } }>;
+ * // unknown
+ *
+ * // T contains a leaf (number) not assignable to string → fails
+ * type Fail = EnableLooseNestedLike<string, { a: string; b: { c: number } }>;
+ * // never
+ * ```
+ */
+type EnableLooseNestedLike<V, T> = T extends LooseNestedLike<V, T> ? unknown : never;
+/**
+ * Maps each property of `U` through `LooseNestedLike`, using the string-index
+ * value type of `T` as the leaf replacement type.
+ * Commonly used to validate that a user-supplied object `U` has the same nested
+ * shape but with values drawn from `T`'s string index signature.
+ *
+ * @example
+ * ```ts
+ * type Schema = { [key: string]: string | number };
+ *
+ * type Input = {
+ *   name: string;
+ *   meta: { tag: boolean };
+ * };
+ *
+ * type Result = LooseNestedObject<Schema, Input>;
+ * // { name: string | number; meta: { tag: string | number } }
+ * ```
+ */
+type LooseNestedObject<T, U> = { [K in keyof U]: LooseNestedLike<StringIndexValueOf<T>, U[K]> };
+//#endregion
+//#region src/types/override.d.ts
+/**
+ * Override properties of Destination with properties from Source.
+ *
+ * Unlike type-fest's `Merge`, this uses only built-in TypeScript type
+ * operations (`Omit` + `&`), ensuring the result remains transparent
+ * to the type checker — property access like `Override<A, B>['key']`
+ * resolves eagerly instead of producing opaque conditional types.
+ *
+ * @example
+ * ```ts
+ * type Base = { a: string; b: number; c: boolean }
+ * type Result = Override<Base, { b: string }>
+ * // Result is { a: string; b: string; c: boolean }
+ * ```
+ */
+type Override<Destination, Source> = Omit<Destination, keyof Source> & Source;
+//#endregion
+//#region src/request/types/api-schema/default-operation.d.ts
+interface DefaultOperation extends KeqOperation {
+  requestHeaders: {
+    'content-type': string;
+    accept: string;
+    'accept-language': string;
+    authorization: string;
+    'cache-control': string;
+    'if-modified-since': string;
+    'if-none-match': string;
+    referer: string;
+    [key: string]: string | number;
+  };
+  responseBody: unknown;
+}
+type KeqDefaultOperation<T extends Partial<KeqOperation> = {}> = Override<DefaultOperation, T>;
+//#endregion
+//#region src/request/types/api-schema/extract-method-operations.d.ts
+/**
+ * Extract operations by method from API schema
+ *
+ * @example
+ * ```
+ * type MyApiSchema = {
+ *   '/users': {
+ *     get: { ... }
+ *     post: { ... }
+ *   }
+ * }
+ *
+ * type GetOperations = ExtractMethodOperations<MyApiSchema, 'get'>
+ * // Result:
+ * // {
+ * //   '/users': { ... }
+ * // }
+ *
+ * // Union method results in never
+ * type NeverOperations = ExtractMethodOperations<MyApiSchema, 'put' | 'delete'>
+ * // Result: never
+ * ```
+ */
+type ExtractMethodOperations<T extends KeqApiSchema, M extends KeqRequestMethod> = IsUnion<M> extends true ? never : { [P in keyof T as T[P][M] extends KeqOperation ? P : never]: T[P][M] extends KeqOperation ? T[P][M] : never };
+//#endregion
+//#region src/request/types/content-type.d.ts
+type ShorthandContentType = 'json' | 'form-data' | 'form' | 'jpeg' | 'bmp' | 'apng' | 'gif' | 'x-icon' | 'png' | 'webp' | 'tiff' | 'svg' | 'xml' | 'html' | 'css';
+type CommonContentType = 'application/json' | 'multipart/form-data' | 'application/x-www-form-urlencoded' | 'image/jpeg' | 'image/bmp' | 'image/apng' | 'image/gif' | 'image/x-icon' | 'image/png' | 'image/webp' | 'image/tiff' | 'image/svg+xml' | 'text/xml' | 'text/html' | 'text/css';
+//#endregion
+//#region src/request/types/keq-attachable-file.d.ts
+type KeqAttachableFile = Blob | File | Buffer;
+//#endregion
+//#region src/request/types/keq-query-options.d.ts
+interface KeqQueryOptions {
+  indices?: IStringifyBaseOptions['indices'];
+  arrayFormat?: IStringifyBaseOptions['arrayFormat'] | 'pipe' | 'space';
+  allowDots?: boolean;
+}
+//#endregion
+//#region src/request/types/server-sent-event.d.ts
+type ServerSentEvent = EventSourceMessage;
+//#endregion
+//#region src/request/keq.d.ts
+/**
+ * extends Core to provide a fluent API for building HTTP requests
+ */
+declare class Keq<OP extends KeqOperation = KeqDefaultOperation, RES_BODY extends KeqOperation['responseBody'] = OP['responseBody'], REQ_PARAMS extends KeqOperation['requestParams'] = OP['requestParams'], REQ_QUERY extends KeqOperation['requestQuery'] = OP['requestQuery'], REQ_HEADERS extends KeqOperation['requestHeaders'] = OP['requestHeaders'], REQ_BODY extends KeqOperation['requestBody'] = OP['requestBody']> extends Core<OP> {
+  /**
+   * Set request header
+   *
+   * @description 设置请求头
+   */
+  set(headers: Partial<REQ_HEADERS> | Headers): this;
+  set<T extends keyof LiteralKeys<REQ_HEADERS>>(name: T, value: LiteralKeys<REQ_HEADERS>[T]): this;
+  set<O extends { [K in keyof O]: StringIndexValueOf<REQ_HEADERS> }>(obj: Partial<O> & EnabledIfStringIndex<REQ_HEADERS>): this;
+  set<O extends { [K in keyof O]: StringIndexValueOf<REQ_HEADERS> }>(key: string, value: StringIndexValueOf<REQ_HEADERS> & EnabledIfStringIndex<REQ_HEADERS>): this;
+  /**
+   * Set request headers
+   */
+  headers(headers: Partial<REQ_HEADERS> | Headers): this;
+  headers<T extends keyof LiteralKeys<REQ_HEADERS>>(name: T, value: LiteralKeys<REQ_HEADERS>[T]): this;
+  headers<O extends { [K in keyof O]: StringIndexValueOf<REQ_HEADERS> }>(obj: Partial<O> & EnabledIfStringIndex<REQ_HEADERS>): this;
+  headers<O extends { [K in keyof O]: StringIndexValueOf<REQ_HEADERS> }>(key: string, value: StringIndexValueOf<REQ_HEADERS> & EnabledIfStringIndex<REQ_HEADERS>): this;
+  /**
+   * Set request query/searchParams
+   */
+  query(obj: Partial<REQ_QUERY>, options?: KeqQueryOptions): this;
+  query<T extends keyof LiteralKeys<REQ_QUERY>>(key: T, value: LiteralKeys<REQ_QUERY>[T], options?: KeqQueryOptions): this;
+  /**
+   * The following two overloads handle flat (non-nested) query params
+   * with arbitrary key names when REQ_QUERY has a string index signature (`[key: string]: ...`).
+   * Values must be directly assignable to the string index value type — no nested objects.
+   *
+   * @example
+   * ```ts
+   * // Given REQ_QUERY = { [key: string]: string }
+   * request.query('customKey', 'value')
+   * request.query({ customKey: 'value', anotherKey: 'value2' })
+   * ```
+   */
+  query<O extends { [K in keyof O]: StringIndexValueOf<REQ_QUERY> }>(key: string, obj: (StringIndexValueOf<REQ_QUERY> & EnabledIfStringIndex<REQ_QUERY>) | undefined, options?: KeqQueryOptions): this;
+  query<O extends { [K in keyof O]: StringIndexValueOf<REQ_QUERY> }>(obj: Partial<O> & EnabledIfStringIndex<REQ_QUERY>, options?: KeqQueryOptions): this;
+  /**
+   * The following two overloads handle nested object query params
+   * when REQ_QUERY has a string index signature (`[key: string]: ...`).
+   * Every leaf value in the nested object must be assignable to the string index value type of REQ_QUERY.
+   *
+   * @example
+   * ```ts
+   * // Given REQ_QUERY = { [key: string]: string }
+   * request.query({ filter: { status: 'active', tags: ['a', 'b'] } })
+   * request.query('filter', { status: 'active', tags: ['a', 'b'] })
+   * ```
+   */
+  query<O extends object>(arg: O & Partial<LooseNestedObject<REQ_QUERY, O>> & EnableLooseNestedLike<StringIndexValueOf<REQ_QUERY>, O> & EnabledIfStringIndex<REQ_QUERY>): this;
+  query<K extends keyof REQ_QUERY, O extends object>(key: K, arg: (O & LooseNestedLike<StringIndexValueOf<REQ_QUERY>, O> & EnableLooseNestedLike<StringIndexValueOf<REQ_QUERY>, O> & EnabledIfStringIndex<REQ_QUERY>) | undefined, options?: KeqQueryOptions): this;
+  /**
+   * Set request route params
+   */
+  params(params: Partial<REQ_PARAMS>): this;
+  params<T extends keyof LiteralKeys<REQ_PARAMS>>(key: T, value: LiteralKeys<REQ_PARAMS>[T]): this;
+  params<O extends { [K in keyof O]: StringIndexValueOf<REQ_PARAMS> }>(obj: Partial<O> & EnabledIfStringIndex<REQ_PARAMS>): this;
+  params<O extends { [K in keyof O]: StringIndexValueOf<REQ_PARAMS> }>(key: string, value: StringIndexValueOf<REQ_PARAMS> & EnabledIfStringIndex<REQ_PARAMS>): this;
+  /**
+   * Set request body
+   */
+  body(value: KeqBodyInit): this;
+  /**
+   * Setting the Content-Type
+   */
+  type(contentType: ShorthandContentType): this;
+  type(contentType: CommonContentType): this;
+  type(contentType: string): this;
+  /**
+   * Http Basic Authentication
+   */
+  auth(username: string, password: string): this;
+  private setTypeIfEmpty;
+  /**
+   * set request body
+   */
+  send(value: Partial<REQ_BODY>): this;
+  field<T extends ConditionalPick<RES_BODY, Primitive>, K extends keyof T>(arg1: K, value: T[K]): this;
+  field(arg1: ConditionalPick<RES_BODY, Primitive>): this;
+  field(arg1: string, value: string | string[]): this;
+  field(arg1: Record<string, string>): this;
+  attach<T extends keyof ConditionalPick<REQ_BODY, KeqAttachableFile>>(key: T, value: KeqAttachableFile, filename: string): this;
+  attach<T extends keyof ConditionalPick<REQ_BODY, KeqAttachableFile>>(key: T, value: KeqAttachableFile | KeqAttachableFile[]): this;
+  attach(key: string, value: KeqAttachableFile, filename: string): this;
+  attach(key: string, value: KeqAttachableFile | KeqAttachableFile[]): this;
+  /**
+   *
+   * @param retryTimes Max number of retries per call
+   * @param retryDelay Initial value used to calculate the retry in milliseconds (This is still randomized following the randomization factor)
+   * @param retryCallback Will be called after request failed
+   */
+  retry(retryTimes: number, retryDelay?: KeqRetryDelay, retryOn?: KeqRetryOn): this;
+  redirect(mod: RequestRedirect): this;
+  credentials(mod: RequestCredentials): this;
+  mode(mod: RequestMode): this;
+  flowControl(mode: 'concurrent', limit: number, signal?: KeqFlowControlSignal): this;
+  flowControl(mode: 'serial', signal?: KeqFlowControlSignal): this;
+  flowControl(mode: 'abort', signal?: KeqFlowControlSignal): this;
+  flowControl(mode: 'mutex', signal?: KeqFlowControlSignal): this;
+  timeout(milliseconds: number): this;
+  resolveWith(m: 'response'): Keq<Override<OP, {
+    responseBody: Response;
+  }>>;
+  resolveWith(m: 'array-buffer'): Keq<Override<OP, {
+    responseBody: ArrayBuffer;
+  }>>;
+  resolveWith(m: 'blob'): Keq<Override<OP, {
+    responseBody: Blob;
+  }>>;
+  resolveWith(m: 'text'): Keq<Override<OP, {
+    responseBody: string;
+  }>>;
+  resolveWith(m: 'sse'): Keq<Override<OP, {
+    responseBody: ReadableStream<ServerSentEvent>;
+  }>>;
+  resolveWith<T = any>(m: 'json' | 'form-data'): Keq<Override<OP, {
+    responseBody: T;
+  }>>;
+}
+//#endregion
+//#region src/context/types/keq-context-options/keq-resolve-with-mode.d.ts
+type KeqResolveWithMode = 'intelligent' | 'response' | 'text' | 'json' | 'form-data' | 'blob' | 'array-buffer' | 'sse';
+//#endregion
+//#region src/context/types/keq-context-options/keq-retry-options.d.ts
+type KeqRetryOn = (attempt: number, error: unknown | null, ctx: KeqSharedContext) => (boolean | Promise<boolean>);
+type KeqRetryDelay = number | ((attempt: number, error: unknown | null, ctx: KeqSharedContext) => number | Promise<number>);
+interface KeqRetryOptions {
+  times: number;
+  delay?: KeqRetryDelay;
+  on?: KeqRetryOn;
+}
+//#endregion
+//#region src/context/types/keq-context-options/keq-middleware-options.d.ts
+interface KeqMiddlewareOptions<OP extends KeqOperation> {
+  /**
+   * replace the default fetch api
+   * default use node-fetch@2 in node and window.fetch in browser
+   */
+  fetchAPI(value: typeof fetch): Keq<OP>;
+  /**
+   * how to resolve the response body
+   * @description 如何解析响应体
+   * @default 'intelligent'
+   */
+  resolveWith(value: KeqResolveWithMode): Keq<OP>;
+  retry(value: KeqRetryOptions): Keq<OP>;
+  flowControl(value: KeqFlowControlOptions): Keq<OP>;
+  timeout(value: KeqTimeoutOptions): Keq<OP>;
+}
+type ExpectNever<T> = ConditionalExcept<T, never>;
+type KeqMiddlewareOptionsParameter = ExpectNever<{ [key in keyof KeqMiddlewareOptions<any>]?: Parameters<KeqMiddlewareOptions<any>[key]>[0] }>;
+type KeqMiddlewareOptionsReturnType<OP extends KeqOperation> = ExpectNever<{ [key in keyof KeqMiddlewareOptions<OP>]: ReturnType<KeqMiddlewareOptions<OP>[key]> }>;
+//#endregion
+//#region src/context/types/keq-context-options/keq-context-options.d.ts
+interface KeqContextOptions extends KeqMiddlewareOptionsParameter {
+  [key: string]: any;
+}
+//#endregion
+//#region src/context/types/keq-global.d.ts
+interface KeqGlobalCore {
+  abortFlowControl?: Record<string, ((reason: any) => void) | undefined>;
+  serialFlowControl?: Record<string, queueAsPromised<{
+    next: KeqNext;
+  }, void>>;
+  mutexFlowControl?: Set<string>;
+}
+interface KeqGlobal {
+  core?: KeqGlobalCore;
+}
+//#endregion
+//#region src/context/types/keq-context-data.d.ts
+interface KeqContextData {
+  retry?: {
+    attempt: number;
+  };
+  [key: string]: any;
+}
+//#endregion
+//#region src/context/types/keq-context.d.ts
+interface KeqContext {
+  locationId?: string;
+  request: KeqRequestInit;
+  response?: Response;
+  res?: Response;
+  output?: any;
+  global: KeqGlobal;
+  emitter: KeqContextEmitter;
+  options: KeqContextOptions;
+  data: KeqContextData;
+}
+//#endregion
+//#region src/context/execution-context.d.ts
+declare const ContextOrchestratorProperty = "__KeyProtectedProperty(context.orchestrator)__";
+declare const ContextOrchestrationProperty = "__KeyProtectedProperty(context.orchestration)__";
+declare class KeqExecutionContext implements KeqContext {
+  private [ContextOrchestratorProperty];
+  private [ContextOrchestrationProperty];
+  constructor(orchestrator: KeqMiddlewareOrchestrator, executor: KeqMiddlewareExecutor);
+  get orchestration(): KeqOrchestratorContext;
+  /**
+   * The unique identifier of the request's location in the code
+   */
+  get locationId(): string | undefined;
+  get request(): KeqRequestInit;
+  get global(): KeqGlobal;
+  get emitter(): KeqContextEmitter;
+  get options(): KeqContextOptions;
+  set output(value: any);
+  get res(): Response | undefined;
+  set res(value: Response | undefined);
+  get response(): Response | undefined;
+  get data(): KeqContextData;
+}
+//#endregion
+//#region src/context/utils/create-proxy-response.d.ts
+declare function createProxyResponse(response: Response): Response;
+//#endregion
+//#region src/request/core.d.ts
+type KeqOptions = Partial<Omit<KeqRequestInit, 'url' | '__url__' | 'signal' | 'abort' | 'clone'>> & {
+  locationId?: string;
+  global?: KeqGlobal;
+  qs?: KeqQueryOptions;
+  middlewares?: KeqMiddleware[];
+};
+/**
+ * Core class that provides the foundational structure for managing middlewares, events, and request execution.
+ */
+declare class Core<OP extends KeqOperation = KeqDefaultOperation, RES_BODY extends KeqOperation['responseBody'] = OP['responseBody']> extends Promise<RES_BODY> {
+  /**
+   * Ensures `.then()`, `.catch()`, `.finally()` return plain Promise instances instead of Core/Keq instances.
+   */
+  static get [Symbol.species](): PromiseConstructor;
+  /**
+   * The unique identifier of the request's location in the code
+   */
+  __locationId__?: string;
+  /** Deferred resolve callback captured from the Promise executor. */
+  private __resolve__;
+  /** Deferred reject callback captured from the Promise executor. */
+  private __reject__;
+  /** Whether the request has been lazily triggered by `.then()`. */
+  private __triggered__;
+  /** Cached promise for idempotent `end()` calls. */
+  private __requestPromise__?;
+  protected requestInit: KeqRequestInit;
+  protected __listeners__: KeqListeners;
+  protected __global__: Record<string, any>;
+  protected __prepend_middlewares__: KeqMiddleware[];
+  protected __append_middlewares__: KeqMiddleware[];
+  protected __qs__: KeqQueryOptions | undefined;
+  protected get __middlewares__(): KeqMiddleware[];
+  protected __options__: KeqContextOptions;
+  constructor(url: URL, options: KeqOptions);
+  use(...middlewares: KeqMiddleware[]): this;
+  on<K extends keyof KeqEvents>(event: K, listener: (data: KeqEvents[K]) => void): this;
+  option<K extends keyof KeqMiddlewareOptionsReturnType<OP>>(key: K, value?: KeqMiddlewareOptionsParameter[K]): KeqMiddlewareOptionsReturnType<OP>[K];
+  option(key: string, value?: any): this;
+  options(opts: KeqContextOptions): this;
+  derive(): this;
+  private buildSharedContext;
+  private run;
+  private __execute__;
+  fire(): void;
+  then<TResult1 = RES_BODY, TResult2 = never>(onfulfilled?: ((value: RES_BODY) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+}
+//#endregion
+//#region src/router/types/keq-route.d.ts
+interface KeqRoute {
+  (ctx: KeqExecutionContext): Promisable<boolean>;
+  __keqRouteName__?: string;
+}
+//#endregion
+//#region src/router/utils/compose-route.d.ts
+declare function composeRoute(routes: KeqRoute[]): KeqRoute;
+//#endregion
+//#region src/router/keq-router.d.ts
+declare class KeqRouter {
+  private readonly middlewares;
+  constructor(middlewares?: KeqMiddleware[]);
+  private static buildMiddleware;
+  route(route: KeqRoute, middleware: KeqMiddleware[]): this;
+  route(route: KeqRoute, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): this;
+  host(host: string, middleware: KeqMiddleware[]): this;
+  host(host: string, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): this;
+  method(method: string, middleware: KeqMiddleware[]): this;
+  method(method: string, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): this;
+  pathname(pathname: string, middleware: KeqMiddleware[]): this;
+  pathname(pathname: string, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): this;
+  location(middleware: KeqMiddleware[]): this;
+  location(middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): this;
+  static route(route: KeqRoute, middleware: KeqMiddleware[]): KeqMiddleware;
+  static route(route: KeqRoute, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): KeqMiddleware;
+  static host(host: string, middleware: KeqMiddleware[]): KeqMiddleware;
+  static host(host: string, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): KeqMiddleware;
+  static method(method: string, middleware: KeqMiddleware[]): KeqMiddleware;
+  static method(method: string, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): KeqMiddleware;
+  static pathname(pathname: string, middleware: KeqMiddleware[], ...additionalMiddlewares: KeqMiddleware[]): KeqMiddleware;
+  static pathname(pathname: string, middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): KeqMiddleware;
+  static location(middleware: KeqMiddleware[]): KeqMiddleware;
+  static location(middleware: KeqMiddleware, ...additionalMiddlewares: KeqMiddleware[]): KeqMiddleware;
+}
+//#endregion
+//#region src/request/request.d.ts
+interface KeqRequestOptions {
+  middlewares?: KeqMiddleware[];
+  terminalMiddlewares?: KeqMiddleware[];
+  baseOrigin?: string;
+  qs?: KeqQueryOptions;
+}
+interface KeqRequestForkOptions {
+  baseOrigin?: string;
+  qs?: KeqQueryOptions;
+}
+type KeqRequestFetchOptions<M extends KeqRequestMethod = KeqRequestMethod> = Partial<Omit<KeqRequestInit, 'url' | '__url__' | 'signal' | 'abort' | 'clone' | 'toFetchArguments' | 'method'>> & {
+  method: M;
+};
+/**
+ * Keq instance factory class,
+ * and shares global data and middlewares across requests
+ */
+declare class KeqRequest<SCHEMA extends KeqApiSchema = KeqApiSchema> {
+  baseOrigin: string;
+  qs?: KeqQueryOptions;
+  /**
+   * share data between requests, used to implement flowControl
+   * @description 跨请求共享数据，用于实现 flowControl的功能
+   */
+  readonly global: KeqGlobal;
+  readonly middlewares: KeqMiddleware[];
+  private readonly __terminalMiddlewares__;
+  private __parent__?;
+  constructor(options?: KeqRequestOptions);
+  private __formatUrl__;
+  private resolveMiddlewares;
+  private __fetch__;
+  fetch<P extends keyof SCHEMA, M extends KeqRequestMethod>(url: P, init: KeqRequestFetchOptions<M>): Keq<Exclude<SCHEMA[P][M], undefined>>;
+  fetch<T = unknown>(url: string | URL, init: KeqRequestFetchOptions): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  get<P extends keyof ExtractMethodOperations<SCHEMA, 'get'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'get'>[P], ExtractMethodOperations<SCHEMA, 'get'>[P]>;
+  get<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  put<P extends keyof ExtractMethodOperations<SCHEMA, 'put'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'put'>[P], ExtractMethodOperations<SCHEMA, 'put'>[P]>;
+  put<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  delete<P extends keyof ExtractMethodOperations<SCHEMA, 'delete'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'delete'>[P], ExtractMethodOperations<SCHEMA, 'delete'>[P]>;
+  delete<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  del<P extends keyof ExtractMethodOperations<SCHEMA, 'delete'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'delete'>[P], ExtractMethodOperations<SCHEMA, 'delete'>[P]>;
+  del<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  post<P extends keyof ExtractMethodOperations<SCHEMA, 'post'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'post'>[P], ExtractMethodOperations<SCHEMA, 'post'>[P]>;
+  post<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  head<P extends keyof ExtractMethodOperations<SCHEMA, 'head'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'head'>[P], ExtractMethodOperations<SCHEMA, 'head'>[P]>;
+  head<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  patch<P extends keyof ExtractMethodOperations<SCHEMA, 'patch'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'patch'>[P], ExtractMethodOperations<SCHEMA, 'patch'>[P]>;
+  patch<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  options<P extends keyof ExtractMethodOperations<SCHEMA, 'options'>>(url: P): Keq<ExtractMethodOperations<SCHEMA, 'options'>[P], ExtractMethodOperations<SCHEMA, 'options'>[P]>;
+  options<T>(url: string | URL): Keq<KeqDefaultOperation<{
+    responseBody: T;
+  }>>;
+  use(firstMiddleware: KeqMiddleware, ...middleware: KeqMiddleware[]): this;
+  useRouter(): KeqRouter;
+  fork(options?: KeqRequestForkOptions): KeqRequest;
+  inherit(parent: KeqRequest): this;
+  adopt(child: KeqRequest): this;
+  /** @deprecated Use `middlewares` instead */
+  get preMiddlewares(): KeqMiddleware[];
+  on<K extends keyof KeqEvents>(event: K, listener: (data: KeqEvents[K]) => void): this;
+}
+declare const request: KeqRequest<KeqApiSchema>;
+//#endregion
+//#region src/request/create-request.d.ts
+/**
+ * @deprecated use new KeqRequest<SCHEMA>(options) instead
+ */
+declare function createRequest<SCHEMA extends KeqApiSchema>(options?: KeqRequestOptions): KeqRequest<SCHEMA>;
+//#endregion
+//#region src/exception/exception.d.ts
+declare class Exception extends CustomError {
+  constructor(message?: string);
+}
+//#endregion
+//#region src/exception/type.exception.d.ts
+declare class TypeException extends Exception {
+  constructor(msg?: string);
+}
+//#endregion
+//#region src/exception/abort.exception.d.ts
+declare class AbortException extends DOMException {
+  constructor(msg: string);
+}
+//#endregion
+//#region src/exception/timeout.exception.d.ts
+declare class TimeoutException extends AbortException {
+  constructor(msg: string);
+}
+//#endregion
+//#region src/exception/http-exceptions/request.exception.d.ts
+interface RequestExceptionOptions {
+  fatal?: boolean;
+  response?: Response;
+}
+declare class RequestException extends Exception {
+  statusCode: number | string;
+  retry: boolean;
+  response?: Response;
+  constructor(statusCode: number | string, message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/bad-request.exception.d.ts
+declare class BadRequestException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/unauthorized.exception.d.ts
+declare class UnauthorizedException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/forbidden.exception.d.ts
+declare class ForbiddenException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/not-founded.exception.d.ts
+declare class NotFoundedException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/method-not-allowed.exception.d.ts
+declare class MethodNotAllowedException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/not-acceptable.exception.d.ts
+declare class NotAcceptableException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/proxy-authentication-required.exception.d.ts
+declare class ProxyAuthenticationRequiredException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/request-timeout.exception.d.ts
+declare class RequestTimeoutException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/conflict.exception.d.ts
+declare class ConflictException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/precondition-failed.exception.d.ts
+declare class PreconditionFailedException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/content-too-large.exception.d.ts
+declare class ContentTooLargeException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/uri-too-long.exception.d.ts
+declare class UriTooLongException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/unsupported-media-type.exception.d.ts
+declare class UnsupportedMediaTypeException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/im-a-teapot.exception.d.ts
+declare class ImATeapotException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/too-many-requests.exception.d.ts
+declare class TooManyRequestsException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/internal-server-error.exception.d.ts
+declare class InternalServerErrorException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/not-implemented.exception.d.ts
+declare class NotImplementedException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/bad-gateway.exception.d.ts
+declare class BadGatewayException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/service-unavailable.exception.d.ts
+declare class ServiceUnavailableException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+//#region src/exception/http-exceptions/gateway-timeout.exception.d.ts
+declare class GatewayTimeoutException extends RequestException {
+  constructor(message?: string, options?: RequestExceptionOptions);
+}
+//#endregion
+export { AbortException, BadGatewayException, BadRequestException, ConflictException, ContentTooLargeException, Exception, ForbiddenException, GatewayTimeoutException, ImATeapotException, InternalServerErrorException, Keq, type KeqApiSchema, type KeqBodyInit, type KeqContext, type KeqContextData, type KeqContextEmitter, type KeqContextOptions, type KeqDefaultOperation, type KeqEvents, KeqExecutionContext, type KeqGlobal, type KeqGlobalCore, type KeqMiddleware, KeqMiddlewareExecutor, type KeqMiddlewareOptions, KeqMiddlewareOrchestrator, type KeqNext, type KeqOperation, type KeqOptions, type KeqPathParameterInit, type KeqQueryInit, type KeqQueryOptions, KeqRequest, type KeqRequestForkOptions, type KeqRetryDelay, type KeqRetryOn, type KeqRoute, KeqSharedContext, type KeqSharedContextOptions, MethodNotAllowedException, NotAcceptableException, NotFoundedException, NotImplementedException, PreconditionFailedException, ProxyAuthenticationRequiredException, RequestException, type RequestExceptionOptions, RequestTimeoutException, type ServerSentEvent, ServiceUnavailableException, TimeoutException, TooManyRequestsException, TypeException, UnauthorizedException, UnsupportedMediaTypeException, UriTooLongException, composeMiddleware, composeRoute, createProxyResponse, createRequest, request };
 //# sourceMappingURL=index.d.ts.map