egg 4.1.0-beta.19 → 4.1.0-beta.20

package/dist/base_hook_class-R8A8gm1s.d.ts

@@ -0,0 +1,1109 @@
+import { EggApplicationLoader } from "./EggApplicationLoader-PnIvd5oV.js";
+import { AppWorkerLoader } from "./AppWorkerLoader-CT875rYM.js";
+import { AgentWorkerLoader } from "./AgentWorkerLoader-DG_hAClt.js";
+import { Response as Response$1 } from "./response-DlNYDj00.js";
+import { IMessenger } from "./IMessenger-C9g6ypSI.js";
+import { BaseContextClass, Context, EggAppConfig, EggAppInfo, EggCore, EggCoreOptions, FileLoaderOptions, ILifecycleBoot, ILifecycleBoot as ILifecycleBoot$1, MiddlewareFunc, Next, Request, Router, Router as Router$1, Singleton, SingletonCreateMethod, SingletonOptions } from "@eggjs/core";
+import http, { IncomingMessage, ServerResponse } from "node:http";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as egg_logger0 from "egg-logger";
+import { EggContextLogger, EggLogger, EggLogger as EggLogger$1, EggLoggerOptions, EggLoggers, EggLoggersOptions, LoggerLevel } from "egg-logger";
+import { Cookies } from "@eggjs/cookies";
+import * as urllib0 from "urllib";
+import { ClientOptions, ClientOptions as HttpClientOptions, HttpClient, HttpClientResponse, RequestOptions, RequestURL, RequestURL as HttpClientRequestURL } from "urllib";
+import { Socket } from "node:net";
+import { PartialDeep } from "type-fest";
+import * as node_modules_urllib_dist_esm_Response_js0 from "node_modules/urllib/dist/esm/Response.js";
+
+//#region src/lib/agent.d.ts
+declare const EGG_LOADER$1: unique symbol;
+/**
+ * Singleton instance in Agent Worker, extend {@link EggApplicationCore}
+ * @augments EggApplicationCore
+ */
+declare class Agent extends EggApplicationCore {
+  #private;
+  /**
+   * @class
+   * @param {Object} options - see {@link EggApplicationCore}
+   */
+  constructor(options?: Omit<EggApplicationCoreOptions, 'type'>);
+  get [EGG_LOADER$1](): typeof AgentWorkerLoader;
+  _wrapMessenger(): void;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/app/extend/helper.d.ts
+/**
+ * The Helper class which can be used as utility function.
+ * We support developers to extend Helper through ${baseDir}/app/extend/helper.js ,
+ * then you can use all method on `ctx.helper` that is a instance of Helper.
+ */
+declare class Helper extends BaseContextClass$1 {
+  /**
+   * Generate URL path(without host) for route. Takes the route name and a map of named params.
+   * @function Helper#pathFor
+   * @param {String} name - Router Name
+   * @param {Object} params - Other params
+   *
+   * @example
+   * ```js
+   * app.get('home', '/index.htm', 'home.index');
+   * ctx.helper.pathFor('home', { by: 'recent', limit: 20 })
+   * => /index.htm?by=recent&limit=20
+   * ```
+   * @return {String} url path(without host)
+   */
+  pathFor(name: string, params: Record<string, any>): string;
+  /**
+   * Generate full URL(with host) for route. Takes the route name and a map of named params.
+   * @function Helper#urlFor
+   * @param {String} name - Router name
+   * @param {Object} params - Other params
+   * @example
+   * ```js
+   * app.get('home', '/index.htm', 'home.index');
+   * ctx.helper.urlFor('home', { by: 'recent', limit: 20 })
+   * => http://127.0.0.1:7001/index.htm?by=recent&limit=20
+   * ```
+   * @return {String} full url(with host)
+   */
+  urlFor(name: string, params: Record<string, any>): string;
+}
+//#endregion
+//#region src/lib/application.d.ts
+declare const EGG_LOADER: unique symbol;
+/**
+ * Singleton instance in App Worker, extend {@link EggApplicationCore}
+ * @augments EggApplicationCore
+ */
+declare class Application extends EggApplicationCore {
+  #private;
+  server?: http.Server;
+  /**
+   * reference to {@link Helper}
+   * @member {Helper} Application#Helper
+   */
+  Helper: typeof Helper;
+  /**
+   * @class
+   * @param {Object} options - see {@link EggApplicationCore}
+   */
+  constructor(options?: Omit<EggApplicationCoreOptions, 'type'>);
+  protected load(): Promise<void>;
+  get [EGG_LOADER](): typeof AppWorkerLoader;
+  onClientError(err: any, socket: Socket): void;
+  onServer(server: http.Server): void;
+  /**
+   * global locals for view
+   * @member {Object} Application#locals
+   * @see Context#locals
+   */
+  get locals(): Record<string, any>;
+  set locals(val: Record<string, any>);
+  /**
+   * save routers to `run/router.json`
+   * @private
+   */
+  dumpConfig(): void;
+  /**
+   * Run async function in the background
+   * @see Context#runInBackground
+   * @param {Function} scope - the first args is an anonymous ctx
+   */
+  runInBackground(scope: (ctx: Context$1) => Promise<void>, req?: unknown): void;
+  /**
+   * secret key for Application
+   * @member {String} Application#keys
+   */
+  get keys(): string[];
+  /**
+   * @deprecated keep compatible with egg 3.x
+   */
+  toAsyncFunction(fn: (...args: any[]) => any): (...args: any[]) => any;
+}
+//#endregion
+//#region src/lib/core/httpclient.d.ts
+interface HttpClientRequestOptions extends RequestOptions {
+  ctx?: any;
+  tracer?: any;
+}
+declare class HttpClient$1 extends HttpClient {
+  #private;
+  constructor(app: EggApplicationCore, options?: ClientOptions);
+  request<T = any>(url: RequestURL, options?: HttpClientRequestOptions): Promise<urllib0.HttpClientResponse<T>>;
+  curl<T = any>(url: RequestURL, options?: HttpClientRequestOptions): Promise<urllib0.HttpClientResponse<T>>;
+}
+//#endregion
+//#region src/app/extend/request.d.ts
+declare class Request$1 extends Request {
+  app: Application;
+  ctx: Context$1;
+  response: Response$1;
+  /**
+   * Request body, parsed from koa-bodyparser or @eggjs/multipart
+   */
+  body: any;
+  /**
+   * Parse the "Host" header field host
+   * and support X-Forwarded-Host when a
+   * proxy is enabled.
+   * @member {String} Request#host
+   * @example
+   * ip + port
+   * ```js
+   * this.request.host
+   * => '127.0.0.1:7001'
+   * ```
+   * or domain
+   * ```js
+   * this.request.host
+   * => 'demo.eggjs.org'
+   * ```
+   */
+  get host(): string;
+  /**
+   * @member {String} Request#protocol
+   * @example
+   * ```js
+   * this.request.protocol
+   * => 'https'
+   * ```
+   */
+  get protocol(): string;
+  /**
+   * Get all pass through ip addresses from the request.
+   * Enable only on `app.config.proxy = true`
+   *
+   * @member {Array} Request#ips
+   * @example
+   * ```js
+   * this.request.ips
+   * => ['100.23.1.2', '201.10.10.2']
+   * ```
+   */
+  get ips(): string[];
+  /**
+   * Get the request remote IPv4 address
+   * @member {String} Request#ip
+   * @return {String} IPv4 address
+   * @example
+   * ```js
+   * this.request.ip
+   * => '127.0.0.1'
+   * => '111.10.2.1'
+   * ```
+   */
+  get ip(): string;
+  /**
+   * Set the request remote IPv4 address
+   * @member {String} Request#ip
+   * @param {String} ip - IPv4 address
+   * @example
+   * ```js
+   * this.request.ip
+   * => '127.0.0.1'
+   * => '111.10.2.1'
+   * ```
+   */
+  set ip(ip: string);
+  /**
+   * detect if response should be json
+   * 1. url path ends with `.json`
+   * 2. response type is set to json
+   * 3. detect by request accept header
+   *
+   * @member {Boolean} Request#acceptJSON
+   * @since 1.0.0
+   */
+  get acceptJSON(): boolean;
+  _customQuery(cacheName: symbol, filter: (value: string | string[]) => string | string[]): Record<string, string | string[]>;
+  /**
+   * get params pass by querystring, all values are of string type.
+   * @member {Object} Request#query
+   * @example
+   * ```js
+   * GET http://127.0.0.1:7001?name=Foo&age=20&age=21
+   * this.query
+   * => { 'name': 'Foo', 'age': '20' }
+   *
+   * GET http://127.0.0.1:7001?a=b&a=c&o[foo]=bar&b[]=1&b[]=2&e=val
+   * this.query
+   * =>
+   * {
+   *   "a": "b",
+   *   "o[foo]": "bar",
+   *   "b[]": "1",
+   *   "e": "val"
+   * }
+   * ```
+   */
+  get query(): Record<string, string>;
+  /**
+   * get params pass by querystring, all value are Array type. {@link Request#query}
+   * @member {Array} Request#queries
+   * @example
+   * ```js
+   * GET http://127.0.0.1:7001?a=b&a=c&o[foo]=bar&b[]=1&b[]=2&e=val
+   * this.queries
+   * =>
+   * {
+   *   "a": ["b", "c"],
+   *   "o[foo]": ["bar"],
+   *   "b[]": ["1", "2"],
+   *   "e": ["val"]
+   * }
+   * ```
+   */
+  get queries(): Record<string, string[]>;
+  /**
+   * Set query-string as an object.
+   *
+   * @function Request#query
+   * @param {Object} obj set querystring and query object for request.
+   */
+  set query(obj: Record<string, string>);
+}
+//#endregion
+//#region src/app/extend/context.d.ts
+interface Cookies$1 extends Cookies {
+  request: any;
+  response: any;
+}
+declare class Context$1 extends Context {
+  app: Application;
+  request: Request$1;
+  response: Response$1;
+  service: BaseContextClass$1;
+  proxy: any;
+  /**
+   * Request start time
+   * @member {Number} Context#starttime
+   */
+  starttime: number;
+  /**
+   * Request start timer using `performance.now()`
+   * @member {Number} Context#performanceStarttime
+   */
+  performanceStarttime: number;
+  /**
+   * Get the current visitor's cookies.
+   */
+  get cookies(): Cookies$1;
+  /**
+   * Get a wrapper httpclient instance contain ctx in the hold request process
+   *
+   * @return {HttpClient} the wrapper httpclient instance
+   */
+  get httpclient(): HttpClient$1;
+  /**
+   * Alias to {@link Context#httpclient}
+   */
+  get httpClient(): HttpClient$1;
+  /**
+   * Shortcut for httpclient.curl
+   *
+   * @function Context#curl
+   * @param {String|Object} url - request url address.
+   * @param {Object} [options] - options for request.
+   * @return {Object} see {@link ContextHttpClient#curl}
+   */
+  curl(url: HttpClientRequestURL, options?: HttpClientRequestOptions): ReturnType<HttpClient$1['request']>;
+  /**
+   * Alias to {@link Application#router}
+   *
+   * @member {Router} Context#router
+   * @since 1.0.0
+   * @example
+   * ```js
+   * this.router.pathFor('post', { id: 12 });
+   * ```
+   */
+  get router(): Router;
+  /**
+   * Set router to Context, only use on EggRouter
+   * @param {Router} val router instance
+   */
+  set router(val: Router);
+  /**
+   * Get helper instance from {@link Application#Helper}
+   *
+   * @member {Helper} Context#helper
+   * @since 1.0.0
+   */
+  get helper(): Helper;
+  /**
+   * Wrap app.loggers with context information,
+   * if a custom logger is defined by naming aLogger, then you can `ctx.getLogger('aLogger')`
+   *
+   * @param {String} name - logger name
+   */
+  getLogger(name: string): EggLogger;
+  /**
+   * Logger for Application
+   *
+   * @member {Logger} Context#logger
+   * @since 1.0.0
+   * @example
+   * ```js
+   * this.logger.info('some request data: %j', this.request.body);
+   * this.logger.warn('WARNING!!!!');
+   * ```
+   */
+  get logger(): EggLogger;
+  /**
+   * Logger for frameworks and plugins
+   *
+   * @member {Logger} Context#coreLogger
+   * @since 1.0.0
+   */
+  get coreLogger(): EggLogger;
+  /**
+   * locals is an object for view, you can use `app.locals` and `ctx.locals` to set variables,
+   * which will be used as data when view is rendering.
+   * The difference between `app.locals` and `ctx.locals` is the context level, `app.locals` is global level, and `ctx.locals` is request level. when you get `ctx.locals`, it will merge `app.locals`.
+   *
+   * when you set locals, only object is available
+   *
+   * ```js
+   * this.locals = {
+   *   a: 1
+   * };
+   * this.locals = {
+   *   b: 1
+   * };
+   * this.locals.c = 1;
+   * console.log(this.locals);
+   * {
+   *   a: 1,
+   *   b: 1,
+   *   c: 1,
+   * };
+   * ```
+   *
+   * `ctx.locals` has cache, it only merges `app.locals` once in one request.
+   *
+   * @member {Object} Context#locals
+   */
+  get locals(): Record<string, any>;
+  set locals(val: Record<string, any>);
+  /**
+   * alias to {@link Context#locals}, compatible with koa that use this variable
+   * @member {Object} state
+   * @see Context#locals
+   */
+  get state(): Record<string, any>;
+  set state(val: Record<string, any>);
+  /**
+   * Run async function in the background
+   * @param {Function} scope - the first args is ctx
+   * ```js
+   * this.body = 'hi';
+   *
+   * this.runInBackground(async ctx => {
+   *   await ctx.mysql.query(sql);
+   *   await ctx.curl(url);
+   * });
+   * ```
+   */
+  runInBackground(scope: (ctx: Context$1) => Promise<void>, taskName?: string): void;
+  _runInBackground(scope: (ctx: Context$1) => Promise<void>, taskName: string): Promise<void>;
+  /**
+   * @member {Boolean} Context#acceptJSON
+   * @see Request#acceptJSON
+   * @since 1.0.0
+   */
+  get acceptJSON(): boolean;
+  get query(): Record<string, string>;
+  /**
+   * @member {Array} Context#queries
+   * @see Request#queries
+   * @since 1.0.0
+   */
+  get queries(): Record<string, string[]>;
+  /**
+   * @member {string} Context#ip
+   * @see Request#ip
+   * @since 1.0.0
+   */
+  get ip(): string;
+  set ip(val: string);
+  /**
+   * @member {Number} Context#realStatus
+   * @see Response#realStatus
+   * @since 1.0.0
+   */
+  get realStatus(): number;
+  set realStatus(val: number);
+}
+//#endregion
+//#region src/app/middleware/meta.d.ts
+interface MetaMiddlewareOptions {
+  enable: boolean;
+  logging: boolean;
+}
+declare const _default$2: (options: MetaMiddlewareOptions) => (ctx: Context$1, next: Next) => Promise<void>;
+//#endregion
+//#region src/app/middleware/notfound.d.ts
+interface NotFoundMiddlewareOptions {
+  enable: boolean;
+  pageUrl: string;
+}
+declare const _default$1: (options: NotFoundMiddlewareOptions) => (ctx: Context$1, next: Next) => Promise<void>;
+//#endregion
+//#region src/app/middleware/site_file.d.ts
+type SiteFileContentFun = (ctx: Context$1) => Promise<Buffer | string>;
+interface SiteFileMiddlewareOptions {
+  enable: boolean;
+  cacheControl: string;
+  [key: string]: string | Buffer | boolean | SiteFileContentFun | URL;
+}
+declare const _default: (options: SiteFileMiddlewareOptions) => (ctx: Context$1, next: Next) => Promise<void>;
+//#endregion
+//#region src/lib/types.d.ts
+type IgnoreItem = string | RegExp | ((ctx: Context$1) => boolean);
+type IgnoreOrMatch = IgnoreItem | IgnoreItem[];
+interface ClientErrorResponse {
+  body: string | Buffer;
+  status: number;
+  headers: {
+    [key: string]: string;
+  };
+}
+/** egg env type */
+type EggEnvType = 'local' | 'unittest' | 'prod' | string;
+/** logger config of egg */
+interface EggLoggerConfig extends Omit<EggLoggersOptions, 'type'> {
+  /** custom config of coreLogger */
+  coreLogger?: Partial<EggLoggerOptions>;
+  /** allow debug log at prod, defaults to `false` */
+  allowDebugAtProd?: boolean;
+  /** disable logger console after app ready. defaults to `false` on local and unittest env, others is `true`. */
+  disableConsoleAfterReady?: boolean;
+  /** [deprecated] Defaults to `true`. */
+  enablePerformanceTimer?: boolean;
+  /** using the app logger instead of EggContextLogger, defaults to `false` */
+  enableFastContextLogger?: boolean;
+}
+/** Custom Loader Configuration */
+interface CustomLoaderConfig extends Omit<FileLoaderOptions, 'inject' | 'target'> {
+  /**
+   * an object you wanner load to, value can only be 'ctx' or 'app'. default to app
+   */
+  inject?: 'ctx' | 'app';
+  /**
+   * whether need to load files in plugins or framework, default to false
+   */
+  loadunit?: boolean;
+}
+interface HttpClientConfig {
+  /** Request timeout */
+  timeout?: number;
+  /** Default request args for httpclient */
+  request?: RequestOptions;
+  /**
+   * @deprecated keep compatible with egg 3.x, no more used
+   */
+  useHttpClientNext?: boolean;
+  /**
+   * Allow http2
+   */
+  allowH2?: boolean;
+}
+/**
+ * Powerful Partial, Support adding ? modifier to a mapped property in deep level
+ * @example
+ * import { PowerPartial, EggAppConfig } from 'egg';
+ *
+ * // { view: { defaultEngines: string } } => { view?: { defaultEngines?: string } }
+ * type EggConfig = PowerPartial<EggAppConfig>
+ *
+ * @deprecated use `PartialDeep` instead
+ */
+type PowerPartial<T> = PartialDeep<T>;
+/**
+ * Partial EggAppConfig
+ */
+type PartialEggConfig = PartialDeep<EggAppConfig$1>;
+/**
+ * Configuration factory function return type
+ */
+type EggConfigFactory = (appInfo: EggAppInfo) => PartialEggConfig;
+/**
+ * Define configuration with type safety
+ * @example
+ * ```ts
+ * import { defineConfig } from 'egg';
+ *
+ * export default defineConfig({
+ *   keys: 'my-keys',
+ *   middleware: []
+ * });
+ * ```
+ */
+declare function defineConfig(config: PartialEggConfig): PartialEggConfig;
+/**
+ * Define configuration factory function with type safety
+ * @example
+ * ```ts
+ * export default defineConfigFactory((appInfo): PartialEggConfig => ({
+ *   keys: appInfo.name + '_keys',
+ *   middleware: []
+ * }));
+ * ```
+ */
+declare function defineConfigFactory(configFactory: EggConfigFactory): EggConfigFactory;
+interface EggAppConfig$1 extends EggAppConfig {
+  workerStartTimeout: number;
+  baseDir: string;
+  middleware: string[];
+  coreMiddleware: string[];
+  /**
+   * The option of `bodyParser` middleware
+   *
+   * @member Config#bodyParser
+   * @property {Boolean} enable - enable bodyParser or not, default to true
+   * @property {String | RegExp | Function | Array} ignore - won't parse request body when url path hit ignore pattern, can not set `ignore` when `match` presented
+   * @property {String | RegExp | Function | Array} match - will parse request body only when url path hit match pattern
+   * @property {String} encoding - body encoding config, default utf8
+   * @property {String} formLimit - form body size limit, default 1mb
+   * @property {String} jsonLimit - json body size limit, default 1mb
+   * @property {String} textLimit - json body size limit, default 1mb
+   * @property {Boolean} strict - json body strict mode, if set strict value true, then only receive object and array json body
+   * @property {Number} queryString.arrayLimit - from item array length limit, default 100
+   * @property {Number} queryString.depth - json value deep length, default 5
+   * @property {Number} queryString.parameterLimit - parameter number limit, default 1000
+   * @property {String[]} enableTypes - parser will only parse when request type hits enableTypes, default is ['json', 'form']
+   * @property {Object} extendTypes - support extend types
+   * @property {String} onProtoPoisoning - Defines what action must take when parsing a JSON object with `__proto__`. Possible values are `'error'`, `'remove'` and `'ignore'`. Default is `'error'`, it will return `400` response when `Prototype-Poisoning` happen.
+   */
+  bodyParser: {
+    enable: boolean;
+    encoding: string;
+    formLimit: string;
+    jsonLimit: string;
+    textLimit: string;
+    strict: boolean;
+    queryString: {
+      arrayLimit: number;
+      depth: number;
+      parameterLimit: number;
+    };
+    ignore?: IgnoreOrMatch;
+    match?: IgnoreOrMatch;
+    enableTypes?: string[];
+    extendTypes?: {
+      json: string[];
+      form: string[];
+      text: string[];
+    };
+    /** Default is `'error'`, it will return `400` response when `Prototype-Poisoning` happen. */
+    onProtoPoisoning: 'error' | 'remove' | 'ignore';
+    onerror(err: any, ctx: Context$1): void;
+  };
+  /**
+   * logger options
+   * @member Config#logger
+   * @property {String} dir - directory of log files
+   * @property {String} encoding - log file encoding, defaults to utf8
+   * @property {String} level - default log level, could be: DEBUG, INFO, WARN, ERROR or NONE, defaults to INFO in production
+   * @property {String} consoleLevel - log level of stdout, defaults to `INFO` in local serverEnv, defaults to `WARN` in unittest, others is `NONE`
+   * @property {Boolean} disableConsoleAfterReady - disable logger console after app ready. defaults to `false` on local and unittest env, others is `true`.
+   * @property {Boolean} outputJSON - log as JSON or not, defaults to `false`
+   * @property {Boolean} buffer - if enabled, flush logs to disk at a certain frequency to improve performance, defaults to true
+   * @property {String} errorLogName - file name of errorLogger
+   * @property {String} coreLogName - file name of coreLogger
+   * @property {String} agentLogName - file name of agent worker log
+   * @property {Object} coreLogger - custom config of coreLogger
+   * @property {Boolean} allowDebugAtProd - allow debug log at prod, defaults to false
+   * @property {Boolean} enableFastContextLogger - using the app logger instead of EggContextLogger, defaults to false
+   */
+  logger: EggLoggerConfig;
+  /** custom logger of egg */
+  customLogger: {
+    [key: string]: EggLoggerOptions;
+  };
+  /** Configuration of httpclient in egg. */
+  httpclient: HttpClientConfig;
+  /**
+   * customLoader config
+   */
+  /**
+   * It will ignore special keys when dumpConfig
+   */
+  dump: {
+    ignore: Set<string | RegExp>;
+    timing: {
+      slowBootActionMinDuration: number;
+    };
+  };
+  /**
+   * The environment of egg
+   */
+  env: EggEnvType;
+  /**
+   * The current HOME directory
+   */
+  HOME: string;
+  hostHeaders: string;
+  /**
+   * Detect request' ip from specified headers, not case-sensitive. Only worked when config.proxy set to true.
+   */
+  ipHeaders: string;
+  protocolHeaders: string;
+  maxProxyCount: number;
+  maxIpsCount: number;
+  proxy: boolean;
+  cookies: {
+    sameSite?: string;
+    httpOnly?: boolean;
+  };
+  /**
+   * The key that signing cookies. It can contain multiple keys separated by `.`
+   * @requires Cookie secret key to sign and encrypt, see https://eggjs.org/core/cookie-and-session#cookie-secret-key
+   */
+  keys: string;
+  /**
+   * The name of the application
+   */
+  name: string;
+  /**
+   * package.json
+   */
+  pkg: Record<string, any>;
+  rundir: string;
+  siteFile: SiteFileMiddlewareOptions;
+  meta: MetaMiddlewareOptions;
+  notfound: NotFoundMiddlewareOptions;
+  overrideMethod: {
+    enable: boolean;
+    allowedMethods: string[];
+  };
+  onClientError?(err: Error, socket: Socket, app: Application): ClientErrorResponse | Promise<ClientErrorResponse>;
+  /**
+   * server timeout in milliseconds, default to 0 (no timeout).
+   *
+   * for special request, just use `ctx.req.setTimeout(ms)`
+   *
+   * @see https://nodejs.org/api/http.html#http_server_timeout
+   */
+  serverTimeout: number | null;
+  cluster: {
+    listen: {
+      path: string;
+      port: number;
+      hostname: string;
+    };
+  };
+  clusterClient: {
+    maxWaitTime: number;
+    responseTimeout: number;
+  };
+  [prop: string]: any;
+}
+type RequestObjectBody = Record<string, any>;
+/**
+ * plugin config item interface
+ */
+interface IEggPluginItem {
+  env?: EggEnvType[];
+  path?: string;
+  package?: string;
+  enable?: boolean;
+}
+type EggPluginItem = IEggPluginItem | boolean;
+/**
+ * build-in plugin list
+ */
+interface EggPlugin {
+  [key: string]: EggPluginItem | undefined;
+  onerror?: EggPluginItem;
+  session?: EggPluginItem;
+  i18n?: EggPluginItem;
+  watcher?: EggPluginItem;
+  multipart?: EggPluginItem;
+  security?: EggPluginItem;
+  development?: EggPluginItem;
+  logrotator?: EggPluginItem;
+  schedule?: EggPluginItem;
+  static?: EggPluginItem;
+  jsonp?: EggPluginItem;
+  view?: EggPluginItem;
+}
+//#endregion
+//#region src/lib/core/messenger/index.d.ts
+/**
+ * @class Messenger
+ */
+declare function create(egg: EggApplicationCore): IMessenger;
+//#endregion
+//#region src/lib/core/context_httpclient.d.ts
+declare class ContextHttpClient {
+  ctx: Context$1;
+  app: Application;
+  constructor(ctx: Context$1);
+  /**
+   * http request helper base on {@link HttpClient}, it will auto save httpclient log.
+   * Keep the same api with {@link Application#curl}.
+   *
+   * @param {String|Object} url - request url address.
+   * @param {Object} [options] - options for request.
+   */
+  curl<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions): Promise<node_modules_urllib_dist_esm_Response_js0.HttpClientResponse<T>>;
+  request<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions): Promise<node_modules_urllib_dist_esm_Response_js0.HttpClientResponse<T>>;
+}
+//#endregion
+//#region src/lib/egg.d.ts
+declare const EGG_PATH: unique symbol;
+interface EggApplicationCoreOptions extends Omit<EggCoreOptions, 'baseDir'> {
+  mode?: 'cluster' | 'single' | 'all-in-one-process';
+  clusterPort?: number;
+  baseDir?: string;
+}
+type EggContext = Context$1;
+type MiddlewareFunc$1<T extends Context$1 = Context$1> = MiddlewareFunc<T>;
+/**
+ * Based on koa's Application
+ * @see https://github.com/eggjs/egg-core
+ * @see https://github.com/eggjs/koa/blob/master/src/application.ts
+ * @augments EggCore
+ */
+declare class EggApplicationCore extends EggCore {
+  #private;
+  ctxStorage: AsyncLocalStorage<Context$1>;
+  /**
+   * Get the current request context from AsyncLocalStorage.
+   * This provides access to the context object for the current request lifecycle.
+   * @returns {Context | undefined} The current request context, or undefined if not in a request scope.
+   */
+  get currentContext(): Context$1 | undefined;
+  ContextCookies: typeof Cookies;
+  ContextLogger: typeof EggContextLogger;
+  ContextHttpClient: typeof ContextHttpClient;
+  HttpClient: typeof HttpClient$1;
+  HttpClientNext: typeof HttpClient$1;
+  /**
+   * Retrieve base context class
+   * @member {BaseContextClass} BaseContextClass
+   * @since 1.0.0
+   */
+  BaseContextClass: typeof BaseContextClass$1;
+  /**
+   * Retrieve base controller
+   * @member {Controller} Controller
+   * @since 1.0.0
+   */
+  Controller: typeof BaseContextClass$1;
+  /**
+   * Retrieve base service
+   * @member {Service} Service
+   * @since 1.0.0
+   */
+  Service: typeof BaseContextClass$1;
+  /**
+   * Retrieve base subscription
+   * @member {Subscription} Subscription
+   * @since 2.12.0
+   */
+  Subscription: typeof BaseContextClass$1;
+  /**
+   * Retrieve base context class
+   * @member {BaseHookClass} BaseHookClass
+   */
+  BaseHookClass: typeof BaseHookClass;
+  /**
+   * Retrieve base boot
+   * @member {Boot}
+   * @alias BaseHookClass
+   */
+  Boot: typeof BaseHookClass;
+  options: Required<EggApplicationCoreOptions>;
+  readonly messenger: IMessenger;
+  agent?: Agent;
+  application?: Application;
+  loader: EggApplicationLoader;
+  /**
+   * @class
+   * @param {Object} options
+   *  - {Object} [type] - type of instance, Agent and Application both extend koa, type can determine what it is.
+   *  - {String} [baseDir] - app root dir, default is `process.cwd()`
+   *  - {Object} [plugins] - custom plugin config, use it in unittest
+   *  - {String} [mode] - process mode, can be cluster / single, default is `cluster`
+   */
+  constructor(options?: EggApplicationCoreOptions);
+  /**
+   * @deprecated please use `options` property instead
+   */
+  get _options(): Required<EggApplicationCoreOptions>;
+  protected loadConfig(): Promise<void>;
+  protected load(): Promise<void>;
+  /**
+   * Usage: new ApiClient({ cluster: app.cluster })
+   */
+  get cluster(): (clientClass: unknown, options?: object) => any;
+  /**
+   * Wrap the Client with Leader/Follower Pattern
+   *
+   * @description almost the same as Agent.cluster API, the only different is that this method create Follower.
+   *
+   * @see https://github.com/node-modules/cluster-client
+   * @param {Function} clientClass - client class function
+   * @param {Object} [options]
+   *   - {Boolean} [autoGenerate] - whether generate delegate rule automatically, default is true
+   *   - {Function} [formatKey] - a method to transform the subscription info into a string，default is JSON.stringify
+   *   - {Object} [transcode|JSON.stringify/parse]
+   *     - {Function} encode - custom serialize method
+   *     - {Function} decode - custom deserialize method
+   *   - {Boolean} [isBroadcast] - whether broadcast subscription result to all followers or just one, default is true
+   *   - {Number} [responseTimeout] - response timeout, default is 3 seconds
+   *   - {Number} [maxWaitTime|30000] - leader startup max time, default is 30 seconds
+   * @return {ClientWrapper} wrapper
+   */
+  clusterWrapper(clientClass: unknown, options?: object): any;
+  /**
+   * print the information when console.log(app)
+   * @return {Object} inspected app.
+   * @since 1.0.0
+   * @example
+   * ```js
+   * console.log(app);
+   * =>
+   * {
+   *   name: 'mock-app',
+   *   env: 'test',
+   *   subdomainOffset: 2,
+   *   config: '<egg config>',
+   *   controller: '<egg controller>',
+   *   service: '<egg service>',
+   *   middlewares: '<egg middlewares>',
+   *   urllib: '<egg urllib>',
+   *   loggers: '<egg loggers>'
+   * }
+   * ```
+   */
+  inspect(): any;
+  toJSON(): any;
+  /**
+   * http request helper base on {@link httpclient}, it will auto save httpclient log.
+   * Keep the same api with `httpclient.request(url, args)`.
+   *
+   * See https://github.com/node-modules/urllib#api-doc for more details.
+   *
+   * @param {String} url request url address.
+   * @param {Object} options
+   * - method {String} - Request method, defaults to GET. Could be GET, POST, DELETE or PUT. Alias 'type'.
+   * - data {Object} - Data to be sent. Will be stringify automatically.
+   * - dataType {String} - String - Type of response data. Could be `text` or `json`.
+   *   If it's `text`, the callback data would be a String.
+   *   If it's `json`, the data of callback would be a parsed JSON Object.
+   *   Default callback data would be a Buffer.
+   * - headers {Object} - Request headers.
+   * - timeout {Number} - Request timeout in milliseconds. Defaults to exports.TIMEOUT.
+   *   Include remote server connecting timeout and response timeout.
+   *   When timeout happen, will return ConnectionTimeout or ResponseTimeout.
+   * - auth {String} - `username:password` used in HTTP Basic Authorization.
+   * - followRedirect {Boolean} - follow HTTP 3xx responses as redirects. defaults to false.
+   * - gzip {Boolean} - let you get the res object when request connected, default false. alias customResponse
+   * - nestedQuerystring {Boolean} - urllib default use querystring to stringify form data which don't
+   *   support nested object, will use qs instead of querystring to support nested object by set this option to true.
+   * - more options see https://github.com/node-modules/urllib
+   * @return {Object}
+   * - status {Number} - HTTP response status
+   * - headers {Object} - HTTP response headers
+   * - res {Object} - HTTP response meta
+   * - data {Object} - HTTP response body
+   *
+   * @example
+   * ```js
+   * const result = await app.curl('http://example.com/foo.json', {
+   *   method: 'GET',
+   *   dataType: 'json',
+   * });
+   * console.log(result.status, result.headers, result.data);
+   * ```
+   */
+  curl<T = any>(url: HttpClientRequestURL, options?: HttpClientRequestOptions): Promise<HttpClientResponse<T>>;
+  /**
+   * Create a new HttpClient instance with custom options
+   * @param {Object} [options] HttpClient init options
+   */
+  createHttpClient(options?: HttpClientOptions): HttpClient$1;
+  /**
+   * HttpClient instance
+   * @see https://github.com/node-modules/urllib
+   * @member {HttpClient}
+   */
+  get httpClient(): HttpClient$1;
+  /**
+   * @deprecated please use httpClient instead
+   * @alias httpClient
+   * @member {HttpClient}
+   */
+  get httpclient(): HttpClient$1;
+  /**
+   * All loggers contain logger, coreLogger and customLogger
+   * @member {Object}
+   * @since 1.0.0
+   */
+  get loggers(): EggLoggers;
+  /**
+   * Get logger by name, it's equal to app.loggers['name'],
+   * but you can extend it with your own logical.
+   * @param {String} name - logger name
+   * @return {Logger} logger
+   */
+  getLogger(name: string): EggLogger;
+  /**
+   * application logger, log file is `$HOME/logs/{appname}/{appname}-web`
+   * @member {Logger}
+   * @since 1.0.0
+   */
+  get logger(): EggLogger;
+  /**
+   * core logger for framework and plugins, log file is `$HOME/logs/{appname}/egg-web`
+   * @member {Logger}
+   * @since 1.0.0
+   */
+  get coreLogger(): EggLogger;
+  _unhandledRejectionHandler(err: any): void;
+  /**
+   * dump out the config and meta object
+   * @private
+   */
+  dumpConfigToObject(): {
+    config: Record<string, any>;
+    meta: Record<string, any>;
+  };
+  /**
+   * save app.config to `run/${type}_config.json`
+   * @private
+   */
+  dumpConfig(): void;
+  dumpTiming(): void;
+  get [EGG_PATH](): string;
+  get config(): EggAppConfig$1;
+  /**
+   * app.env delegate app.config.env
+   * @deprecated
+   */
+  get env(): string;
+  set env(_: string);
+  /**
+   * app.proxy delegate app.config.proxy
+   * @deprecated
+   */
+  get proxy(): boolean;
+  set proxy(_: boolean);
+  /**
+   * Create an anonymous context, the context isn't request level, so the request is mocked.
+   * then you can use context level API like `ctx.service`
+   * @member {String} EggApplication#createAnonymousContext
+   * @param {Request} [req] - if you want to mock request like querystring, you can pass an object to this function.
+   * @return {Context} context
+   */
+  createAnonymousContext(req?: any): EggContext;
+  /**
+   * Run async function in the anonymous context scope
+   * @see Context#runInAnonymousContextScope
+   * @param {Function} scope - the first args is an anonymous ctx, scope should be async function
+   * @param {Request} [req] - if you want to mock request like querystring, you can pass an object to this function.
+   */
+  runInAnonymousContextScope(scope: (ctx: Context$1) => Promise<void>, req?: unknown): Promise<void>;
+  /**
+   * Create egg context
+   * @function EggApplication#createContext
+   * @param  {Req} req - node native Request object
+   * @param  {Res} res - node native Response object
+   * @return {Context} context object
+   */
+  createContext(req: IncomingMessage, res: ServerResponse): Context$1;
+}
+//#endregion
+//#region src/lib/core/base_context_logger.d.ts
+declare class BaseContextLogger {
+  #private;
+  /**
+   * @class
+   * @param {Context} ctx - context instance
+   * @param {String} pathName - class path name
+   * @since 1.0.0
+   */
+  constructor(ctx: EggContext, pathName?: string);
+  protected _log(method: 'info' | 'warn' | 'error' | 'debug', args: any[]): void;
+  /**
+   * @member {Function} BaseContextLogger#debug
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  debug(...args: any[]): void;
+  /**
+   * @member {Function} BaseContextLogger#info
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  info(...args: any[]): void;
+  /**
+   * @member {Function} BaseContextLogger#warn
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  warn(...args: any[]): void;
+  /**
+   * @member {Function} BaseContextLogger#error
+   * @param {...any} args - log msg
+   * @since 1.2.0
+   */
+  error(...args: any[]): void;
+}
+//#endregion
+//#region src/lib/core/base_context_class.d.ts
+/**
+ * BaseContextClass is a base class that can be extended,
+ * it's instantiated in context level,
+ * {@link Helper}, {@link Service} is extending it.
+ */
+declare class BaseContextClass$1 extends BaseContextClass {
+  #private;
+  [key: string | symbol]: any;
+  ctx: Context$1;
+  pathName?: string;
+  app: Application;
+  service: BaseContextClass$1;
+  get logger(): BaseContextLogger;
+}
+//#endregion
+//#region src/lib/start.d.ts
+interface StartEggOptions {
+  /** specify framework that can be absolute path or npm package */
+  framework?: string;
+  /** directory of application, default to `process.cwd()` */
+  baseDir?: string;
+  /** ignore single process mode warning */
+  ignoreWarning?: boolean;
+  mode?: 'single';
+  env?: string;
+  plugins?: EggPlugin;
+}
+interface SingleModeApplication extends Application {
+  agent: SingleModeAgent;
+}
+interface SingleModeAgent extends Agent {
+  app: SingleModeApplication;
+}
+/**
+ * Start egg with single process
+ */
+declare function startEgg(options?: StartEggOptions): Promise<SingleModeApplication>;
+//#endregion
+//#region src/lib/core/base_hook_class.d.ts
+declare class BaseHookClass implements ILifecycleBoot {
+  #private;
+  fullPath?: string;
+  constructor(instance: Application | Agent);
+  get logger(): egg_logger0.EggLogger;
+  get config(): EggAppConfig$1;
+  get app(): Application;
+  get agent(): Agent;
+}
+//#endregion
+export { Agent, Application, BaseContextClass$1 as BaseContextClass, BaseContextLogger, BaseHookClass, ClientErrorResponse, Context$1 as Context, ContextHttpClient, CustomLoaderConfig, EggAppConfig$1 as EggAppConfig, type EggAppInfo, EggApplicationCore, EggApplicationCoreOptions, EggConfigFactory, EggContext, EggEnvType, type EggLogger$1 as EggLogger, EggLoggerConfig, EggPlugin, EggPluginItem, Helper, HttpClient$1 as HttpClient, HttpClientConfig, type HttpClientOptions, HttpClientRequestOptions, type HttpClientRequestURL, type HttpClientResponse, IEggPluginItem, type ILifecycleBoot$1 as ILifecycleBoot, type LoggerLevel, MetaMiddlewareOptions, MiddlewareFunc$1 as MiddlewareFunc, type Next, NotFoundMiddlewareOptions, type PartialDeep, PartialEggConfig, PowerPartial, Request$1 as Request, RequestObjectBody, Router$1 as Router, type SingleModeAgent, type SingleModeApplication, Singleton, type SingletonCreateMethod, type SingletonOptions, SiteFileContentFun, SiteFileMiddlewareOptions, StartEggOptions, _default, _default$1, _default$2, create, defineConfig, defineConfigFactory, startEgg };