@eggjs/core 7.0.0-beta.18 → 7.0.0-beta.20

package/dist/index.d.ts

@@ -1,12 +1,977 @@
-import { _default } from "./utils/index.js";
-import { CustomLoaderConfigItem, EggAppConfig, EggAppInfo, EggPluginInfo } from "./types.js";
-import { BaseContextClass } from "./base_context_class.js";
-import { Timing, TimingItem } from "./utils/timing.js";
-import { BootImplClass, FunWithFullPath, ILifecycleBoot, Lifecycle, LifecycleOptions } from "./lifecycle.js";
-import { CaseStyle, CaseStyleFunction, EXPORTS, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem } from "./loader/file_loader.js";
-import { ClassLoader, ClassLoaderOptions, ContextLoader, ContextLoaderOptions } from "./loader/context_loader.js";
-import { EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions } from "./loader/egg_loader.js";
-import { Singleton, SingletonCreateMethod, SingletonOptions } from "./singleton.js";
-import { Context, EGG_LOADER, EggCore, EggCoreInitOptions, EggCoreOptions, KoaApplication, KoaContext, KoaMiddlewareFunc, KoaRequest, KoaResponse, MiddlewareFunc, Next, Request, Response, Router } from "./egg.js";
-import { SequencifyResult, SequencifyTask, sequencify } from "./utils/sequencify.js";
-export { BaseContextClass, BootImplClass, CaseStyle, CaseStyleFunction, ClassLoader, ClassLoaderOptions, Context, ContextLoader, ContextLoaderOptions, CustomLoaderConfigItem, EGG_LOADER, EXPORTS, EggAppConfig, EggAppInfo, EggCore, EggCoreInitOptions, EggCoreOptions, EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions, EggPluginInfo, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem, FunWithFullPath, ILifecycleBoot, KoaApplication, KoaContext, KoaMiddlewareFunc, KoaRequest, KoaResponse, Lifecycle, LifecycleOptions, MiddlewareFunc, Next, Request, Response, Router, SequencifyResult, SequencifyTask, Singleton, SingletonCreateMethod, SingletonOptions, Timing, TimingItem, sequencify, _default as utils };
+import { Application as KoaApplication, Context as KoaContext, MiddlewareFunc as KoaMiddlewareFunc, Next, Request as KoaRequest, Response as KoaResponse } from "@eggjs/koa";
+import * as egg_logger0 from "egg-logger";
+import { EggConsoleLogger, Logger } from "egg-logger";
+import { EggRouter as Router, RegisterOptions, ResourcesController } from "@eggjs/router";
+import { EventEmitter } from "node:events";
+import { ReadyFunctionArg } from "get-ready";
+import { Ready as Ready$1 } from "ready-callback";
+
+//#region src/utils/index.d.ts
+type Fun = (...args: unknown[]) => unknown;
+declare function getCalleeFromStack(withLine?: boolean, stackIndex?: number): string;
+declare const _default: {
+  deprecated(message: string): void;
+  extensions: any;
+  extensionNames: string[];
+  existsPath(filepath: string): Promise<boolean>;
+  loadFile(filepath: string): Promise<any>;
+  resolvePath(filepath: string, options?: {
+    paths?: string[];
+  }): string;
+  methods: string[];
+  callFn(fn: Fun, args?: unknown[], ctx?: unknown): Promise<unknown>;
+  getCalleeFromStack: typeof getCalleeFromStack;
+  getResolvedFilename(filepath: string, baseDir: string): string;
+};
+//#endregion
+//#region src/types.d.ts
+interface EggAppInfo {
+  /** package.json */
+  pkg: Record<string, any>;
+  /** the application name from package.json */
+  name: string;
+  /** current directory of application */
+  baseDir: string;
+  /** equals to serverEnv */
+  env: string;
+  /** equals to serverScope */
+  scope: string;
+  /** home directory of the OS */
+  HOME: string;
+  /** baseDir when local and unittest, HOME when other environment */
+  root: string;
+}
+interface EggPluginInfo {
+  /** the plugin name, it can be used in `dep` */
+  name: string;
+  /** the package name of plugin */
+  package?: string;
+  version?: string;
+  /** whether enabled */
+  enable: boolean;
+  implicitEnable?: boolean;
+  /** the directory of the plugin package */
+  path?: string;
+  /** the dependent plugins, you can use the plugin name */
+  dependencies: string[];
+  /** the optional dependent plugins. */
+  optionalDependencies: string[];
+  dependents?: string[];
+  /** specify the serverEnv that only enable the plugin in it */
+  env: string[];
+  /** the file plugin config in. */
+  from: string;
+}
+interface CustomLoaderConfigItem {
+  /** the directory of the custom loader */
+  directory: string;
+  /** the inject object, it can be app or ctx */
+  inject: string;
+  /** whether load unit files */
+  loadunit?: boolean;
+}
+interface EggAppConfig extends Record<string, any> {
+  coreMiddleware: string[];
+  middleware: string[];
+  customLoader?: Record<string, CustomLoaderConfigItem>;
+  controller?: {
+    supportParams?: boolean;
+  };
+}
+//#endregion
+//#region src/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 {
+  ctx: Context;
+  app: EggCore;
+  config: Record<string, any>;
+  service: BaseContextClass;
+  /**
+   * @since 1.0.0
+   */
+  constructor(ctx: Context);
+}
+//#endregion
+//#region src/utils/timing.d.ts
+interface TimingItem {
+  name: string;
+  start: number;
+  end?: number;
+  duration?: number;
+  pid: number;
+  index: number;
+}
+declare class Timing {
+  #private;
+  constructor();
+  init(): void;
+  start(name?: string, start?: number): TimingItem | undefined;
+  end(name?: string): TimingItem | undefined;
+  enable(): void;
+  disable(): void;
+  clear(): void;
+  toJSON(): TimingItem[];
+  itemToString(timelineEnd: number, item: TimingItem, times: number): string;
+  toString(prefix?: string, width?: number): string;
+}
+//#endregion
+//#region src/lifecycle.d.ts
+interface ILifecycleBoot {
+  fullPath?: string;
+  /**
+   * Ready to call configDidLoad,
+   * Config, plugin files are referred,
+   * this is the last chance to modify the config.
+   */
+  configWillLoad?(): void;
+  /**
+   * Config, plugin files have loaded
+   */
+  configDidLoad?(): void;
+  /**
+   * All files have loaded, start plugin here
+   */
+  didLoad?(): Promise<void>;
+  /**
+   * All plugins have started, can do some thing before app ready
+   */
+  willReady?(): Promise<void>;
+  /**
+   * Worker is ready, can do some things,
+   * don't need to block the app boot
+   */
+  didReady?(err?: Error): Promise<void>;
+  /**
+   * Server is listening
+   */
+  serverDidReady?(): Promise<void>;
+  /**
+   * Do some thing before app close
+   */
+  beforeClose?(): Promise<void>;
+}
+type BootImplClass<T = ILifecycleBoot> = new (...args: any[]) => T;
+interface LifecycleOptions {
+  baseDir: string;
+  app: EggCore;
+  logger: EggConsoleLogger;
+}
+type FunWithFullPath = Fun & {
+  fullPath?: string;
+};
+declare class Lifecycle extends EventEmitter {
+  #private;
+  loadReady: Ready$1;
+  bootReady: Ready$1;
+  options: LifecycleOptions;
+  readyTimeout: number;
+  constructor(options: Partial<LifecycleOptions>);
+  ready(): Promise<void>;
+  ready(flagOrFunction: ReadyFunctionArg): void;
+  get app(): EggCore;
+  get logger(): EggConsoleLogger<egg_logger0.LoggerOptions>;
+  get timing(): Timing;
+  legacyReadyCallback(name: string, opt?: object): (...args: unknown[]) => void;
+  addBootHook(bootHootOrBootClass: BootImplClass | ILifecycleBoot): void;
+  addFunctionAsBootHook<T = EggCore>(hook: (app: T) => void, fullPath?: string): void;
+  /**
+   * init boots and trigger config did config
+   */
+  init(): void;
+  registerBeforeStart(scope: Fun, name: string): void;
+  registerBeforeClose(fn: FunWithFullPath, fullPath?: string): void;
+  close(): Promise<void>;
+  triggerConfigWillLoad(): void;
+  triggerConfigDidLoad(): void;
+  triggerDidLoad(): void;
+  triggerWillReady(): void;
+  triggerDidReady(err?: Error): Promise<void>;
+  triggerServerDidReady(): Promise<void>;
+}
+//#endregion
+//#region src/loader/file_loader.d.ts
+declare const FULLPATH: unique symbol;
+declare const EXPORTS: unique symbol;
+declare const CaseStyle: {
+  readonly camel: "camel";
+  readonly lower: "lower";
+  readonly upper: "upper";
+};
+type CaseStyle = (typeof CaseStyle)[keyof typeof CaseStyle];
+type CaseStyleFunction = (filepath: string) => string[];
+type FileLoaderInitializer = (exports: unknown, options: {
+  path: string;
+  pathName: string;
+}) => unknown;
+type FileLoaderFilter = (exports: unknown) => boolean;
+interface FileLoaderOptions {
+  /** directories to be loaded */
+  directory: string | string[];
+  /** attach the target object from loaded files */
+  target: Record<string, any>;
+  /** match the files when load, support glob, default to all js files */
+  match?: string | string[];
+  /** ignore the files when load, support glob */
+  ignore?: string | string[];
+  /** custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path` */
+  initializer?: FileLoaderInitializer;
+  /** determine whether invoke when exports is function */
+  call?: boolean;
+  /** determine whether override the property when get the same name */
+  override?: boolean;
+  /** an object that be the argument when invoke the function */
+  inject?: Record<string, any>;
+  /** a function that filter the exports which can be loaded */
+  filter?: FileLoaderFilter;
+  /** set property's case when converting a filepath to property list. */
+  caseStyle?: CaseStyle | CaseStyleFunction;
+  lowercaseFirst?: boolean;
+}
+interface FileLoaderParseItem {
+  fullpath: string;
+  properties: string[];
+  exports: object | Fun;
+}
+/**
+ * Load files from directory to target object.
+ * @since 1.0.0
+ */
+declare class FileLoader {
+  static get FULLPATH(): symbol;
+  static get EXPORTS(): symbol;
+  readonly options: FileLoaderOptions & Required<Pick<FileLoaderOptions, 'caseStyle'>>;
+  /**
+   * @class
+   * @param {Object} options - options
+   * @param {String|Array} options.directory - directories to be loaded
+   * @param {Object} options.target - attach the target object from loaded files
+   * @param {String} options.match - match the files when load, support glob, default to all js files
+   * @param {String} options.ignore - ignore the files when load, support glob
+   * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+   * @param {Boolean} options.call - determine whether invoke when exports is function
+   * @param {Boolean} options.override - determine whether override the property when get the same name
+   * @param {Object} options.inject - an object that be the argument when invoke the function
+   * @param {Function} options.filter - a function that filter the exports which can be loaded
+   * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+   */
+  constructor(options: FileLoaderOptions);
+  /**
+   * attach items to target object. Mapping the directory to properties.
+   * `app/controller/group/repository.js` => `target.group.repository`
+   * @returns {Object} target
+   * @since 1.0.0
+   */
+  load(): Promise<object>;
+  /**
+   * Parse files from given directories, then return an items list, each item contains properties and exports.
+   *
+   * For example, parse `app/controller/group/repository.js`
+   *
+   * ```
+   * module.exports = app => {
+   *   return class RepositoryController extends app.Controller {};
+   * }
+   * ```
+   *
+   * It returns a item
+   *
+   * ```
+   * {
+   *   properties: [ 'group', 'repository' ],
+   *   exports: app => { ... },
+   * }
+   * ```
+   *
+   * `Properties` is an array that contains the directory of a filepath.
+   *
+   * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+   * @returns {Array} items
+   * @since 1.0.0
+   */
+  protected parse(): Promise<FileLoaderParseItem[]>;
+}
+//#endregion
+//#region src/loader/context_loader.d.ts
+interface ClassLoaderOptions {
+  ctx: Context;
+  properties: any;
+}
+declare class ClassLoader {
+  #private;
+  readonly _cache: Map<any, any>;
+  _ctx: Context;
+  constructor(options: ClassLoaderOptions);
+}
+interface ContextLoaderOptions extends Omit<FileLoaderOptions, 'target'> {
+  /** required inject */
+  inject: Record<string, any>;
+  /** property name defined to target */
+  property: string | symbol;
+  /** determine the field name of inject object. */
+  fieldClass?: string;
+}
+/**
+ * Same as {@link FileLoader}, but it will attach file to `inject[fieldClass]`.
+ * The exports will be lazy loaded, such as `ctx.group.repository`.
+ * @augments FileLoader
+ * @since 1.0.0
+ */
+declare class ContextLoader extends FileLoader {
+  #private;
+  /**
+   * @class
+   * @param {Object} options - options same as {@link FileLoader}
+   * @param {String} options.fieldClass - determine the field name of inject object.
+   */
+  constructor(options: ContextLoaderOptions);
+}
+//#endregion
+//#region src/loader/egg_loader.d.ts
+interface EggLoaderOptions {
+  /** server env */
+  env: string;
+  /** Application instance */
+  app: EggCore;
+  EggCoreClass?: typeof EggCore;
+  /** the directory of application */
+  baseDir: string;
+  /** egg logger */
+  logger: Logger;
+  /** server scope */
+  serverScope?: string;
+  /** custom plugins */
+  plugins?: Record<string, EggPluginInfo>;
+}
+type EggDirInfoType = 'app' | 'plugin' | 'framework';
+interface EggDirInfo {
+  path: string;
+  type: EggDirInfoType;
+}
+declare class EggLoader {
+  #private;
+  readonly options: EggLoaderOptions;
+  readonly timing: Timing;
+  readonly pkg: Record<string, any>;
+  readonly eggPaths: string[];
+  readonly serverEnv: string;
+  readonly serverScope: string;
+  readonly appInfo: EggAppInfo;
+  dirs?: EggDirInfo[];
+  /**
+   * @class
+   * @param {Object} options - options
+   * @param {String} options.baseDir - the directory of application
+   * @param {EggCore} options.app - Application instance
+   * @param {Logger} options.logger - logger
+   * @param {Object} [options.plugins] - custom plugins
+   * @since 1.0.0
+   */
+  constructor(options: EggLoaderOptions);
+  get app(): EggCore;
+  get lifecycle(): Lifecycle;
+  get logger(): Logger<egg_logger0.EggLoggerOptions>;
+  /**
+   * Get {@link AppInfo#env}
+   * @returns {String} env
+   * @see AppInfo#env
+   * @private
+   * @since 1.0.0
+   */
+  protected getServerEnv(): string;
+  /**
+   * Get {@link AppInfo#scope}
+   * @returns {String} serverScope
+   * @private
+   */
+  protected getServerScope(): string;
+  /**
+   * Get {@link AppInfo#name}
+   * @returns {String} appname
+   * @private
+   * @since 1.0.0
+   */
+  getAppname(): string;
+  /**
+   * Get home directory
+   * @returns {String} home directory
+   * @since 3.4.0
+   */
+  getHomedir(): string;
+  /**
+   * Get app info
+   * @returns {AppInfo} appInfo
+   * @since 1.0.0
+   */
+  protected getAppInfo(): EggAppInfo;
+  /**
+   * Get {@link EggLoader#eggPaths}
+   * @returns {Array} framework directories
+   * @see {@link EggLoader#eggPaths}
+   * @private
+   * @since 1.0.0
+   */
+  protected getEggPaths(): string[];
+  /** start Plugin loader */
+  lookupDirs: Set<string>;
+  eggPlugins: Record<string, EggPluginInfo>;
+  appPlugins: Record<string, EggPluginInfo>;
+  customPlugins: Record<string, EggPluginInfo>;
+  allPlugins: Record<string, EggPluginInfo>;
+  orderPlugins: EggPluginInfo[];
+  /** enable plugins */
+  plugins: Record<string, EggPluginInfo>;
+  /**
+   * Load config/plugin.js from {EggLoader#loadUnits}
+   *
+   * plugin.js is written below
+   *
+   * ```js
+   * {
+   *   'xxx-client': {
+   *     enable: true,
+   *     package: 'xxx-client',
+   *     dep: [],
+   *     env: [],
+   *   },
+   *   // short hand
+   *   'rds': false,
+   *   'depd': {
+   *     enable: true,
+   *     path: 'path/to/depd'
+   *   }
+   * }
+   * ```
+   *
+   * If the plugin has path, Loader will find the module from it.
+   *
+   * Otherwise Loader will lookup follow the order by packageName
+   *
+   * 1. $APP_BASE/node_modules/${package}
+   * 2. $EGG_BASE/node_modules/${package}
+   *
+   * You can call `loader.plugins` that retrieve enabled plugins.
+   *
+   * ```js
+   * loader.plugins['xxx-client'] = {
+   *   name: 'xxx-client',                 // the plugin name, it can be used in `dep`
+   *   package: 'xxx-client',              // the package name of plugin
+   *   enable: true,                       // whether enabled
+   *   path: 'path/to/xxx-client',         // the directory of the plugin package
+   *   dep: [],                            // the dependent plugins, you can use the plugin name
+   *   env: [ 'local', 'unittest' ],       // specify the serverEnv that only enable the plugin in it
+   * }
+   * ```
+   *
+   * `loader.allPlugins` can be used when retrieve all plugins.
+   * @function EggLoader#loadPlugin
+   * @since 1.0.0
+   */
+  loadPlugin(): Promise<void>;
+  protected loadAppPlugins(): Promise<Record<string, EggPluginInfo>>;
+  protected loadEggPlugins(): Promise<Record<string, EggPluginInfo>>;
+  protected loadCustomPlugins(): Record<string, EggPluginInfo>;
+  protected readPluginConfigs(configPaths: string[] | string): Promise<Record<string, EggPluginInfo>>;
+  protected getOrderPlugins(allPlugins: Record<string, EggPluginInfo>, enabledPluginNames: string[], appPlugins: Record<string, EggPluginInfo>): EggPluginInfo[];
+  protected getLookupDirs(): Set<string>;
+  protected getPluginPath(plugin: EggPluginInfo): string;
+  /** end Plugin loader */
+  /** start Config loader */
+  configMeta: Record<string, any>;
+  config: EggAppConfig;
+  /**
+   * Load config/config.js
+   *
+   * Will merge config.default.js 和 config.${env}.js
+   *
+   * @function EggLoader#loadConfig
+   * @since 1.0.0
+   */
+  loadConfig(): Promise<void>;
+  /** end Config loader */
+  /** start Extend loader */
+  /**
+   * mixin Agent.prototype
+   * @function EggLoader#loadAgentExtend
+   * @since 1.0.0
+   */
+  loadAgentExtend(): Promise<void>;
+  /**
+   * mixin Application.prototype
+   * @function EggLoader#loadApplicationExtend
+   * @since 1.0.0
+   */
+  loadApplicationExtend(): Promise<void>;
+  /**
+   * mixin Request.prototype
+   * @function EggLoader#loadRequestExtend
+   * @since 1.0.0
+   */
+  loadRequestExtend(): Promise<void>;
+  /**
+   * mixin Response.prototype
+   * @function EggLoader#loadResponseExtend
+   * @since 1.0.0
+   */
+  loadResponseExtend(): Promise<void>;
+  /**
+   * mixin Context.prototype
+   * @function EggLoader#loadContextExtend
+   * @since 1.0.0
+   */
+  loadContextExtend(): Promise<void>;
+  /**
+   * mixin app.Helper.prototype
+   * @function EggLoader#loadHelperExtend
+   * @since 1.0.0
+   */
+  loadHelperExtend(): Promise<void>;
+  /**
+   * Find all extend file paths by name
+   * can be override in top level framework to support load `app/extends/{name}.js`
+   *
+   * @param {String} name - filename which may be `app/extend/{name}.js`
+   * @returns {Array} filepaths extend file paths
+   * @private
+   */
+  protected getExtendFilePaths(name: string): string[];
+  /**
+   * Loader app/extend/xx.js to `prototype`,
+   * @function loadExtend
+   * @param {String} name - filename which may be `app/extend/{name}.js`
+   * @param {Object} proto - prototype that mixed
+   * @since 1.0.0
+   */
+  loadExtend(name: string, proto: object): Promise<void>;
+  /** end Extend loader */
+  /** start Custom loader */
+  /**
+   * load app.js
+   *
+   * @example
+   * - old:
+   *
+   * ```js
+   * module.exports = function(app) {
+   *   doSomething();
+   * }
+   * ```
+   *
+   * - new:
+   *
+   * ```js
+   * module.exports = class Boot {
+   *   constructor(app) {
+   *     this.app = app;
+   *   }
+   *   configDidLoad() {
+   *     doSomething();
+   *   }
+   * }
+   * @since 1.0.0
+   */
+  loadCustomApp(): Promise<void>;
+  /**
+   * Load agent.js, same as {@link EggLoader#loadCustomApp}
+   */
+  loadCustomAgent(): Promise<void>;
+  loadBootHook(): void;
+  /** end Custom loader */
+  /** start Service loader */
+  /**
+   * Load app/service
+   * @function EggLoader#loadService
+   * @param {Object} options - LoaderOptions
+   * @since 1.0.0
+   */
+  loadService(options?: Partial<ContextLoaderOptions>): Promise<void>;
+  /** end Service loader */
+  /** start Middleware loader */
+  /**
+   * Load app/middleware
+   *
+   * app.config.xx is the options of the middleware xx that has same name as config
+   *
+   * @function EggLoader#loadMiddleware
+   * @param {Object} opt - LoaderOptions
+   * @example
+   * ```js
+   * // app/middleware/status.js
+   * module.exports = function(options, app) {
+   *   // options == app.config.status
+   *   return async next => {
+   *     await next();
+   *   }
+   * }
+   * ```
+   * @since 1.0.0
+   */
+  loadMiddleware(opt?: Partial<FileLoaderOptions>): Promise<void>;
+  /** end Middleware loader */
+  /** start Controller loader */
+  /**
+   * Load app/controller
+   * @param {Object} opt - LoaderOptions
+   * @since 1.0.0
+   */
+  loadController(opt?: Partial<FileLoaderOptions>): Promise<void>;
+  /** end Controller loader */
+  /** start Router loader */
+  /**
+   * Load app/router.js
+   * @function EggLoader#loadRouter
+   * @since 1.0.0
+   */
+  loadRouter(): Promise<void>;
+  /** end Router loader */
+  /** start CustomLoader loader */
+  loadCustomLoader(): Promise<void>;
+  /** end CustomLoader loader */
+  /**
+   * Load single file, will invoke when export is function
+   *
+   * @param {String} filepath - fullpath
+   * @param {Array} inject - pass rest arguments into the function when invoke
+   * @returns {Object} exports
+   * @example
+   * ```js
+   * app.loader.loadFile(path.join(app.options.baseDir, 'config/router.js'));
+   * ```
+   * @since 1.0.0
+   */
+  loadFile(filepath: string, ...inject: unknown[]): Promise<any>;
+  /**
+   * @param {String} filepath - fullpath
+   * @private
+   */
+  requireFile(filepath: string): Promise<any>;
+  /**
+   * Get all loadUnit
+   *
+   * loadUnit is a directory that can be loaded by EggLoader, it has the same structure.
+   * loadUnit has a path and a type(app, framework, plugin).
+   *
+   * The order of the loadUnits:
+   *
+   * 1. plugin
+   * 2. framework
+   * 3. app
+   *
+   * @returns {Array} loadUnits
+   * @since 1.0.0
+   */
+  getLoadUnits(): EggDirInfo[];
+  /**
+   * Load files using {@link FileLoader}, inject to {@link Application}
+   * @param {String|Array} directory - see {@link FileLoader}
+   * @param {String} property - see {@link FileLoader}, e.g.: 'controller', 'middlewares'
+   * @param {Object} options - see {@link FileLoader}
+   * @since 1.0.0
+   */
+  loadToApp(directory: string | string[], property: string | symbol, options?: Omit<FileLoaderOptions, 'inject' | 'target'>): Promise<void>;
+  /**
+   * Load files using {@link ContextLoader}
+   * @param {String|Array} directory - see {@link ContextLoader}
+   * @param {String} property - see {@link ContextLoader}
+   * @param {Object} options - see {@link ContextLoader}
+   * @since 1.0.0
+   */
+  loadToContext(directory: string | string[], property: string | symbol, options?: Omit<ContextLoaderOptions, 'inject' | 'property'>): Promise<void>;
+  /**
+   * @member {FileLoader} EggLoader#FileLoader
+   * @since 1.0.0
+   */
+  get FileLoader(): typeof FileLoader;
+  /**
+   * @member {ContextLoader} EggLoader#ContextLoader
+   * @since 1.0.0
+   */
+  get ContextLoader(): typeof ContextLoader;
+  getTypeFiles(filename: string): string[];
+  resolveModule(filepath: string): string | undefined;
+}
+//#endregion
+//#region src/singleton.d.ts
+type SingletonCreateMethod = (config: Record<string, any>, app: EggCore, clientName: string) => unknown | Promise<unknown>;
+interface SingletonOptions {
+  name: string;
+  app: EggCore;
+  create: SingletonCreateMethod;
+}
+declare class Singleton<T = any> {
+  #private;
+  readonly clients: Map<string, T>;
+  readonly app: EggCore;
+  readonly create: SingletonCreateMethod;
+  readonly name: string;
+  readonly options: Record<string, any>;
+  constructor(options: SingletonOptions);
+  init(): void | Promise<void>;
+  initSync(): void;
+  initAsync(): Promise<void>;
+  /**
+   * @deprecated please use `getSingletonInstance(id)` instead
+   */
+  get(id: string): T;
+  /**
+   * Get singleton instance by id
+   */
+  getSingletonInstance(id: string): T;
+  createInstance(config: Record<string, any>, clientName: string): T;
+  createInstanceAsync(config: Record<string, any>, clientName: string): Promise<T>;
+}
+//#endregion
+//#region src/egg.d.ts
+declare const EGG_LOADER: unique symbol;
+interface EggCoreOptions {
+  baseDir: string;
+  type: 'application' | 'agent';
+  plugins?: any;
+  serverScope?: string;
+  env?: string;
+}
+type EggCoreInitOptions = Partial<EggCoreOptions>;
+declare class Request extends KoaRequest {
+  app: EggCore;
+  response: Response;
+}
+declare class Response extends KoaResponse {
+  app: EggCore;
+  request: Request;
+}
+declare class Context extends KoaContext {
+  app: EggCore;
+  request: Request;
+  response: Response;
+  service: BaseContextClass;
+  /**
+   * Returns map of URL parameters for given `path` and `paramNames`.
+   * @example
+   * ##### ctx.params.id {string}
+   *
+   * `GET /api/users/1` => `'1'`
+   *
+   * ##### ctx.params.per_page {string}
+   *
+   * The number of every page, `GET /api/users?per_page=20` => `20`
+   */
+  params?: Record<string, string>;
+  /**
+   * Returns array of router regexp url path captures.
+   */
+  captures?: string[];
+  /**
+   * Returns the name of the matched router.
+   */
+  routerName?: string;
+  /**
+   * Returns the path of the matched router.
+   */
+  routerPath?: string | RegExp;
+}
+type MiddlewareFunc<T extends KoaContext = Context> = KoaMiddlewareFunc<T>;
+declare class EggCore extends KoaApplication {
+  #private;
+  options: EggCoreOptions;
+  timing: Timing;
+  console: EggConsoleLogger;
+  BaseContextClass: typeof BaseContextClass;
+  Controller: typeof BaseContextClass;
+  Service: typeof BaseContextClass;
+  Helper?: typeof BaseContextClass;
+  lifecycle: Lifecycle;
+  loader: EggLoader;
+  /** auto inject on loadService() */
+  readonly serviceClasses: Record<string, any>;
+  /** auto inject on loadController() */
+  readonly controller: Record<string, any>;
+  /** auto inject on loadMiddleware() */
+  readonly middlewares: Record<string, (opt: unknown, app: EggCore) => MiddlewareFunc>;
+  /**
+   * @class
+   * @param {Object} options - options
+   * @param {String} [options.baseDir] - the directory of application
+   * @param {String} [options.type] - whether it's running in app worker or agent worker
+   * @param {Object} [options.plugins] - custom plugins
+   * @since 1.0.0
+   */
+  constructor(options?: EggCoreInitOptions);
+  get logger(): Logger;
+  get coreLogger(): Logger;
+  /**
+   * create a singleton instance
+   * @param {String} name - unique name for singleton
+   * @param {Function|AsyncFunction} create - method will be invoked when singleton instance create
+   */
+  addSingleton(name: string, create: SingletonCreateMethod): void;
+  /**
+   * override koa's app.use, support generator function
+   * @since 1.0.0
+   */
+  use<T extends KoaContext = Context>(fn: MiddlewareFunc<T>): this;
+  /**
+   * Whether `application` or `agent`
+   * @member {String}
+   * @since 1.0.0
+   */
+  get type(): "application" | "agent";
+  /**
+   * The current directory of application
+   * @member {String}
+   * @see {@link AppInfo#baseDir}
+   * @since 1.0.0
+   */
+  get baseDir(): string;
+  /**
+   * Alias to {@link https://npmjs.com/package/depd}
+   * @member {Function}
+   * @since 1.0.0
+   */
+  get deprecate(): (message: string) => void;
+  /**
+   * The name of application
+   * @member {String}
+   * @see {@link AppInfo#name}
+   * @since 1.0.0
+   */
+  get name(): any;
+  /**
+   * Retrieve enabled plugins
+   * @member {Object}
+   * @since 1.0.0
+   */
+  get plugins(): Record<string, EggPluginInfo>;
+  /**
+   * The configuration of application
+   * @member {Config}
+   * @since 1.0.0
+   */
+  get config(): EggAppConfig;
+  /**
+   * Execute scope after loaded and before app start.
+   *
+   * Notice:
+   * This method is now NOT recommended and regarded as a deprecated one,
+   * For plugin development, we should use `didLoad` instead.
+   * For application development, we should use `willReady` instead.
+   *
+   * @see https://eggjs.org/en/advanced/loader.html#beforestart
+   *
+   * @param  {Function} scope function will execute before app start
+   * @param {string} [name] scope name, default is empty string
+   */
+  beforeStart(scope: Fun, name?: string): void;
+  /**
+   * register an callback function that will be invoked when application is ready.
+   * @see https://github.com/node-modules/get-ready
+   * @since 1.0.0
+   * @example
+   * const app = new Application(...);
+   * app.ready(err => {
+   *   if (err) throw err;
+   *   console.log('done');
+   * });
+   */
+  ready(): Promise<void>;
+  ready(flagOrFunction: ReadyFunctionArg): void;
+  /**
+   * If a client starts asynchronously, you can register `readyCallback`,
+   * then the application will wait for the callback to ready
+   *
+   * It will log when the callback is not invoked after 10s
+   *
+   * Recommend to use {@link EggCore#beforeStart}
+   * @since 1.0.0
+   *
+   * @param {String} name - readyCallback task name
+   * @param {object} opts -
+   *   - {Number} [timeout=10000] - emit `ready_timeout` when it doesn't finish but reach the timeout
+   *   - {Boolean} [isWeakDep=false] - whether it's a weak dependency
+   * @returns {Function} - a callback
+   * @example
+   * const done = app.readyCallback('mysql');
+   * mysql.ready(done);
+   */
+  readyCallback(name: string, opts: object): (...args: unknown[]) => void;
+  /**
+   * Register a function that will be called when app close.
+   *
+   * Notice:
+   * This method is now NOT recommended directly used,
+   * Developers SHOULDN'T use app.beforeClose directly now,
+   * but in the form of class to implement beforeClose instead.
+   *
+   * @see https://eggjs.org/en/advanced/loader.html#beforeclose
+   *
+   * @param {Function} fn - the function that can be generator function or async function.
+   */
+  beforeClose(fn: Fun, name?: string): void;
+  /**
+   * Close all, it will close
+   * - callbacks registered by beforeClose
+   * - emit `close` event
+   * - remove add listeners
+   *
+   * If error is thrown when it's closing, the promise will reject.
+   * It will also reject after following call.
+   * @returns {Promise} promise
+   * @since 1.0.0
+   */
+  close(): Promise<void>;
+  /**
+   * get router
+   * @member {Router} EggCore#router
+   * @since 1.0.0
+   */
+  get router(): Router;
+  /**
+   * Alias to {@link Router#url}
+   * @param {String} name - Router name
+   * @param {Object} params - more parameters
+   * @returns {String} url
+   */
+  url(name: string, params?: Parameters<Router['url']>[1]): string;
+  head(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  head(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  get(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  get(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  put(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  put(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  patch(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  patch(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  post(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  post(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  delete(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  delete(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  del(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  del(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  all(path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  all(name: string, path: string | RegExp | (string | RegExp)[], ...middlewares: (MiddlewareFunc | string)[]): EggCore;
+  resources(prefix: string, controller: string | ResourcesController): EggCore;
+  resources(prefix: string, middleware: MiddlewareFunc, controller: string | ResourcesController): EggCore;
+  resources(name: string, prefix: string, controller: string | ResourcesController): EggCore;
+  resources(name: string, prefix: string, middleware: MiddlewareFunc, controller: string | ResourcesController): EggCore;
+  redirect(source: string, destination: string, status?: number): this;
+  register(path: string | RegExp | (string | RegExp)[], methods: string[], middleware: MiddlewareFunc | MiddlewareFunc[], opts?: RegisterOptions): this;
+  get [EGG_LOADER](): typeof EggLoader;
+}
+//#endregion
+//#region src/utils/sequencify.d.ts
+interface SequencifyResult {
+  sequence: string[];
+  requires: Record<string, true>;
+}
+interface SequencifyTask {
+  dependencies: string[];
+  optionalDependencies: string[];
+}
+declare function sequencify(tasks: Record<string, SequencifyTask>, names: string[]): {
+  sequence: string[];
+  missingTasks: string[];
+  recursiveDependencies: string[];
+};
+//#endregion
+export { BaseContextClass, BootImplClass, CaseStyle, CaseStyleFunction, ClassLoader, ClassLoaderOptions, Context, ContextLoader, ContextLoaderOptions, CustomLoaderConfigItem, EGG_LOADER, EXPORTS, EggAppConfig, EggAppInfo, EggCore, EggCoreInitOptions, EggCoreOptions, EggDirInfo, EggDirInfoType, EggLoader, EggLoaderOptions, EggPluginInfo, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem, FunWithFullPath, ILifecycleBoot, KoaApplication, KoaContext, type KoaMiddlewareFunc, KoaRequest, KoaResponse, Lifecycle, LifecycleOptions, MiddlewareFunc, type Next, Request, Response, Router, SequencifyResult, SequencifyTask, Singleton, SingletonCreateMethod, SingletonOptions, Timing, TimingItem, sequencify, _default as utils };