@anu8151/adonisjs-blueprint 0.3.3 → 0.3.6

package/build/base_generator-ClKso0XJ.d.ts

@@ -0,0 +1,3009 @@
+import { Codemods } from "@adonisjs/core/ace/codemods";
+import { AssemblerRcFile } from "@adonisjs/assembler/types";
+import diagnostics_channel from "node:diagnostics_channel";
+import { ApplicationService } from "@adonisjs/core/types";
+
+//#region node_modules/@poppinss/types/build/src/base.d.ts
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * Primitive values
+ */
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Accept one or more of the mentioned type
+ */
+type OneOrMore<T> = T | T[];
+/**
+ * Representation of a class constructor
+ */
+type Constructor<T, Arguments extends unknown[] = any[]> = new (...args: Arguments) => T;
+/**
+ * Representation of an abstract class constructor
+ */
+type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new (...args: Arguments) => T;
+/**
+ * A function that lazily imports a module with default export.
+ */
+type LazyImport<DefaultExport> = () => Promise<{
+  default: DefaultExport;
+}>;
+/**
+ * Unwraps default export from a lazy import function
+ */
+type UnWrapLazyImport<Fn extends LazyImport<any>> = Awaited<ReturnType<Fn>>['default'];
+/**
+ * Normalizes constructor to work with mixins. There is an open bug for mixins
+ * to allow constructors other than `...args: any[]`
+ *
+ * https://github.com/microsoft/TypeScript/issues/37142
+ */
+type NormalizeConstructor<T extends Constructor<any>> = Omit<T, 'constructor'> & {
+  new (...args: any[]): InstanceType<T>;
+};
+/**
+ * Create a branded Opaque type for a value. For example
+ *
+ * type Username = Opaque<string, 'username'>
+ * type Password = Opaque<string, 'password'>
+ *
+ * function checkUser(username: Username) {}
+ *
+ * const username: Username = 'virk'
+ * const password: Password = 'secret'
+ *
+ * checkUser(username) // ✅
+ * checkUser(password) // ❌
+ */
+declare const opaqueProp: unique symbol;
+type Opaque<T, K> = T & {
+  [opaqueProp]: K;
+};
+type UnwrapOpaque<T> = T extends Opaque<infer A, any> ? A : never;
+/**
+ * Extract functions from an object or class instance
+ */
+type ExtractFunctions<T, IgnoreList extends keyof T = never> = { [P in keyof T]: P extends IgnoreList ? never : T[P] extends ((...args: any[]) => any) ? P : never }[keyof T];
+/**
+ * Check of all the values of an object are optional.
+ */
+type AreAllOptional<T> = keyof T extends never ? true : { [K in keyof T]-?: [undefined] extends [T[K]] ? never : K }[keyof T] extends never ? true : false;
+/**
+ * Returns a union of properties that could be undefined
+ */
+type ExtractUndefined<T> = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T];
+/**
+ * Returns a union of properties that will never be undefined
+ */
+type ExtractDefined<T> = { [K in keyof T]: undefined extends T[K] ? never : K }[keyof T];
+/**
+ * Returns a union of T or PromiseLike<T>
+ */
+type AsyncOrSync<T> = PromiseLike<T> | T;
+/**
+ * Marks nested properties as partial
+ */
+type DeepPartial<T> = Prettify<{ [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P] }>;
+//#endregion
+//#region node_modules/@poppinss/types/build/src/route.d.ts
+/**
+ * Infers param segment from the route identifier.
+ */
+type ParamSegment<Identifier extends string> = Identifier extends `${infer SegmentA}/${infer SegmentB}` ? Param<SegmentA> | ParamSegment<SegmentB> : Param<Identifier>;
+type Param<Segment extends string> = Segment extends `:${string}?` ? never : Segment extends `:${infer ParamName}` ? ParamName extends `${infer ParamWithoutExt}.${string}` ? ParamWithoutExt : ParamName : never;
+/**
+ * Infers optional param segment from the route identifier.
+ */
+type OptionalParamSegment<Identifier extends string> = Identifier extends `${infer SegmentA}/${infer SegmentB}` ? OptionalParam<SegmentA> | OptionalParamSegment<SegmentB> : OptionalParam<Identifier>;
+type OptionalParam<Segment extends string> = Segment extends `:${infer ParamName}?` ? ParamName : never;
+/**
+ * Infers wildcard param segment from the route identifier.
+ */
+type WildcardParamSegment<Identifier extends string> = Identifier extends `${infer SegmentA}/${infer SegmentB}` ? WildcardParam<SegmentA> | WildcardParamSegment<SegmentB> : WildcardParam<Identifier>;
+type WildcardParam<Segment extends string> = Segment extends '*' ? '*' : never;
+/**
+ * Infer route params from the route idenfifier
+ */
+type InferRouteParams<Identifier extends string> = Prettify<{ [Key in ParamSegment<Identifier>]: string } & { [Key in OptionalParamSegment<Identifier>]?: string } & { [Key in WildcardParamSegment<Identifier>]: string[] }>;
+//#endregion
+//#region node_modules/@adonisjs/config/build/src/config.d.ts
+/**
+ * Config module eases the process of using configuration inside your AdonisJS
+ * applications.
+ *
+ * The config files are stored inside a dedicated directory, which are loaded and cached
+ * on application boot. Later you can access the values using the `dot` syntax.
+ *
+ * ## Access values
+ *
+ * 1. **Given the config file is stored as `config/app.ts` with following content**
+ *
+ * ```js
+ * module.exports = {
+ *  appKey: ''
+ * }
+ * ```
+ *
+ * 2. **You access the appKey as follows**
+ *
+ * ```js
+ * const config = new Config(configTree)
+ * config.get('app.appKey')
+ * ```
+ */
+declare class Config {
+  #private;
+  constructor(config?: Record<any, any>);
+  /**
+   * Get a tree of config imported from the config directory
+   */
+  all(): Record<any, any>;
+  /**
+   * Check if config value exists for a given key
+   *
+   * ```ts
+   * config.has('database.mysql')
+   * ```
+   */
+  has(key: string): boolean;
+  /**
+   * Read value from the config. Make use of the `dot notation`
+   * syntax to read nested values.
+   *
+   * The `defaultValue` is returned when the original value
+   * is `undefined`.
+   *
+   * ```ts
+   * config.get('database.mysql')
+   * ```
+   */
+  get<T>(key: string, defaultValue?: any): T;
+  /**
+   * Define defaults for a config key. The defaults are merged
+   * with the value of the config key.
+   */
+  defaults(key: string, value: any): void;
+  /**
+   * Update value for a key. No changes are made on the disk
+   *
+   * ```ts
+   * config.set('database.host', '127.0.0.1')
+   * ```
+   */
+  set(key: string, value: any): void;
+}
+//#endregion
+//#region node_modules/@adonisjs/config/build/src/loader.d.ts
+/**
+ * The config loader imports all the script files from a given directory
+ * and returns their exports as a tree of objects.
+ *
+ * Following file extensions are considered script files.
+ *
+ * - .js
+ * - .ts (without .d.ts)
+ * - .json
+ * - .cjs
+ * - .mjs
+ */
+declare class ConfigLoader {
+  #private;
+  constructor(configDir: string | URL);
+  /**
+   * Load config files as a tree from a given path.
+   */
+  load(): Promise<any>;
+}
+//#endregion
+//#region node_modules/@adonisjs/application/build/src/stubs/stub.d.ts
+/**
+ * The Stub class processes template files using the Tempura template engine
+ * to generate code files. Stubs are template files that contain placeholders
+ * and logic for generating application resources like controllers, models, etc.
+ *
+ * Features:
+ * - Tempura template processing with data binding
+ * - Automatic file writing with directory creation
+ * - Force overwrite support
+ * - Export metadata parsing from template output
+ * - Enhanced error reporting with stub file locations
+ *
+ * @example
+ * const stub = new Stub(app, stubContent, '/path/to/controller.stub')
+ * const result = await stub.generate({
+ *   name: 'UserController',
+ *   to: app.httpControllersPath('user_controller.ts')
+ * })
+ */
+declare class Stub {
+  #private;
+  /**
+   * Creates a new Stub instance for processing template files.
+   *
+   * @param {Application<any>} app - The application instance
+   * @param {string} stubContents - The raw contents of the stub template
+   * @param {string} stubPath - The absolute path to the stub file
+   */
+  constructor(app: Application<any>, stubContents: string, stubPath: string);
+  /**
+   * Replaces the rendered stub output with raw content.
+   * When called, the provided content will be used as the final output
+   * instead of processing the stub template.
+   *
+   * @param rawContent - The raw content to use instead of rendering the stub
+   * @returns {this} Returns the Stub instance for method chaining
+   */
+  replaceWith(rawContent: string): this;
+  /**
+   * Prepares the stub for file generation by rendering the template
+   * and extracting all metadata, without actually writing to disk.
+   *
+   * @param {Record<string, any>} stubData - The data to use for stub preparation
+   */
+  prepare(stubData: Record<string, any>): Promise<PreparedStub>;
+  /**
+   * Generates the final resource file by processing the stub template
+   * and writing the result to disk, with support for force overwrite.
+   *
+   * @param {Record<string, any>} stubData - The data to use for stub generation
+   */
+  generate(stubData: Record<string, any>): Promise<GeneratedStub>;
+}
+//#endregion
+//#region node_modules/@adonisjs/application/build/src/stubs/manager.d.ts
+/**
+ * StubsManager handles reading, copying, and building stubs from various sources.
+ * Stubs are template files used for code generation in AdonisJS applications.
+ *
+ * The manager can source stubs from:
+ * - Application's local stubs directory (publishTarget)
+ * - Custom file system paths
+ * - Package exports with stubsRoot
+ *
+ * @example
+ * const stubsManager = new StubsManager(app, '/path/to/stubs')
+ * const stub = await stubsManager.build('controller.stub')
+ * const files = await stubsManager.copy('models', { pkg: '@adonisjs/lucid' })
+ */
+declare class StubsManager {
+  #private;
+  /**
+   * Creates a new StubsManager instance.
+   *
+   * @param {Application<any>} app - The application instance
+   * @param {string} publishTarget - Absolute directory path where stubs should be published
+   */
+  constructor(app: Application<any>, publishTarget: string);
+  /**
+   * Creates a Stub instance by locating and loading a stub file.
+   * Searches in publishTarget first, then optional source or package locations.
+   *
+   * @param {string} stubName - Name of the stub file to build (e.g., 'controller.stub')
+   * @param {Object} [options] - Optional configuration for stub source
+   * @param {string} [options.source] - Custom file system path to search for stubs
+   * @param {string} [options.pkg] - Package name to source stubs from
+   * @returns {Promise<Stub>} Promise that resolves to a Stub instance
+   * @throws {RuntimeException} When stub file cannot be found in any source
+   */
+  build(stubName: string, options?: {
+    source?: string;
+    pkg?: string;
+  }): Promise<Stub>;
+  /**
+   * Copies stub files from a source location to the publish target directory.
+   * Can copy individual files or entire directories recursively.
+   *
+   * @param {string} stubPath - Relative path to the stub file or directory to copy
+   * @param {Object} options - Copy configuration options
+   * @param {boolean} [options.overwrite] - Whether to overwrite existing files
+   * @param {string} [options.source] - Source file system path (mutually exclusive with pkg)
+   * @param {string} [options.pkg] - Package name to copy from (mutually exclusive with source)
+   * @returns {Promise<string[]>} Promise that resolves to an array of copied file paths
+   * @throws {Error} When source path cannot be found
+   */
+  copy(stubPath: string, options: {
+    overwrite?: boolean;
+  } & ({
+    source: string;
+  } | {
+    pkg: string;
+  })): Promise<string[]>;
+}
+//#endregion
+//#region node_modules/@poppinss/exception/build/src/exception.d.ts
+/**
+ * Create a custom error class with the ability to define the error
+ * code, status, and the help text.
+ *
+ * ```js
+ * export class FileNotFoundException extends Exception {
+ *   static status = 500
+ *   static code = 'E_FILE_NOT_FOUND'
+ * }
+ *
+ * throw new FileNotFoundException(
+ *  `Unable to find file from ${filePath} location`
+ * )
+ * ```
+ */
+declare class Exception extends Error {
+  /**
+   * Define the error metadata as static properties to avoid
+   * setting them repeatedly on the error instance
+   */
+  static help?: string;
+  static code?: string;
+  static status?: number;
+  static message?: string;
+  /**
+   * Name of the class that raised the exception.
+   */
+  name: string;
+  /**
+   * Optional help description for the error. You can use it to define additional
+   * human readable information for the error.
+   */
+  help?: string;
+  /**
+   * A machine readable error code. This will allow the error handling logic
+   * to narrow down exceptions based upon the error code.
+   */
+  code?: string;
+  /**
+   * A status code for the error. Usually helpful when converting errors
+   * to HTTP responses.
+   */
+  status: number;
+  constructor(message?: string, options?: ErrorOptions & {
+    code?: string;
+    status?: number;
+  });
+  get [Symbol.toStringTag](): string;
+  toString(): string;
+}
+declare class InvalidArgumentsException extends Exception {
+  static code: string;
+  static status: number;
+}
+declare class RuntimeException extends Exception {
+  static code: string;
+  static status: number;
+}
+/**
+ * Helper to create an anonymous error class.
+ *
+ * ```ts
+ *
+ * const E_RESOURCE_NOT_FOUND = createError<[number]>(
+ *   'Unable to find resource with id %d',
+ *   'E_RESOURCE_NOT_FOUND'
+ * )
+ * const id = 1
+ * throw new E_RESOURCE_NOT_FOUND([id])
+ *```
+ */
+declare function createError<T extends any[] = never>(message: string, code: string, status?: number): typeof Exception & T extends never ? {
+  new (args?: any, options?: ErrorOptions): Exception;
+} : {
+  new (args: T, options?: ErrorOptions): Exception;
+};
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/resolver.d.ts
+/**
+ * Container resolver exposes the APIs to resolve bindings. You can think
+ * of resolver as an isolated container instance, with only the APIs
+ * to resolve bindings.
+ *
+ * ```ts
+ * const container = new Container()
+ * const resolver = container.createResolver()
+ *
+ * await resolver.make(BINDING_NAME)
+ * await resolver.make(CLASS_CONSTRUCTOR)
+ * ```
+ */
+declare class ContainerResolver<KnownBindings extends Record<any, any>> {
+  #private;
+  /**
+   * Initialize the container resolver with container bindings and options
+   *
+   * @param container - Object containing all container bindings, values, swaps, hooks, and aliases
+   * @param options - Container configuration options
+   */
+  constructor(container: {
+    bindings: Bindings;
+    bindingValues: BindingValues;
+    swaps: Swaps;
+    hooks: Hooks;
+    aliases: Map<Partial<keyof KnownBindings>, keyof KnownBindings | AbstractConstructor<any>>;
+    contextualBindings: Map<Constructor<any>, ContextualBindings>;
+  }, options: ContainerOptions);
+  /**
+   * Find if the resolver has a binding registered using the
+   * "bind", the "singleton", or the "bindValue" methods.
+   *
+   * @param binding - The binding key to check for
+   *
+   * @example
+   * ```ts
+   * resolver.hasBinding('route')
+   * resolver.hasBinding(Route)
+   * ```
+   */
+  hasBinding<Binding extends keyof KnownBindings>(binding: Binding): boolean;
+  hasBinding(binding: BindingKey): boolean;
+  /**
+   * Find if the resolver has all the bindings registered using the
+   * "bind", the "singleton", or the "bindValue" methods.
+   *
+   * @param bindings - Array of binding keys to check for
+   *
+   * @example
+   * ```ts
+   * resolver.hasAllBindings(['route', 'encryption'])
+   * resolver.hasAllBindings([Route, Encryption])
+   * ```
+   */
+  hasAllBindings<Binding extends keyof KnownBindings>(bindings: Binding[]): boolean;
+  hasAllBindings(bindings: BindingKey[]): boolean;
+  /**
+   * Resolves binding in context of a parent. The method is same as
+   * the "make" method, but instead takes a parent class
+   * constructor. This is used internally for dependency resolution.
+   *
+   * @param parent - The parent class requesting the binding
+   * @param binding - The binding to resolve
+   * @param runtimeValues - Optional runtime values for dependencies
+   * @param createError - Error creator function
+   *
+   * @example
+   * ```ts
+   * const db = await resolver.resolveFor(UsersController, Database)
+   * ```
+   */
+  resolveFor<Binding>(parent: unknown, binding: Binding, runtimeValues?: any[], createError?: ErrorCreator): Promise<Make<Binding>>;
+  /**
+   * Resolves the binding or constructor a class instance as follows.
+   *
+   * - Resolve the binding from the values (if registered)
+   * - Resolve the binding from the bindings (if registered)
+   * - If binding is a class, then create a instance of it. The constructor
+   *   dependencies are further resolved as well.
+   * - All other values are returned as it is.
+   *
+   * @param binding - The binding key or class constructor to resolve
+   * @param runtimeValues - Optional runtime values for dependencies
+   * @param createError - Error creator function
+   *
+   * @example
+   * ```ts
+   * await resolver.make('route')
+   * await resolver.make(Database)
+   * await resolver.make(UsersController, [request, response])
+   * ```
+   */
+  make<Binding extends keyof KnownBindings>(binding: Binding, runtimeValues?: any[], createError?: ErrorCreator): Promise<Binding extends string | symbol ? KnownBindings[Binding] : Make<Binding>>;
+  make<Binding>(binding: Binding, runtimeValues?: any[], createError?: ErrorCreator): Promise<Make<Binding>>;
+  /**
+   * Call a method on an object by injecting its dependencies. The method
+   * dependencies are resolved in the same manner as a class constructor
+   * dependencies.
+   *
+   * @param value - The object instance containing the method
+   * @param method - The method name to call
+   * @param runtimeValues - Optional runtime values for method dependencies
+   * @param createError - Error creator function
+   *
+   * @example
+   * ```ts
+   * const controller = await resolver.make(UsersController)
+   * await resolver.call(controller, 'index')
+   * ```
+   */
+  call<Value extends Record<any, any>, Method extends ExtractFunctions<Value>>(value: Value, method: Method, runtimeValues?: any[], createError?: ErrorCreator): Promise<ReturnType<Value[Method]>>;
+  /**
+   * Register a binding as a value. Values bound to the resolver are
+   * isolated from the container and only available within this resolver instance.
+   *
+   * @param binding - The binding key (string, symbol, or class constructor)
+   * @param value - The pre-resolved value to bind
+   *
+   * @example
+   * ```ts
+   * const resolver = container.createResolver()
+   * resolver.bindValue(HttpContext, ctx)
+   * await resolver.make(UsersController) // Will receive the ctx
+   * ```
+   */
+  bindValue<Binding extends keyof KnownBindings>(
+  /**
+   * Need to narrow down the "Binding" for the case where "KnownBindings" are <any, any>
+   */
+
+  binding: Binding extends string | symbol ? Binding : never, value: KnownBindings[Binding]): void;
+  bindValue<Binding extends AbstractConstructor<any>>(binding: Binding, value: InstanceType<Binding>): void;
+}
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/types.d.ts
+/**
+ * A function to create custom errors when container fails. It can be
+ * used to point errors to the original source
+ *
+ * @param message - The error message to use
+ * @returns Exception instance
+ */
+type ErrorCreator = (message: string) => Exception;
+/**
+ * Shape of a class constructor with injections
+ *
+ * @template T - The constructor type
+ */
+type InspectableConstructor = Function & {
+  containerInjections?: Record<string | number | symbol, {
+    dependencies: any[];
+    createError?: ErrorCreator;
+  }>;
+  containerProvider?: ContainerProvider;
+};
+/**
+ * Returns the inferred value for the make method
+ *
+ * @template T - The type to infer from
+ */
+type Make<T> = T extends AbstractConstructor<infer A> ? A : never;
+/**
+ * Accepted values for the binding key
+ *
+ * Can be a string, symbol, or abstract constructor
+ */
+type BindingKey = string | symbol | AbstractConstructor<any>;
+/**
+ * Shape of the binding resolver
+ *
+ * @template KnownBindings - Known bindings record type
+ * @template Value - The resolved value type
+ * @param resolver - Container resolver instance
+ * @param runtimeValues - Optional runtime values
+ * @returns The resolved value or promise of resolved value
+ */
+type BindingResolver<KnownBindings extends Record<any, any>, Value> = (resolver: ContainerResolver<KnownBindings>, runtimeValues?: any[]) => Value | Promise<Value>;
+/**
+ * Shape of the registered bindings
+ *
+ * Map structure containing binding keys and their resolver configurations
+ */
+type Bindings = Map<BindingKey, {
+  resolver: BindingResolver<Record<any, any>, any>;
+  isSingleton: false;
+} | {
+  resolver: (containerResolver: ContainerResolver<Record<any, any>>, runtimeValues?: any[]) => Promise<{
+    value: any;
+    cached: boolean;
+  }>;
+  isSingleton: true;
+  hooksPromise?: Promise<void>;
+}>;
+/**
+ * Shape of the registered contextual bindings
+ *
+ * Map structure for contextual binding resolvers
+ */
+type ContextualBindings = Map<AbstractConstructor<any>, {
+  resolver: BindingResolver<Record<any, any>, any>;
+}>;
+/**
+ * Shape of the registered swaps
+ *
+ * Map structure for binding swaps during testing
+ */
+type Swaps = Map<AbstractConstructor<any>, BindingResolver<Record<any, any>, any>>;
+/**
+ * Shape of the registered binding values
+ *
+ * Map structure containing cached binding values
+ */
+type BindingValues = Map<BindingKey, any>;
+/**
+ * The data emitted by the `container_binding:resolved` event. If known bindings
+ * are defined, then the bindings and values will be correctly
+ * inferred.
+ *
+ * @template KnownBindings - Known bindings record type
+ */
+type ContainerResolveEventData<KnownBindings> = {
+  binding: AbstractConstructor<unknown>;
+  value: unknown;
+} | { [K in keyof KnownBindings]: {
+  binding: K;
+  value: KnownBindings[K];
+} }[keyof KnownBindings];
+/**
+ * Shape of the hooks callback
+ *
+ * @template KnownBindings - Known bindings record type
+ * @template Value - The resolved value type
+ * @param value - The resolved value
+ * @param resolver - Container resolver instance
+ * @returns Void or promise of void
+ */
+type HookCallback<KnownBindings extends Record<any, any>, Value> = (value: Value, resolver: ContainerResolver<KnownBindings>) => void | Promise<void>;
+/**
+ * Hooks can be registered for all the supported binding datatypes.
+ *
+ * Map structure containing binding keys and their associated hook callbacks
+ */
+type Hooks = Map<BindingKey, Set<HookCallback<any, any>>>;
+/**
+ * The default implementation of the container
+ * provider.
+ *
+ * @param binding - The inspectable constructor
+ * @param property - The property key
+ * @param resolver - Container resolver instance
+ * @param runtimeValues - Optional runtime values
+ * @returns Promise of dependency array
+ */
+type DefaultContainerProvider = (binding: InspectableConstructor, property: string | symbol | number, resolver: ContainerResolver<any>, runtimeValues?: any[]) => Promise<any[]>;
+/**
+ * The container provider to discover and build dependencies
+ * for the constructor or the class method.
+ *
+ * @param binding - The inspectable constructor
+ * @param property - The property key
+ * @param resolver - Container resolver instance
+ * @param defaultProvider - Default container provider
+ * @param runtimeValues - Optional runtime values
+ * @returns Promise of dependency array
+ */
+type ContainerProvider = (binding: InspectableConstructor, property: string | symbol | number, resolver: ContainerResolver<any>, defaultProvider: DefaultContainerProvider, runtimeValues?: any[]) => Promise<any[]>;
+/**
+ * Options accepted by the container class
+ *
+ * @property emitter - Optional event emitter for container events
+ */
+type ContainerOptions = {
+  emitter?: {
+    emit(event: string | symbol, ...values: any[]): any;
+  };
+};
+/**
+ * The shape of the function that imports a module expression and runs
+ * it using the container
+ *
+ * @template T - The module type
+ * @template Args - Function arguments type
+ * @param resolver - Container resolver or container instance
+ * @param args - Function arguments
+ * @returns Promise of any value
+ */
+type ModuleCallable<T, Args extends any[]> = T extends undefined ? (resolver: ContainerResolver<any> | Container<any>, ...args: Args) => Promise<any> : (...args: Args) => Promise<any>;
+/**
+ * The shape of the handle method object that imports a module expression
+ * and runs it using the container
+ *
+ * @template T - The module type
+ * @template Args - Handler arguments type
+ * @property name - Optional handler name
+ * @property handle - Handler function
+ */
+type ModuleHandler<T, Args extends any[]> = T extends undefined ? {
+  name?: string;
+  handle(resolver: ContainerResolver<any> | Container<any>, ...args: Args): Promise<any>;
+} : {
+  name?: string;
+  handle(...args: Args): Promise<any>;
+};
+/**
+ * Data shared with the container.make tracing channel
+ *
+ * @property binding - The binding being resolved (constructor, string, or symbol)
+ */
+type ContainerMakeTracingData = {
+  binding: AbstractConstructor<any> | string | symbol;
+};
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/contextual_bindings_builder.d.ts
+/**
+ * A fluent builder to register contextual bindings with the
+ * container.
+ */
+declare class ContextBindingsBuilder<KnownBindings extends Record<any, any>, PinnedBinding extends AbstractConstructor<any>> {
+  #private;
+  /**
+   * Initialize the contextual bindings builder
+   *
+   * @param parent - The parent class constructor for the contextual binding
+   * @param container - The container instance to register bindings with
+   */
+  constructor(parent: Constructor<any>, container: Container<KnownBindings>);
+  /**
+   * Specify the binding for which to register a custom
+   * resolver.
+   *
+   * @param binding - The dependency class that the parent asks for
+   *
+   * @example
+   * ```ts
+   * container
+   *   .when(UsersController)
+   *   .asksFor(Hash)
+   *   .provide(() => new Argon2())
+   * ```
+   */
+  asksFor<Binding extends PinnedBinding>(binding: Binding): ContextBindingsBuilder<KnownBindings, Binding>;
+  /**
+   * Provide a resolver to resolve the parent dependency
+   *
+   * @param resolver - Factory function that returns the contextual implementation
+   *
+   * @example
+   * ```ts
+   * container
+   *   .when(UsersController)
+   *   .asksFor(Hash)
+   *   .provide(() => new Argon2())
+   * ```
+   */
+  provide(resolver: BindingResolver<KnownBindings, Make<PinnedBinding>>): void;
+}
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/container.d.ts
+/**
+ * The container class exposes the API to register bindings, values
+ * and resolve them.
+ *
+ * Known bindings types can be defined at the time of the constructing
+ * the container.
+ *
+ * ```ts
+ * new Container<{ 'route': Route, encryption: Encryption }>()
+ * ```
+ *
+ * You can resolve bindings and construct classes as follows
+ *
+ * ```ts
+ * await container.make(BINDING_NAME)
+ * await container.make(CLASS_CONSTRUCTOR)
+ * ```
+ */
+declare class Container<KnownBindings extends Record<any, any>> {
+  #private;
+  /**
+   * Initialize the container with optional configuration
+   *
+   * @param options - Optional container configuration including event emitter
+   *
+   * @example
+   * ```ts
+   * const container = new Container()
+   * ```
+   *
+   * @example
+   * ```ts
+   * const container = new Container<{
+   *   route: Route
+   *   encryption: Encryption
+   * }>({ emitter: eventEmitter })
+   * ```
+   */
+  constructor(options?: ContainerOptions);
+  /**
+   * Define an emitter instance to use for container events
+   *
+   * @param emitter - Event emitter instance that implements emit method
+   *
+   * @example
+   * ```ts
+   * const container = new Container()
+   * container.useEmitter(eventEmitter)
+   * ```
+   */
+  useEmitter(emitter: Exclude<ContainerOptions['emitter'], undefined>): this;
+  /**
+   * Create a container resolver to resolve bindings, or make classes.
+   *
+   * ```ts
+   * const resolver = container.createResolver()
+   * await resolver.make(CLASS_CONSTRUCTOR)
+   * ```
+   *
+   * Bind values with the resolver. Resolver values are isolated from the
+   * container.
+   *
+   * ```ts
+   * resolver.bindValue(HttpContext, new HttpContext())
+   * await resolver.make(UsersController)
+   * ```
+   *
+   * @returns A new container resolver instance
+   */
+  createResolver(): ContainerResolver<KnownBindings>;
+  /**
+   * Find if the container has a binding registered using the
+   * "bind", the "singleton", or the "bindValue" methods.
+   *
+   * @param binding - The binding key to check for
+   *
+   * @example
+   * ```ts
+   * container.hasBinding('route')
+   * container.hasBinding(Route)
+   * ```
+   */
+  hasBinding<Binding extends keyof KnownBindings>(binding: Binding): boolean;
+  hasBinding(binding: BindingKey): boolean;
+  /**
+   * Find if the container has all the bindings registered using the
+   * "bind", the "singleton", or the "bindValue" methods.
+   *
+   * @param bindings - Array of binding keys to check for
+   *
+   * @example
+   * ```ts
+   * container.hasAllBindings(['route', 'encryption'])
+   * container.hasAllBindings([Route, Encryption])
+   * ```
+   */
+  hasAllBindings<Binding extends keyof KnownBindings>(bindings: Binding[]): boolean;
+  hasAllBindings(binding: BindingKey[]): boolean;
+  /**
+   * Resolves the binding or constructor a class instance as follows.
+   *
+   * - Resolve the binding from the values (if registered)
+   * - Resolve the binding from the bindings (if registered)
+   * - If binding is a class, then create a instance of it. The constructor
+   *   dependencies are further resolved as well.
+   * - All other values are returned as it is.
+   *
+   * @param binding - The binding key or class constructor to resolve
+   * @param runtimeValues - Optional array of runtime values for constructor dependencies
+   * @param createError - Optional custom error creator function
+   *
+   * @example
+   * ```ts
+   * await container.make('route')
+   * await container.make(Database)
+   * await container.make(UsersController, [request, response])
+   * ```
+   */
+  make<Binding extends keyof KnownBindings>(binding: Binding, runtimeValues?: any[], createError?: ErrorCreator): Promise<Binding extends string | symbol ? KnownBindings[Binding] : Make<Binding>>;
+  make<Binding>(binding: Binding, runtimeValues?: any[], createError?: ErrorCreator): Promise<Make<Binding>>;
+  /**
+   * Call a method on an object by injecting its dependencies. The method
+   * dependencies are resolved in the same manner as a class constructor
+   * dependencies.
+   *
+   * @param value - The object instance containing the method
+   * @param method - The method name to call
+   * @param runtimeValues - Optional array of runtime values for method dependencies
+   * @param createError - Optional custom error creator function
+   *
+   * @example
+   * ```ts
+   * const controller = await container.make(UsersController)
+   * await container.call(controller, 'index')
+   * ```
+   */
+  call<Value extends Record<any, any>, Method extends ExtractFunctions<Value>>(value: Value, method: Method, runtimeValues?: any[], createError?: ErrorCreator): Promise<ReturnType<Value[Method]>>;
+  /**
+   * Register an alias for a binding. The value can be a reference
+   * to an existing binding or to a class constructor that will
+   * instantiate to the same value as the alias.
+   *
+   * @param alias - The alias name (must be string or symbol)
+   * @param value - The constructor or binding key this alias points to
+   *
+   * @example
+   * ```ts
+   * container.alias('db', Database)
+   * await container.make('db') // returns Database instance
+   * ```
+   */
+  alias<Alias extends keyof KnownBindings>(
+  /**
+   * An alias must always be defined as a string or a symbol. Classes cannot be
+   * aliases
+   */
+
+  alias: Alias extends string | symbol ? Alias : never,
+  /**
+   * The value should either be the constructor point to the alias value
+   * or reference to binding that has the same value as the alias
+   */
+
+  value: AbstractConstructor<KnownBindings[Alias]> | Exclude<{ [K in keyof KnownBindings]: KnownBindings[K] extends KnownBindings[Alias] ? K : never }[keyof KnownBindings], Alias>): void;
+  /**
+   * Register a binding inside the container. The method receives a
+   * key-value pair.
+   *
+   * - Key can be a string, symbol or a constructor.
+   * - The value is always a factory function to construct the dependency.
+   *
+   * @param binding - The binding key (string, symbol, or class constructor)
+   * @param resolver - Factory function that resolves the binding value
+   *
+   * @example
+   * ```ts
+   * container.bind('route', () => new Route())
+   * await container.make('route')
+   * ```
+   *
+   * @example
+   * ```ts
+   * container.bind(Route, () => new Route())
+   * await container.make(Route)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const routeSymbol = Symbol('route')
+   * container.bind(routeSymbol, () => new Route())
+   * await container.make(routeSymbol)
+   * ```
+   */
+  bind<Binding extends keyof KnownBindings>(
+  /**
+   * Need to narrow down the "Binding" for the case where "KnownBindings" are <any, any>
+   */
+
+  binding: Binding extends string | symbol ? Binding : never, resolver: BindingResolver<KnownBindings, KnownBindings[Binding]>): void;
+  bind<Binding extends AbstractConstructor<any>>(binding: Binding, resolver: BindingResolver<KnownBindings, InstanceType<Binding>>): void;
+  /**
+   * Register a binding as a value. Unlike bind() and singleton(), this
+   * method accepts the resolved value directly instead of a factory function.
+   *
+   * @param binding - The binding key (string, symbol, or class constructor)
+   * @param value - The pre-resolved value to bind
+   *
+   * @example
+   * ```ts
+   * const route = new Route()
+   * container.bindValue(Route, route)
+   * ```
+   *
+   * @example
+   * ```ts
+   * container.bindValue('config', { debug: true })
+   * ```
+   */
+  bindValue<Binding extends keyof KnownBindings>(
+  /**
+   * Need to narrow down the "Binding" for the case where "KnownBindings" are <any, any>
+   */
+
+  binding: Binding extends string | symbol ? Binding : never, value: KnownBindings[Binding]): void;
+  bindValue<Binding extends AbstractConstructor<any>>(binding: Binding, value: InstanceType<Binding>): void;
+  /**
+   * Register a binding as a singleton. The singleton method is same
+   * as the bind method, but the factory function is invoked
+   * only once and the result is cached for subsequent resolutions.
+   *
+   * @param binding - The binding key (string, symbol, or class constructor)
+   * @param resolver - Factory function that resolves the binding value
+   *
+   * @example
+   * ```ts
+   * container.singleton('route', () => new Route())
+   * await container.make('route')
+   * ```
+   *
+   * @example
+   * ```ts
+   * container.singleton(Route, () => new Route())
+   * await container.make(Route)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const routeSymbol = Symbol('route')
+   * container.singleton(routeSymbol, () => new Route())
+   * await container.make(routeSymbol)
+   * ```
+   */
+  singleton<Binding extends keyof KnownBindings>(
+  /**
+   * Need to narrow down the "Binding" for the case where "KnownBindings" are <any, any>
+   */
+
+  binding: Binding extends string | symbol ? Binding : never, resolver: BindingResolver<KnownBindings, KnownBindings[Binding]>): void;
+  singleton<Binding extends AbstractConstructor<any>>(binding: Binding, resolver: BindingResolver<KnownBindings, InstanceType<Binding>>): void;
+  /**
+   * Define a fake implementation for a binding or a class constructor.
+   * Swaps have the highest priority when resolving dependencies
+   * from the container. Useful for testing.
+   *
+   * @param binding - The class constructor to swap
+   * @param resolver - Factory function that returns the swapped implementation
+   *
+   * @example
+   * ```ts
+   * container.swap(Database, () => new MockDatabase())
+   * const db = await container.make(Database) // returns MockDatabase
+   * ```
+   */
+  swap<Binding extends AbstractConstructor<any>>(binding: Binding, resolver: BindingResolver<KnownBindings, InstanceType<Binding>>): void;
+  /**
+   * Restore binding by removing its swap
+   *
+   * @param binding - The class constructor to restore
+   *
+   * @example
+   * ```ts
+   * container.restore(Database)
+   * ```
+   */
+  restore(binding: AbstractConstructor<any>): void;
+  /**
+   * Restore mentioned or all bindings by removing their swaps
+   *
+   * @param bindings - Optional array of class constructors to restore. If not provided, all swaps are removed
+   *
+   * @example
+   * ```ts
+   * container.restoreAll([Database, Cache])
+   * ```
+   *
+   * @example
+   * ```ts
+   * container.restoreAll() // Restore all swaps
+   * ```
+   */
+  restoreAll(bindings?: AbstractConstructor<any>[]): void;
+  /**
+   * Define hooks to be executed after a binding has been resolved
+   * from the container.
+   *
+   * The hooks are executed for:
+   * - Bindings
+   * - Only once for singletons
+   * - Class constructors
+   *
+   * Hooks are not executed for direct values registered with the container.
+   *
+   * @param binding - The binding key or class constructor
+   * @param callback - Hook function to execute after resolution
+   *
+   * @example
+   * ```ts
+   * container.resolving('database', async (db, resolver) => {
+   *   await db.connect()
+   * })
+   * ```
+   *
+   * @example
+   * ```ts
+   * container.resolving(Database, async (db, resolver) => {
+   *   await db.connect()
+   * })
+   * ```
+   */
+  resolving<Binding extends keyof KnownBindings>(binding: Binding extends string | symbol ? Binding : never, callback: HookCallback<KnownBindings, KnownBindings[Binding]>): void;
+  resolving<Binding extends AbstractConstructor<any>>(binding: Binding, callback: HookCallback<KnownBindings, InstanceType<Binding>>): void;
+  /**
+   * Create a contextual builder to define contextual bindings.
+   * Contextual bindings allow you to specify different implementations
+   * for a dependency based on which class is asking for it.
+   *
+   * @param parent - The class constructor that will receive the contextual binding
+   *
+   * @example
+   * ```ts
+   * container
+   *   .when(UsersController)
+   *   .asksFor(Hash)
+   *   .provide(() => new Argon2())
+   * ```
+   */
+  when(parent: Constructor<any>): ContextBindingsBuilder<KnownBindings, AbstractConstructor<any>>;
+  /**
+   * Add a contextual binding for a given class constructor. A
+   * contextual binding takes a parent, parent's dependency and a callback
+   * to resolve the dependency.
+   *
+   * For example:
+   * - When "UsersController"
+   * - Asks for "Hash class"
+   * - Provide "Argon2" implementation
+   *
+   * @param parent - The class constructor that will receive the contextual binding
+   * @param binding - The dependency class that the parent asks for
+   * @param resolver - Factory function to resolve the contextual binding
+   *
+   * @example
+   * ```ts
+   * container.contextualBinding(
+   *   UsersController,
+   *   Hash,
+   *   () => new Argon2()
+   * )
+   * ```
+   */
+  contextualBinding<Binding extends AbstractConstructor<any>>(parent: Constructor<any>, binding: Binding, resolver: BindingResolver<KnownBindings, Make<Binding>>): void;
+}
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/decorators/inject.d.ts
+/**
+ * The "@inject" decorator uses Reflection to inspect the dependencies of a class
+ * or a method and defines them as metadata on the class for the container to
+ * discover them.
+ *
+ * @example
+ * ```ts
+ * @inject()
+ * class UsersController {
+ *   constructor(private database: Database) {}
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * class UsersController {
+ *   @inject()
+ *   async index(request: Request, response: Response) {
+ *     // Method with dependency injection
+ *   }
+ * }
+ * ```
+ */
+declare function inject(): {
+  <C extends Function>(target: C): void;
+  (target: any, propertyKey: string | symbol): void;
+};
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/module_caller.d.ts
+/**
+ * The moduleCaller works around a very specific pattern we use with
+ * AdonisJS, ie to construct classes and call methods using the
+ * container.
+ *
+ * For example: Controllers of AdonisJS allows defining a controller
+ * as follows
+ *
+ * Behind the scenes, we have to run following operations in order to call the
+ * method on the controller:
+ *
+ * - Create an instance of the controller class using the container.
+ * - Call the method using the container with dependency injection support.
+ *
+ * @param target - The class constructor to instantiate
+ * @param method - The method name to call on the instance
+ *
+ * @example
+ * ```ts
+ * route.get('/', [HomeController, 'index'])
+ * ```
+ *
+ * @example
+ * ```ts
+ * const callable = moduleCaller(HomeController, 'handle')
+ *   .toCallable(container)
+ *
+ * await callable(ctx)
+ * ```
+ */
+declare function moduleCaller(target: Constructor<any>, method: string): {
+  /**
+   * Converts the class reference to a callable function. Invoking this method
+   * internally creates a new instance of the class using the container and
+   * invokes the method using the container.
+   *
+   * You can create a callable function using the container instance as shown below
+   *
+   * ```ts
+   * const fn = moduleCaller(HomeController, 'handle')
+   *  .toCallable(container)
+   *
+   * // Call the function and pass context to it
+   * await fn(ctx)
+   * ```
+   *
+   * Another option is to not pass the container at the time of creating
+   * the callable function, but instead pass a resolver instance at
+   * the time of calling the function
+   *
+   * ```ts
+   * const fn = moduleCaller(HomeController, 'handle')
+   *  .toCallable()
+   *
+   * // Call the function and pass context to it
+   * const resolver = container.createResolver()
+   * await fn(resolver, ctx)
+   * ```
+   */
+  toCallable<T extends Container<any> | ContainerResolver<any> | undefined = undefined, Args extends any[] = any[]>(container?: T): ModuleCallable<T, Args>;
+  /**
+   * Converts the class reference to an object with handle method. Invoking this
+   * method internally creates a new instance of the class using the container
+   * and invokes the method using the container.
+   *
+   * You can create a handle method object using the container instance as shown below
+   *
+   * ```ts
+   * const handler = moduleCaller(HomeController, 'handle')
+   *  .toHandleMethod(container)
+   *
+   * // Call the function and pass context to it
+   * await handler.handle(ctx)
+   * ```
+   *
+   * Another option is to not pass the container at the time of creating
+   * the handle method object, but instead pass a resolver instance at
+   * the time of calling the function
+   *
+   * ```ts
+   * const handler = moduleCaller(HomeController, 'handle')
+   *  .toHandleMethod()
+   *
+   * // Call the function and pass context to it
+   * const resolver = container.createResolver()
+   * await handler.handle(resolver, ctx)
+   * ```
+   */
+  toHandleMethod<T extends Container<any> | ContainerResolver<any> | undefined = undefined, Args extends any[] = any[]>(container?: T): ModuleHandler<T, Args>;
+};
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/module_importer.d.ts
+/**
+ * The moduleImporter module works around a very specific pattern we use
+ * with AdonisJS, ie to lazy load modules by wrapping import calls inside
+ * a callback.
+ *
+ * For example: Middleware of AdonisJS allows registering middleware as an
+ * array of import calls.
+ *
+ * Behind the scenes, we have to run following operations in order to call the
+ * handle method on the defined middleware:
+ *
+ * - Lazily call the registered callbacks to import the middleware.
+ * - Check if the module has a default export.
+ * - Create an instance of the default export class using the container.
+ * - Call the `handle` method on the middleware class using the container.
+ *
+ * @param importFn - Function that returns a promise with the module's default export
+ * @param method - The method name to call on the imported class instance
+ *
+ * @example
+ * ```ts
+ * defineMiddleware([
+ *   () => import('#middleware/silent_auth')
+ * ])
+ * ```
+ *
+ * @example
+ * ```ts
+ * defineMiddleware({
+ *   auth: () => import('#middleware/auth')
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * const callable = moduleImporter(() => import('#middleware/auth'), 'handle')
+ *   .toCallable(container)
+ *
+ * await callable(ctx)
+ * ```
+ */
+declare function moduleImporter(importFn: () => Promise<{
+  default: Constructor<any>;
+}>, method: string): {
+  /**
+   * Converts the module import function to a callable function. Invoking this
+   * method run internally import the module, create a new instance of the
+   * default export class using the container and invokes the method using
+   * the container.
+   *
+   * You can create a callable function using the container instance as shown below
+   *
+   * ```ts
+   * const fn = moduleImporter(() => import('#middleware/auth_middleware'), 'handle')
+   *  .toCallable(container)
+   *
+   * // Call the function and pass context to it
+   * await fn(ctx)
+   * ```
+   *
+   * Another option is to not pass the container at the time of creating
+   * the callable function, but instead pass a resolver instance at
+   * the time of calling the function
+   *
+   * ```ts
+   * const fn = moduleImporter(() => import('#middleware/auth_middleware'), 'handle')
+   *  .toCallable()
+   *
+   * // Call the function and pass context to it
+   * const resolver = container.createResolver()
+   * await fn(resolver, ctx)
+   * ```
+   */
+  toCallable<T extends Container<any> | ContainerResolver<any> | undefined = undefined, Args extends any[] = any[]>(container?: T): ModuleCallable<T, Args>;
+  /**
+   * Converts the module import function to an object with handle method. Invoking the
+   * handle method run internally imports the module, create a new instance of
+   * the default export class using the container and invokes the method using
+   * the container.
+   *
+   * You can create a handle method object using the container instance as shown below
+   *
+   * ```ts
+   * const handler = moduleImporter(() => import('#middleware/auth_middleware'), 'handle')
+   *  .toHandleMethod(container)
+   *
+   * // Call the function and pass context to it
+   * await handler.handle(ctx)
+   * ```
+   *
+   * Another option is to not pass the container at the time of creating
+   * the handle method object, but instead pass a resolver instance at
+   * the time of calling the function
+   *
+   * ```ts
+   * const handler = moduleImporter(() => import('#middleware/auth_middleware'), 'handle')
+   *  .toHandleMethod()
+   *
+   * // Call the function and pass context to it
+   * const resolver = container.createResolver()
+   * await handler.handle(resolver, ctx)
+   * ```
+   */
+  toHandleMethod<T extends Container<any> | ContainerResolver<any> | undefined = undefined, Args extends any[] = any[]>(container?: T): ModuleHandler<T, Args>;
+};
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/module_expression.d.ts
+/**
+ * The moduleExpression module works around a very specific pattern we use
+ * with AdonisJS, ie to bind modules as string.
+ *
+ * For example: With the router of AdonisJS, we can bind a controller to a route
+ * as follows.
+ *
+ * Behind the scenes, we have to run following operations in order to call a
+ * method on the users_controller class:
+ *
+ * - Dynamic import `#controllers/users_controller` module
+ * - Check if the module has a default export.
+ * - Create an instance of the default export class using the container.
+ * - Call the `index` method on the controller class using the container.
+ *
+ * Router is just one example, we do this with event listeners, redis pub/sub
+ * and so on.
+ *
+ * So, instead of writing all this parsing logic, we encapsulate it inside the
+ * "moduleExpression" module.
+ *
+ * @param expression - The module expression string (e.g., '#controllers/users_controller.index')
+ * @param parentURL - The parent URL for resolving the module
+ *
+ * @example
+ * ```ts
+ * Route.get('users', '#controllers/users_controller.index')
+ * ```
+ *
+ * @example
+ * ```ts
+ * const callable = moduleExpression('#controllers/users_controller.index', import.meta.url)
+ *   .toCallable(container)
+ *
+ * await callable(ctx)
+ * ```
+ */
+declare function moduleExpression(expression: string, parentURL: URL | string): {
+  /**
+   * Parses a module expression to extract the module import path
+   * and the method to call on the default exported class.
+   *
+   * ```ts
+   * moduleExpression('#controllers/users_controller').parse()
+   * // ['#controllers/users_controller', 'handle']
+   * ```
+   *
+   * With method
+   * ```ts
+   * moduleExpression('#controllers/users_controller.index').parse()
+   * // ['#controllers/users_controller', 'index']
+   * ```
+   */
+  parse(): [string, string];
+  /**
+   * Converts the module expression to a callable function. Invoking this
+   * method run internally import the module, create a new instance of the
+   * default export class using the container and invokes the method using
+   * the container.
+   *
+   * You can create a callable function using the container instance as shown below
+   *
+   * ```ts
+   * const fn = moduleExpression('#controllers/users_controller.index')
+   *  .toCallable(container)
+   *
+   * // Call the function and pass context to it
+   * await fn(ctx)
+   * ```
+   *
+   * Another option is to not pass the container at the time of creating
+   * the callable function, but instead pass a resolver instance at
+   * the time of calling the function
+   *
+   * ```ts
+   * const fn = moduleExpression('#controllers/users_controller.index')
+   *  .toCallable()
+   *
+   * // Call the function and pass context to it
+   * const resolver = container.createResolver()
+   * await fn(resolver, ctx)
+   * ```
+   */
+  toCallable<T extends Container<any> | ContainerResolver<any> | undefined = undefined, Args extends any[] = any[]>(container?: T): ModuleCallable<T, Args>;
+  /**
+   * Converts the module expression to an object with handle method. Invoking the
+   * handle method run internally imports the module, create a new instance of
+   * the default export class using the container and invokes the method using
+   * the container.
+   *
+   * You can create a handle method object using the container instance as shown below
+   *
+   * ```ts
+   * const handler = moduleExpression('#controllers/users_controller.index')
+   *  .toHandleMethod(container)
+   *
+   * // Call the function and pass context to it
+   * await handler.handle(ctx)
+   * ```
+   *
+   * Another option is to not pass the container at the time of creating
+   * the handle method object, but instead pass a resolver instance at
+   * the time of calling the function
+   *
+   * ```ts
+   * const handler = moduleExpression('#controllers/users_controller.index')
+   *  .toHandleMethod()
+   *
+   * // Call the function and pass context to it
+   * const resolver = container.createResolver()
+   * await handler.handle(resolver, ctx)
+   * ```
+   */
+  toHandleMethod<T extends Container<any> | ContainerResolver<any> | undefined = undefined, Args extends any[] = any[]>(container?: T): ModuleHandler<T, Args>;
+};
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/parse_binding_reference.d.ts
+/**
+ * The "parseBindingReference" method is used to parse binding references
+ * similar to route controller binding value or event listener binding value.
+ *
+ * See the following examples to understand how this function works.
+ *
+ * ### Magic strings
+ * ```ts
+ * parseBindingReference('#controllers/home_controller')
+ * // returns { moduleNameOrPath: '#controllers/home_controller', method: 'handle' }
+ *
+ * parseBindingReference('#controllers/home_controller.index')
+ * // returns { moduleNameOrPath: '#controllers/home_controller', method: 'index' }
+ *
+ * parseBindingReference('#controllers/home.controller.index')
+ * // returns { moduleNameOrPath: '#controllers/home.controller', method: 'index' }
+ * ```
+ *
+ * ### Class reference
+ * ```ts
+ * class HomeController {}
+ *
+ * parseBindingReference([HomeController])
+ * // returns { moduleNameOrPath: 'HomeController', method: 'handle' }
+ *
+ * parseBindingReference([HomeController, 'index'])
+ * // returns { moduleNameOrPath: 'HomeController', method: 'index' }
+ * ```
+ *
+ * ### Lazy import reference
+ * ```ts
+ * const HomeController = () => import('#controllers/home_controller')
+ *
+ * parseBindingReference([HomeController])
+ * // returns { moduleNameOrPath: '#controllers/home_controller', method: 'handle' }
+ *
+ * parseBindingReference([HomeController, 'index'])
+ * // returns { moduleNameOrPath: 'controllers/home_controller', method: 'index' }
+ * ```
+ */
+declare function parseBindingReference(binding: string | [LazyImport<Constructor<any>> | Constructor<any>, any?]): Promise<{
+  moduleNameOrPath: string;
+  method: string;
+}>;
+//#endregion
+//#region node_modules/@adonisjs/fold/build/src/tracing_channels.d.ts
+/**
+ * Tracing channel for container.make method calls
+ *
+ * This channel emits events when the container resolves dependencies,
+ * providing data about the binding being resolved.
+ *
+ * @example
+ * ```ts
+ * containerMake.subscribe('start', (message) => {
+ *   console.log('Starting resolution for:', message.binding)
+ * })
+ * ```
+ */
+declare const containerMake: diagnostics_channel.TracingChannel<"adonisjs.container.make", ContainerMakeTracingData>;
+//#endregion
+//#region node_modules/@poppinss/macroable/build/index.d.ts
+/**
+ * Abstract class that adds capabilities for extending classes from outside-in,
+ * in the form of macros, instance properties, and getters.
+ *
+ * @example
+ * ```ts
+ * class User extends Macroable {
+ *   name: string
+ *   constructor(name: string) {
+ *     super()
+ *     this.name = name
+ *   }
+ * }
+ *
+ * // Add a macro
+ * User.macro('greet', function() {
+ *   return `Hello, ${this.name}`
+ * })
+ *
+ * // Add a getter
+ * User.getter('upperName', function() {
+ *   return this.name.toUpperCase()
+ * })
+ *
+ * const user = new User('John')
+ * user.greet() // "Hello, John"
+ * user.upperName // "JOHN"
+ * ```
+ */
+declare abstract class Macroable {
+  /**
+   * Set of instance properties that will be added to each instance during construction.
+   * Each entry contains a key and value pair representing the property name and its value.
+   */
+  protected static instanceMacros: Set<{
+    key: string | symbol | number;
+    value: unknown;
+  }>;
+  /**
+   * Adds a macro (property or method) to the class prototype.
+   * Macros are standard properties that get added to the class prototype,
+   * making them available on all instances of the class.
+   *
+   * @param name - The name of the property or method to add
+   * @param value - The value to assign to the property or method
+   *
+   * @example
+   * ```ts
+   * // Add a property macro
+   * MyClass.macro('version', '1.0.0')
+   *
+   * // Add a method macro
+   * MyClass.macro('greet', function() {
+   *   return 'Hello!'
+   * })
+   *
+   * const instance = new MyClass()
+   * instance.version // "1.0.0"
+   * instance.greet() // "Hello!"
+   * ```
+   */
+  static macro<T extends {
+    new (...args: any[]): any;
+  }, K extends keyof InstanceType<T>>(this: T, name: K, value: InstanceType<T>[K]): void;
+  /**
+   * Adds an instance property that will be assigned to each instance during construction.
+   * Unlike macros which are added to the prototype, instance properties are unique to each instance.
+   *
+   * @param name - The name of the property to add to instances
+   * @param value - The value to assign to the property on each instance
+   *
+   * @example
+   * ```ts
+   * // Add an instance method
+   * MyClass.instanceProperty('save', function() {
+   *   console.log('Saving...', this.id)
+   * })
+   *
+   * const { save } = new MyClass()
+   * save()
+   * ```
+   */
+  static instanceProperty<T extends {
+    new (...args: any[]): any;
+  }, K extends keyof InstanceType<T>>(this: T, name: K, value: InstanceType<T>[K]): void;
+  /**
+   * Adds a getter property to the class prototype using Object.defineProperty.
+   * Getters are computed properties that are evaluated each time they are accessed,
+   * unless the singleton flag is enabled.
+   *
+   * @param name - The name of the getter property
+   * @param accumulator - Function that computes and returns the property value
+   * @param singleton - If true, the getter value is cached after first access
+   *
+   * @example
+   * ```ts
+   * // Add a regular getter
+   * MyClass.getter('timestamp', function() {
+   *   return Date.now()
+   * })
+   *
+   * // Add a singleton getter (cached after first access)
+   * MyClass.getter('config', function() {
+   *   return loadConfig()
+   * }, true)
+   *
+   * const instance = new MyClass()
+   * instance.timestamp // Computed each time
+   * instance.config // Computed once, then cached
+   * ```
+   */
+  static getter<T extends {
+    new (...args: any[]): any;
+  }, K extends keyof InstanceType<T>>(this: T, name: K, accumulator: () => InstanceType<T>[K], singleton?: boolean): void;
+  /**
+   * Constructor that applies all registered instance properties to the new instance.
+   * This method iterates through the instanceMacros set and assigns each property
+   * to the instance, binding functions to the instance context.
+   */
+  constructor();
+}
+//#endregion
+//#region node_modules/@poppinss/hooks/build/src/runner.d.ts
+/**
+ * Runner allows running a set of specific hook handlers for a given
+ * event. You can grab the instance of the runner using the "hook.runner" method.
+ *
+ * ```ts
+ * const hooks = new Hooks()
+ *
+ * await hooks.runner('saving').run()
+ * ```
+ */
+declare class Runner<HookArgs extends any[], CleanUpArgs extends any[]> {
+  #private;
+  action: string;
+  /**
+   * Find if cleanup is pending or not
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('saving')
+   * await runner.run()
+   *
+   * if (runner.isCleanupPending) {
+   *   await runner.cleanup()
+   * }
+   * ```
+   */
+  get isCleanupPending(): boolean;
+  /**
+   * Create a new Runner instance
+   *
+   * @param action - The name of the event/action this runner handles
+   * @param hookHandlers - Optional set of hook handlers to initialize with
+   *
+   * @example
+   * ```ts
+   * const runner = new Runner('saving', new Set([handler1, handler2]))
+   * ```
+   */
+  constructor(action: string, hookHandlers?: Set<HookHandler<HookArgs, CleanUpArgs> | HookHandlerProvider<HookArgs, CleanUpArgs>>);
+  /**
+   * Ignore specific or all hook handlers. Calling this
+   * method multiple times will result in overwriting
+   * the existing state.
+   *
+   * @param handlersToIgnore - Array of handler names to ignore, or undefined to skip all hooks
+   *
+   * @example
+   * ```ts
+   * // Skip specific handlers
+   * runner.without(['hashPassword', 'validateEmail']).run()
+   *
+   * // Skip all handlers
+   * runner.without().run()
+   * ```
+   */
+  without(handlersToIgnore?: string[]): this;
+  /**
+   * Execute handlers
+   *
+   * @param data - Arguments to pass to the hook handlers
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('saving')
+   * await runner.run(user, { email: 'new@example.com' })
+   * ```
+   */
+  run(...data: HookArgs): Promise<void>;
+  /**
+   * Execute handlers in reverse order
+   *
+   * @param data - Arguments to pass to the hook handlers
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('deleting')
+   * await runner.runReverse(user)
+   * ```
+   */
+  runReverse(...data: HookArgs): Promise<void>;
+  /**
+   * Execute cleanup actions
+   *
+   * @param data - Arguments to pass to the cleanup handlers
+   *
+   * @example
+   * ```ts
+   * const runner = hooks.runner('saving')
+   * await runner.run(user)
+   *
+   * // Later, cleanup any resources
+   * await runner.cleanup(user)
+   * ```
+   */
+  cleanup(...data: CleanUpArgs): Promise<void>;
+}
+//#endregion
+//#region node_modules/@poppinss/hooks/build/src/types.d.ts
+/**
+ * Shape of the cleanup handler
+ */
+type CleanupHandler<Args extends any[]> = (...args: Args) => void | Promise<void>;
+/**
+ * Shape of the hook handler
+ */
+type HookHandler<Args extends any[], CleanUpArgs extends any[]> = (...args: Args) => void | CleanupHandler<CleanUpArgs> | Promise<void> | Promise<CleanupHandler<CleanUpArgs>>;
+/**
+ * Extracts args from a hook handler type
+ */
+type ExtractHookHandlerArgs<Handler> = Handler extends HookHandler<infer A, infer B> ? [A, B] : never;
+/**
+ * Hook represented as an object with handle method
+ */
+type HookHandlerProvider<Args extends any[], CleanUpArgs extends any[]> = {
+  name: string;
+  handle(event: string, ...args: Args): void | CleanupHandler<CleanUpArgs> | Promise<void> | Promise<CleanupHandler<CleanUpArgs>>;
+};
+//#endregion
+//#region node_modules/@adonisjs/application/build/src/feature_flags.d.ts
+/**
+ * A light weight implementation of feature flags to conditionally enable
+ * experimental and legacy features.
+ *
+ * @template FlagsList - Type definition for the feature flags object
+ *
+ * @example
+ * const flags = new FeatureFlags({ newUI: true, betaFeature: false })
+ * if (flags.enabled('newUI')) {
+ *   // Enable new UI
+ * }
+ *
+ * @example
+ * const dynamicFlags = new FeatureFlags(() => getConfigFlags())
+ * flags.when('betaFeature',
+ *   () => console.log('Beta enabled'),
+ *   () => console.log('Beta disabled')
+ * )
+ */
+declare class FeatureFlags<FlagsList extends Record<any, any>> {
+  #private;
+  /**
+   * Creates a new FeatureFlags instance
+   *
+   * @param flags - Either a static flags object or a factory function
+   */
+  constructor(flags: FlagsList | (() => FlagsList));
+  /**
+   * Checks if a feature is enabled
+   *
+   * @param feature - The feature name to check
+   * @returns boolean - True if the feature is enabled
+   */
+  enabled<Feature extends keyof FlagsList | (string & {})>(feature: Feature): boolean;
+  /**
+   * Checks if a feature is disabled
+   *
+   * @param feature - The feature name to check
+   * @returns boolean - True if the feature is disabled
+   */
+  disabled<Feature extends keyof FlagsList | (string & {})>(feature: Feature): boolean;
+  /**
+   * Checks if a feature exists in the flags
+   *
+   * @param feature - The feature name to check
+   * @returns boolean - True if the feature exists
+   */
+  has<Feature extends keyof FlagsList | (string & {})>(feature: Feature): boolean;
+  /**
+   * Conditionally executes callbacks based on feature flag state
+   *
+   * @param feature - The feature name to check
+   * @param enabledCallback - Callback to execute when feature is enabled
+   * @param disabledCallback - Optional callback to execute when feature is disabled
+   * @returns The result of the executed callback
+   */
+  when<Feature extends keyof FlagsList | (string & {}), EnabledResult, DisabledResult>(feature: Feature, enabledCallback: () => EnabledResult, disabledCallback?: () => DisabledResult): [never] extends DisabledResult ? EnabledResult | undefined : EnabledResult | DisabledResult;
+}
+//#endregion
+//#region node_modules/@adonisjs/application/build/src/application.d.ts
+/**
+ * Application class manages the state of an AdonisJS application. It includes:
+ *
+ * - Setting up the base features like importing config and setting up logger.
+ * - Parsing the "adonisrc.js" file
+ * - Setting up the IoC container
+ * - Registering and booting providers
+ * - Invoking lifecycle methods on the providers and hooks
+ *
+ * The Application class extends Macroable to allow runtime extension of functionality.
+ * It manages the entire lifecycle from creation to termination, providing hooks at
+ * each stage for customization.
+ *
+ * @template ContainerBindings - Type definition for IoC container bindings
+ * @extends {Macroable}
+ * @class Application
+ */
+declare class Application<ContainerBindings extends Record<any, any>> extends Macroable {
+  #private;
+  /**
+   * Stores metadata information about the application including
+   * app name, version, and AdonisJS version.
+   *
+   * @type {Map<string, any>}
+   */
+  info: Map<'appName' | 'version' | 'adonisVersion' | string, any>;
+  /**
+   * Returns the application name from the info map.
+   * Defaults to 'adonisjs_app' if not set.
+   *
+   * @readonly
+   * @type {string}
+   */
+  get appName(): any;
+  /**
+   * Returns the application version from the info map.
+   * Returns null if no version is set.
+   *
+   * @readonly
+   * @type {SemverNode | null}
+   */
+  get version(): SemverNode | null;
+  /**
+   * The parsed version for the "@adonisjs/core" package.
+   * Returns null if no version is available.
+   *
+   * @readonly
+   * @type {SemverNode | null}
+   */
+  get adonisVersion(): SemverNode | null;
+  /**
+   * The URL for the root of the application directory.
+   *
+   * @readonly
+   * @type {URL}
+   */
+  get appRoot(): URL;
+  /**
+   * A boolean to know if the application has been booted.
+   * Returns true when the application state is beyond 'initiated'.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get isBooted(): boolean;
+  /**
+   * A boolean to know if the application is ready and fully started.
+   * Returns true only when the application state is 'ready'.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get isReady(): boolean;
+  /**
+   * A boolean to know if the application has been terminated.
+   * Returns true only when the application state is 'terminated'.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get isTerminated(): boolean;
+  /**
+   * A boolean to know if the application is in the middle of
+   * the termination process but not yet fully terminated.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get isTerminating(): boolean;
+  /**
+   * Reference to the config instance. The value is available
+   * after the "init" method has been called.
+   *
+   * @readonly
+   * @type {any}
+   */
+  get config(): Config;
+  /**
+   * Reference to the parsed adonisrc.js file. The value is available
+   * after the "init" method has been called.
+   *
+   * @readonly
+   * @type {any}
+   */
+  get rcFile(): RcFile;
+  /**
+   * Normalized current NODE_ENV value. Converts common variations
+   * to standard values (development, production, test).
+   *
+   * @readonly
+   * @type {string}
+   */
+  get nodeEnvironment(): string;
+  /**
+   * Returns true when the NODE_ENV is set to 'production'.
+   * Useful for conditional logic based on production environment.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get inProduction(): boolean;
+  /**
+   * Returns true when the NODE_ENV is set to 'development'.
+   * Useful for enabling development-specific features.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get inDev(): boolean;
+  /**
+   * Returns true when the NODE_ENV is set to 'test'.
+   * Useful for enabling test-specific behavior.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get inTest(): boolean;
+  /**
+   * Returns true if the process is managed and running under PM2.
+   * Detected by checking for the pm2_id environment variable.
+   *
+   * @readonly
+   * @type {boolean}
+   */
+  get managedByPm2(): boolean;
+  /**
+   * Reference to scaffolding generators for creating application files.
+   * Provides utilities for generating controllers, models, migrations, etc.
+   *
+   * @readonly
+   * @type {any}
+   */
+  get generators(): {
+    singularControllerNames: string[];
+    entityPathSegment(segmentName: string): string;
+    createEntity(entityName: string): {
+      path: string;
+      name: string;
+    };
+    importPath(...paths: string[]): string;
+    tableName(entityName: string): string;
+    modelName(entityName: string): string;
+    modelFileName(entityName: string): string;
+    controllerName(entityName: string, singular?: boolean): string;
+    controllerFileName(entityName: string, singular?: boolean): string;
+    eventName(entityName: string): string;
+    eventFileName(entityName: string): string;
+    listenerName(entityName: string): string;
+    listenerFileName(entityName: string): string;
+    middlewareName(entityName: string): string;
+    middlewareFileName(entityName: string): string;
+    providerName(entityName: string): string;
+    providerFileName(entityName: string): string;
+    policyName(entityName: string): string;
+    policyFileName(entityName: string): string;
+    factoryName(entityName: string): string;
+    factoryFileName(entityName: string): string;
+    serviceName(entityName: string): string;
+    serviceFileName(entityName: string): string;
+    seederName(entityName: string): string;
+    seederFileName(entityName: string): string;
+    commandTerminalName(entityName: string): string;
+    commandName(entityName: string): string;
+    commandFileName(entityName: string): string;
+    validatorName(entityName: string): string;
+    validatorActionName(entityName: string, action: string): string;
+    validatorFileName(entityName: string): string;
+    exceptionName(entityName: string): string;
+    exceptionFileName(entityName: string): string;
+    mailerName(entityName: string, type?: "notification" | "provision"): string;
+    mailerFileName(entityName: string, type?: "notification" | "provision"): string;
+    mailName(entityName: string, type?: string): string;
+    mailFileName(entityName: string, type?: string): string;
+    testGroupName(entity: {
+      path: string;
+      name: string;
+    }): string;
+    testFileName(entityName: string): string;
+    viewFileName(entityName: string): string;
+    transformerName(entityName: string): string;
+    transformerFileName(entityName: string): string;
+    inertiaPageName(entityName: string): string;
+    inertiaPageFileName(entityName: string, extension: string): string;
+  };
+  /**
+   * Reference to the stubs module for scaffolding resources or ejecting stubs.
+   * Provides functionality to create and manage code generation templates.
+   *
+   * @type {Object}
+   * @property {Function} create - Factory function to create a StubsManager instance
+   */
+  stubs: {
+    create: () => Promise<StubsManager>;
+  };
+  /**
+   * Feature flags manager for checking the status of experimental features.
+   * Reads configuration from adonisrc.js experimental section.
+   *
+   * @type {FeatureFlags<ExperimentalFlagsList>}
+   */
+  experimentalFlags: FeatureFlags<ExperimentalFlagsList>;
+  /**
+   * Flag indicating if VineJS provider is configured and available.
+   * When true, the @vinejs/vine package can be safely imported.
+   *
+   * @type {boolean}
+   * @default false
+   */
+  usingVineJS: boolean;
+  /**
+   * Flag indicating if Edge template engine provider is configured.
+   * When true, the edge.js package can be safely imported.
+   *
+   * @type {boolean}
+   * @default false
+   */
+  usingEdgeJS: boolean;
+  /**
+   * Detects which AI coding agent the application is running under.
+   * Checks for environment variables set by different AI coding assistants:
+   * - CLAUDECODE='1' for Claude Code
+   * - GEMINI_CLI='1' for Gemini
+   * - GITHUB_COPILOT_CLI_MODE='1' for GitHub Copilot
+   * - WINDSURF_SESSION='1' or TERM_PROGRAM='windsurf' for Windsurf
+   * - CODEX_CLI='1' or CODEX_SANDBOX='1' for Codex
+   * - OPENCODE='1' for OpenCode
+   * - CURSOR_AGENT='1' for Cursor
+   *
+   * @readonly
+   * @type {'claude' | 'gemini' | 'copilot' | 'windsurf' | 'codex' | 'opencode' | 'cursor' | null}
+   * @returns The name of the detected AI agent, or null if none detected
+   */
+  get detectedAIAgent(): ("claude" | "cursor" | "opencode" | "gemini" | "copilot" | "windsurf" | "codex") | null;
+  /**
+   * Returns true if the application is running within any AI coding agent.
+   * This is a convenience getter that checks if detectedAIAgent is not null.
+   *
+   * @readonly
+   * @type {boolean}
+   * @returns True when running under an AI coding agent, false otherwise
+   */
+  get runningInAIAgent(): boolean;
+  /**
+   * Reference to the AdonisJS IoC container. The container manages
+   * dependency injection and service binding throughout the application.
+   * Available after the "init" method has been called.
+   *
+   * @type {Container<ContainerBindings>}
+   */
+  container: Container<ContainerBindings>;
+  /**
+   * Creates an instance of Application.
+   *
+   * @param {URL} appRoot - The root URL of the application
+   * @param {Object} options - Configuration options
+   * @param {AppEnvironments} options.environment - The application environment
+   * @param {Importer} [options.importer] - Optional module importer function
+   */
+  constructor(appRoot: URL, options: {
+    environment: AppEnvironments;
+    importer?: Importer;
+  });
+  /**
+   * The current environment in which the application is running
+   *
+   * @returns {AppEnvironments} The current application environment
+   */
+  getEnvironment(): AppEnvironments;
+  /**
+   * Switch the environment in which the app is running. The
+   * environment can only be changed before the app is booted.
+   *
+   * @param {AppEnvironments} environment - The new environment to set
+   * @returns {this} Returns the application instance for method chaining
+   * @throws {RuntimeException} When called after the app has been booted
+   */
+  setEnvironment(environment: AppEnvironments): this;
+  /**
+   * The current state of the application
+   *
+   * @returns {ApplicationStates} The current application state
+   */
+  getState(): ApplicationStates;
+  /**
+   * Specify the contents of the "adonisrc.js" file as
+   * an object. Calling this method will disable loading
+   * the "adonisrc.js" file from the disk.
+   *
+   * @param {Record<string, any>} value - The RC file contents as an object
+   * @returns {this} Returns the application instance for method chaining
+   */
+  rcContents(value: Record<string, any>): this;
+  /**
+   * Define the config values to use when booting the
+   * config provider. Calling this method disables
+   * reading files from the config directory.
+   *
+   * @param {Record<any, any>} values - The config values to use
+   * @returns {this} Returns the application instance for method chaining
+   */
+  useConfig(values: Record<any, any>): this;
+  /**
+   * Notify the parent process when the Node.js process is spawned with an IPC channel.
+   * The arguments accepted are same as "process.send"
+   *
+   * @param {any} message - The message to send to the parent process
+   * @param {any} [sendHandle] - Optional handle to send with the message
+   * @param {Object} [options] - Options for sending the message
+   * @param {boolean} [options.swallowErrors] - Whether to swallow errors
+   * @param {boolean} [options.keepOpen] - Whether to keep the connection open
+   * @param {function} [callback] - Callback function to handle send result
+   */
+  notify(message: any, sendHandle?: any, options?: {
+    swallowErrors?: boolean | undefined;
+    keepOpen?: boolean | undefined;
+  }, callback?: (error: Error | null) => void): void;
+  /**
+   * Listen for a process signal. This method is same as calling
+   * "process.on(signal)"
+   *
+   * @param {NodeJS.Signals} signal - The signal to listen for
+   * @param {NodeJS.SignalsListener} callback - The callback to execute when signal is received
+   * @returns {this} Returns the application instance for method chaining
+   */
+  listen(signal: NodeJS.Signals, callback: NodeJS.SignalsListener): this;
+  /**
+   * Listen for a process signal once. This method is same as calling
+   * "process.once(signal)"
+   *
+   * @param {NodeJS.Signals} signal - The signal to listen for
+   * @param {NodeJS.SignalsListener} callback - The callback to execute when signal is received
+   * @returns {this} Returns the application instance for method chaining
+   */
+  listenOnce(signal: NodeJS.Signals, callback: NodeJS.SignalsListener): this;
+  /**
+   * Listen for a process signal conditionally.
+   *
+   * @param {boolean} conditional - Whether to register the listener
+   * @param {NodeJS.Signals} signal - The signal to listen for
+   * @param {NodeJS.SignalsListener} callback - The callback to execute when signal is received
+   * @returns {this} Returns the application instance for method chaining
+   */
+  listenIf(conditional: boolean, signal: NodeJS.Signals, callback: NodeJS.SignalsListener): this;
+  /**
+   * Listen for a process signal once conditionally.
+   *
+   * @param {boolean} conditional - Whether to register the listener
+   * @param {NodeJS.Signals} signal - The signal to listen for
+   * @param {NodeJS.SignalsListener} callback - The callback to execute when signal is received
+   * @returns {this} Returns the application instance for method chaining
+   */
+  listenOnceIf(conditional: boolean, signal: NodeJS.Signals, callback: NodeJS.SignalsListener): this;
+  /**
+   * Register hooks that are called before the app starts
+   * the initiating process
+   *
+   * @param {HookHandler} handler - The hook handler function to register
+   * @returns {this} Returns the application instance for method chaining
+   */
+  initiating(handler: HookHandler<[Application<ContainerBindings>], [Application<ContainerBindings>]>): this;
+  /**
+   * Initiate the application. Calling this method performs following
+   * operations:
+   *
+   * - Parses the "adonisrc.js" file
+   * - Validate and set environment variables
+   * - Loads the application config from the configured config dir.
+   * - Configures the logger
+   * - Instantiates the IoC container
+   *
+   * @returns {Promise<void>} Promise that resolves when initiation is complete
+   */
+  init(): Promise<void>;
+  /**
+   * Register hooks that are called before the app boot
+   * process starts
+   *
+   * @param {HookHandler} handler - The hook handler function to register
+   * @returns {this} Returns the application instance for method chaining
+   */
+  booting(handler: HookHandler<[Application<ContainerBindings>], [Application<ContainerBindings>]>): this;
+  /**
+   * Boot the application. Calling this method performs the following
+   * operations:
+   *
+   * - Resolve providers and call the "register" method on them.
+   * - Call the "boot" method on providers
+   * - Run the "booted" hooks
+   *
+   * @returns {Promise<void>} Promise that resolves when boot is complete
+   */
+  boot(): Promise<void>;
+  /**
+   * Register a hook to get notified when the application has
+   * been booted.
+   *
+   * The hook will be called immediately if the app has already
+   * been booted.
+   *
+   * @param {HookHandler} handler - The hook handler function to register
+   * @returns {Promise<void>} Promise that resolves after the handler is executed
+   */
+  booted(handler: HookHandler<[Application<ContainerBindings>], [Application<ContainerBindings>]>): Promise<void>;
+  /**
+   * Register hooks that are called when the app is starting
+   *
+   * @param {HookHandler} handler - The hook handler function to register
+   * @returns {this} Returns the application instance for method chaining
+   */
+  starting(handler: HookHandler<[Application<ContainerBindings>], [Application<ContainerBindings>]>): this;
+  /**
+   * Start the application. Calling this method performs the following
+   * operations:
+   *
+   * - Run the "start" lifecycle hooks on all the providers
+   * - Start the application by invoking the supplied callback
+   * - Run the "ready" lifecycle hooks on all the providers
+   * - Run the "ready" application hooks
+   *
+   * @param {function} callback - The callback function to invoke when starting the app
+   * @returns {Promise<void>} Promise that resolves when start is complete
+   */
+  start(callback: (app: this) => void | Promise<void>): Promise<void>;
+  /**
+   * Register hooks that are called when the app is ready.
+   *
+   * The hook will be called immediately if the app is already ready.
+   *
+   * @param {HookHandler} handler - The hook handler function to register
+   * @returns {Promise<void>} Promise that resolves after the handler is executed
+   */
+  ready(handler: HookHandler<[Application<ContainerBindings>], [Application<ContainerBindings>]>): Promise<void>;
+  /**
+   * Register hooks that are called before the app is terminated.
+   *
+   * @param {HookHandler} handler - The hook handler function to register
+   * @returns {this} Returns the application instance for method chaining
+   */
+  terminating(handler: HookHandler<[Application<ContainerBindings>], [Application<ContainerBindings>]>): this;
+  /**
+   * Terminate application gracefully. Calling this method performs
+   * the following operations:
+   *
+   * - Run "shutdown" hooks on all the providers
+   * - Run "terminating" app lifecycle hooks
+   *
+   * @returns {Promise<void>} Promise that resolves when termination is complete
+   */
+  terminate(): Promise<void>;
+  /**
+   * Returns relative path to a file from the app root
+   *
+   * @param {string} absolutePath - The absolute path to convert
+   * @returns {string} The relative path from app root
+   */
+  relativePath(absolutePath: string): string;
+  /**
+   * Returns URL to a path from the application root.
+   *
+   * @param {...string} paths - Path segments to join
+   * @returns {URL} The constructed URL
+   */
+  makeURL(...paths: string[]): URL;
+  /**
+   * Returns file system path from the application root.
+   *
+   * @param {...string} paths - Path segments to join
+   * @returns {string} The constructed file system path
+   */
+  makePath(...paths: string[]): string;
+  /**
+   * Makes path to the config directory
+   *
+   * @param {...string} paths - Path segments to append to config directory
+   * @returns {string} The constructed config directory path
+   */
+  configPath(...paths: string[]): string;
+  /**
+   * Makes path to the public directory
+   *
+   * @param {...string} paths - Path segments to append to public directory
+   * @returns {string} The constructed public directory path
+   */
+  publicPath(...paths: string[]): string;
+  /**
+   * Makes path to the providers directory
+   *
+   * @param {...string} paths - Path segments to append to providers directory
+   * @returns {string} The constructed providers directory path
+   */
+  providersPath(...paths: string[]): string;
+  /**
+   * Makes path to the factories directory
+   *
+   * @param {...string} paths - Path segments to append to factories directory
+   * @returns {string} The constructed factories directory path
+   */
+  factoriesPath(...paths: string[]): string;
+  /**
+   * Makes path to the migrations directory
+   *
+   * @param {...string} paths - Path segments to append to migrations directory
+   * @returns {string} The constructed migrations directory path
+   */
+  migrationsPath(...paths: string[]): string;
+  /**
+   * Makes path to the seeders directory
+   *
+   * @param {...string} paths - Path segments to append to seeders directory
+   * @returns {string} The constructed seeders directory path
+   */
+  seedersPath(...paths: string[]): string;
+  /**
+   * Makes path to the language files directory
+   *
+   * @param {...string} paths - Path segments to append to language files directory
+   * @returns {string} The constructed language files directory path
+   */
+  languageFilesPath(...paths: string[]): string;
+  /**
+   * Makes path to the views directory
+   *
+   * @param {...string} paths - Path segments to append to views directory
+   * @returns {string} The constructed views directory path
+   */
+  viewsPath(...paths: string[]): string;
+  /**
+   * Makes path to the start directory
+   *
+   * @param {...string} paths - Path segments to append to start directory
+   * @returns {string} The constructed start directory path
+   */
+  startPath(...paths: string[]): string;
+  /**
+   * Makes path to the tmp directory
+   *
+   * @param {...string} paths - Path segments to append to tmp directory
+   * @returns {string} The constructed tmp directory path
+   */
+  tmpPath(...paths: string[]): string;
+  /**
+   * Makes path to the contracts directory
+   *
+   * @param {...string} paths - Path segments to append to contracts directory
+   * @returns {string} The constructed contracts directory path
+   * @deprecated Use "types" directory instead
+   */
+  contractsPath(...paths: string[]): string;
+  /**
+   * Makes path to the http controllers directory
+   *
+   * @param {...string} paths - Path segments to append to http controllers directory
+   * @returns {string} The constructed http controllers directory path
+   */
+  httpControllersPath(...paths: string[]): string;
+  /**
+   * Makes path to the models directory
+   *
+   * @param {...string} paths - Path segments to append to models directory
+   * @returns {string} The constructed models directory path
+   */
+  modelsPath(...paths: string[]): string;
+  /**
+   * Makes path to the services directory
+   *
+   * @param {...string} paths - Path segments to append to services directory
+   * @returns {string} The constructed services directory path
+   */
+  servicesPath(...paths: string[]): string;
+  /**
+   * Makes path to the exceptions directory
+   *
+   * @param {...string} paths - Path segments to append to exceptions directory
+   * @returns {string} The constructed exceptions directory path
+   */
+  exceptionsPath(...paths: string[]): string;
+  /**
+   * Makes path to the mailers directory
+   *
+   * @param {...string} paths - Path segments to append to mailers directory
+   * @returns {string} The constructed mailers directory path
+   */
+  mailersPath(...paths: string[]): string;
+  /**
+   * Makes path to the mails directory
+   *
+   * @param {...string} paths - Path segments to append to mails directory
+   * @returns {string} The constructed mails directory path
+   */
+  mailsPath(...paths: string[]): string;
+  /**
+   * Makes path to the middleware directory
+   *
+   * @param {...string} paths - Path segments to append to middleware directory
+   * @returns {string} The constructed middleware directory path
+   */
+  middlewarePath(...paths: string[]): string;
+  /**
+   * Makes path to the policies directory
+   *
+   * @param {...string} paths - Path segments to append to policies directory
+   * @returns {string} The constructed policies directory path
+   */
+  policiesPath(...paths: string[]): string;
+  /**
+   * Makes path to the validators directory
+   *
+   * @param {...string} paths - Path segments to append to validators directory
+   * @returns {string} The constructed validators directory path
+   */
+  validatorsPath(...paths: string[]): string;
+  /**
+   * Makes path to the commands directory
+   *
+   * @param {...string} paths - Path segments to append to commands directory
+   * @returns {string} The constructed commands directory path
+   */
+  commandsPath(...paths: string[]): string;
+  /**
+   * Makes path to the events directory
+   *
+   * @param {...string} paths - Path segments to append to events directory
+   * @returns {string} The constructed events directory path
+   */
+  eventsPath(...paths: string[]): string;
+  /**
+   * Makes path to the listeners directory
+   *
+   * @param {...string} paths - Path segments to append to listeners directory
+   * @returns {string} The constructed listeners directory path
+   */
+  listenersPath(...paths: string[]): string;
+  /**
+   * Makes path to the transformers directory
+   *
+   * @param {...string} paths - Path segments to append to transformers directory
+   * @returns {string} The constructed transformers directory path
+   */
+  transformersPath(...paths: string[]): string;
+  /**
+   * Makes path to the client directory for writing generated
+   * output
+   *
+   * @param {...string} paths - Path segments to append to events directory
+   * @returns {string} The constructed directory path
+   */
+  generatedClientPath(...paths: string[]): string;
+  /**
+   * Makes path to the server directory for writing generated
+   * output
+   *
+   * @param {...string} paths - Path segments to append to events directory
+   * @returns {string} The constructed directory path
+   */
+  generatedServerPath(...paths: string[]): string;
+  /**
+   * Import a module by identifier. This method uses the importer function
+   * defined at the time of creating the application instance and throws
+   * an error if no importer was defined.
+   *
+   * @param {string} moduleIdentifier - The module identifier to import
+   * @returns {any} The imported module
+   * @throws {RuntimeException} When no importer function is defined
+   */
+  import(moduleIdentifier: string): any;
+  /**
+   * Import a module by identifier and return its default export. This method uses the importer function
+   * defined at the time of creating the application instance and throws
+   * an error if no importer was defined.
+   *
+   * @template T - The type of the default export
+   * @param {string} moduleIdentifier - The module identifier to import
+   * @returns The default export of the imported module
+   * @throws {RuntimeException} When no importer function is defined
+   */
+  importDefault<T extends object>(moduleIdentifier: string): Promise<T extends {
+    default: infer A;
+  } ? A : never>;
+  /**
+   * JSON representation of the application
+   *
+   * @returns The application state as a JSON object
+   */
+  toJSON(): {
+    isReady: boolean;
+    isTerminating: boolean;
+    environment: AppEnvironments;
+    nodeEnvironment: string;
+    appName: any;
+    version: string | null;
+    adonisVersion: string | null;
+  };
+}
+//#endregion
+//#region node_modules/@adonisjs/application/build/src/types.d.ts
+/**
+ * Known application environments. The list is strictly limited to
+ * AdonisJS known environments and custom environments are not
+ * supported as of now.
+ *
+ * @example
+ * // Environment-specific behavior
+ * if (app.getEnvironment() === 'test') {
+ *   // Test-specific logic
+ * }
+ *
+ * - 'web' - HTTP server environment
+ * - 'console' - Command-line environment (ace commands)
+ * - 'test' - Testing environment
+ * - 'repl' - REPL environment
+ * - 'unknown' - Fallback for unrecognized environments
+ */
+type AppEnvironments = 'web' | 'console' | 'test' | 'repl' | 'unknown';
+/**
+ * Known application states.
+ *
+ * - 'created'      Creating an application class instance sets the state to 'created'.
+ *
+ * - 'initiated'    Calling `app.init()` method sets the state to 'initiated'.
+ *                  The rc file contents and environment variables are parsed during
+ *                  init phase.
+ *
+ * - 'booted'       Calling `app.boot()` method sets the state to `booted`. The service
+ *                  providers are registered and booted in this state.
+ *
+ * - 'ready'        Calling `app.start()` method sets the state to `ready`. A set of
+ *                  pre and post start operations inside this method.
+ *
+ *                  The service providers start methods are called during pre-start phase.
+ *                  The service providers shutdown and application terminating hooks are
+ *                  called during post-start phase.
+ *
+ * - 'terminated'   Calling `app.terminate' method sets the state to `terminated`. The service
+ *                  providers shutdown methods are called in this state.
+ */
+type ApplicationStates = 'created' | 'initiated' | 'booted' | 'ready' | 'terminated';
+/**
+ * State shared with hooks during application lifecycle.
+ * Represents the application instance parameters passed to hook functions.
+ *
+ * @template ContainerBindings - Type representing the container bindings
+ * @example
+ * // Hook function receiving application state
+ * function myHook(app: Application<ContainerBindings>) {
+ *   // Access application instance
+ * }
+ */
+type HooksState<ContainerBindings extends Record<any, any>> = [[Application<ContainerBindings>], [Application<ContainerBindings>]];
+/**
+ * Shape of directories object with known and unknown directories.
+ * Defines the standard directory structure for an AdonisJS application.
+ * Custom directories can be added via the index signature.
+ *
+ * @example
+ * const directories: DirectoriesNode = {
+ *   config: './config',
+ *   public: './public',
+ *   // ... other standard directories
+ *   customDir: './custom' // Custom directory
+ * }
+ */
+interface DirectoriesNode {
+  [key: string]: string;
+  config: string;
+  public: string;
+  contracts: string;
+  providers: string;
+  languageFiles: string;
+  migrations: string;
+  seeders: string;
+  factories: string;
+  views: string;
+  start: string;
+  tmp: string;
+  httpControllers: string;
+  models: string;
+  services: string;
+  exceptions: string;
+  mailers: string;
+  middleware: string;
+  policies: string;
+  validators: string;
+  commands: string;
+  events: string;
+  listeners: string;
+  transformers: string;
+  stubs: string;
+  generatedClient: string;
+  generatedServer: string;
+}
+/**
+ * To be extended by packages that want to introduce experimental flags.
+ * This interface can be augmented by packages to add their own experimental features.
+ *
+ * @example
+ * // In a package's types file:
+ * declare module '@adonisjs/application/types' {
+ *   interface ExperimentalFlagsList {
+ *     myExperimentalFeature: boolean
+ *   }
+ * }
+ */
+interface ExperimentalFlagsList {}
+/**
+ * Shape of preload files configuration.
+ * Preload files are automatically imported during application boot
+ * for specific environments.
+ *
+ * @example
+ * const preloadFile: PreloadNode = {
+ *   file: () => import('./start/routes.js'),
+ *   environment: ['web', 'console']
+ * }
+ */
+type PreloadNode = {
+  file: () => Promise<any>;
+  environment: Exclude<AppEnvironments, 'unknown'>[];
+};
+/**
+ * Shape of provider modules configuration.
+ * Providers are service containers that register bindings and boot
+ * application services for specific environments.
+ *
+ * @example
+ * const provider: ProviderNode = {
+ *   file: () => import('./providers/database_provider.js'),
+ *   environment: ['web', 'console']
+ * }
+ */
+type ProviderNode = {
+  file: () => Promise<{
+    default?: new (app: Application<any>) => ContainerProviderContract;
+  }>;
+  environment: Exclude<AppEnvironments, 'unknown'>[];
+};
+/**
+ * Shape of semantic version node.
+ * Represents a parsed semantic version with its components
+ * and utility methods.
+ *
+ * @example
+ * const version: SemverNode = {
+ *   major: 1,
+ *   minor: 2,
+ *   patch: 3,
+ *   prerelease: ['beta', 1],
+ *   version: '1.2.3-beta.1',
+ *   toString: () => '1.2.3-beta.1'
+ * }
+ */
+type SemverNode = {
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease: (string | number)[];
+  version: string;
+  toString(): string;
+};
+/**
+ * Shape of meta file configuration inside the `metaFiles` array
+ * in the `adonisrc.js` file.
+ * Meta files are watched for changes and can trigger server reloads.
+ *
+ * @example
+ * const metaFile: MetaFileNode = {
+ *   pattern: './config/**\/*.ts',
+ *   reloadServer: true // Reload server when files matching pattern change
+ * }
+ */
+type MetaFileNode = {
+  pattern: string;
+  reloadServer: boolean;
+};
+/**
+ * Shape of the adonisrc.js configuration file.
+ * This is the main configuration file that defines the application structure,
+ * providers, preloads, and other essential settings.
+ *
+ * @example
+ * const rcFile: RcFile = {
+ *   typescript: true,
+ *   directories: { ... },
+ *   providers: [...],
+ *   preloads: [...],
+ *   // ... other configurations
+ * }
+ */
+type RcFile = {
+  /**
+   * Indicates whether this is a TypeScript project.
+   */
+  typescript: boolean;
+  /**
+   * List of configured directories for the application.
+   * Combines standard AdonisJS directories with custom ones.
+   */
+  directories: DirectoriesNode & {
+    [key: string]: string;
+  };
+  /**
+   * Array of files to preload after the application has been booted.
+   * These files are automatically imported based on environment.
+   */
+  preloads: PreloadNode[];
+  /**
+   * Array of meta files to watch for changes.
+   * Used by development tools to trigger server reloads.
+   */
+  metaFiles: MetaFileNode[];
+  /**
+   * Providers to register in the IoC container.
+   * Providers are registered based on their environment configuration.
+   */
+  providers: ProviderNode[];
+  /**
+   * Array of Ace commands to register.
+   * Each entry is a function that imports a command class.
+   */
+  commands: (() => Promise<any>)[];
+  /**
+   * Custom aliases for Ace commands.
+   * Maps alias names to actual command names.
+   *
+   * @example
+   * { 'm:c': 'make:controller', 'serve': 'serve' }
+   */
+  commandsAliases: {
+    [key: string]: string;
+  };
+  /**
+   * Assembler hooks configuration for build processes.
+   * Hooks are executed during various build lifecycle events.
+   */
+  hooks: AssemblerRcFile['hooks'];
+  /**
+   * Test suites configuration for the application.
+   * Defines test files, directories, and execution settings.
+   */
+  tests: {
+    suites: {
+      name: string;
+      files: string | string[];
+      directories: string[];
+      timeout?: number;
+    }[];
+    forceExit: boolean;
+    timeout: number;
+  };
+  /**
+   * Reference to the raw contents of the `adonisrc.js` file.
+   * Contains the original, unprocessed configuration object.
+   */
+  raw: Record<string, any>;
+  /**
+   * Flags to enable experimental features.
+   * Can be extended by packages to add their own experimental options.
+   */
+  experimental: ExperimentalFlagsList;
+};
+/**
+ * Input shape for RcFile configuration.
+ * A partial version of RcFile used when creating or updating
+ * the application configuration. Includes preset functions for
+ * applying common configurations.
+ *
+ * @example
+ * const input: RcFileInput = {
+ *   typescript: true,
+ *   presets: [webPreset()],
+ *   directories: { controllers: './app/controllers' }
+ * }
+ */
+interface RcFileInput {
+  /**
+   * List of preset functions to apply to the configuration.
+   * Presets provide common configuration patterns.
+   */
+  presets?: PresetFn[];
+  typescript?: RcFile['typescript'];
+  directories?: Partial<DirectoriesNode> & {
+    [key: string]: string;
+  };
+  preloads?: (PreloadNode | PreloadNode['file'])[];
+  metaFiles?: string[] | RcFile['metaFiles'];
+  commands?: RcFile['commands'];
+  commandsAliases?: RcFile['commandsAliases'];
+  tests?: {
+    suites: {
+      name: string;
+      files: string | string[];
+      timeout?: number;
+    }[];
+    forceExit?: boolean;
+    timeout?: number;
+  };
+  providers?: (ProviderNode | ProviderNode['file'])[];
+  hooks?: RcFile['hooks'];
+  /**
+   * Optional flags to enable experimental features.
+   * Can be extended by packages to add their own experimental options.
+   */
+  experimental?: ExperimentalFlagsList;
+}
+/**
+ * RCFile after has been normalized by the RCManager. This file is
+ * shared with the presets
+ */
+type NormalizedRcFileInput = Prettify<Required<Omit<RcFileInput, 'directories'> & {
+  directories: RcFile['directories'];
+}>>;
+/**
+ * Contract for service provider classes.
+ * Service providers are used to register bindings in the IoC container
+ * and boot application services during different lifecycle phases.
+ *
+ * @example
+ * export default class MyProvider implements ContainerProviderContract {
+ *   register() {
+ *     this.app.container.singleton('myService', () => new MyService())
+ *   }
+ *
+ *   boot() {
+ *     // Boot logic
+ *   }
+ * }
+ */
+interface ContainerProviderContract {
+  /**
+   * The register method is called to register bindings in the IoC container.
+   * This is where you should bind services, singletons, and other dependencies.
+   */
+  register?(): void;
+  /**
+   * The boot method is called to boot application state.
+   * Use this method for registering macros, middleware, REPL bindings,
+   * and other application-level configurations.
+   */
+  boot?(): AsyncOrSync<void>;
+  /**
+   * The start method is called after all providers have been booted.
+   * This is the ideal place to use existing container bindings and
+   * perform startup operations that depend on other services.
+   */
+  start?(): AsyncOrSync<void>;
+  /**
+   * The ready method is called when the application is fully ready.
+   * For HTTP servers, this is called after the server starts listening.
+   * Preloaded files have been imported and the app is ready to serve requests.
+   */
+  ready?(): AsyncOrSync<void>;
+  /**
+   * The shutdown method is called during graceful application shutdown.
+   * Use this method to clean up resources, close connections, and perform
+   * other cleanup tasks. Avoid long-running operations to prevent forceful termination.
+   */
+  shutdown?(): AsyncOrSync<void>;
+}
+/**
+ * Function type for importing modules in the context of an AdonisJS application.
+ * This function is called whenever AdonisJS needs to import a module from a string identifier.
+ *
+ * @param moduleIdentifier - The module identifier or path to import
+ * @param options - Optional import call options
+ * @returns The imported module
+ *
+ * @example
+ * const importer: Importer = (id, options) => import(id)
+ */
+type Importer = (moduleIdentifier: string, options?: ImportCallOptions) => any;
+/**
+ * Type for AdonisRC preset functions.
+ * Preset functions are used to apply common configuration patterns
+ * to the RcFile configuration object.
+ *
+ * @param options - Object containing the RcFile to modify
+ *
+ * @example
+ * const webPreset: PresetFn = ({ rcFile }) => {
+ *   rcFile.providers.push(httpProvider)
+ *   rcFile.preloads.push(routesPreload)
+ * }
+ */
+type PresetFn = (options: {
+  rcFile: NormalizedRcFileInput;
+}) => void;
+/**
+ * Represents a prepared stub ready for file generation.
+ * Contains the rendered content and metadata extracted from the stub template,
+ * but has not yet been written to disk.
+ *
+ * @example
+ * const preparedStub: PreparedStub = {
+ *   contents: 'export class User {}',
+ *   destination: '/app/models/user.ts',
+ *   force: false,
+ *   attributes: { to: '/app/models/user.ts' }
+ * }
+ */
+type PreparedStub = {
+  /** The rendered contents of the stub template */contents: string; /** The absolute path where the file should be written */
+  destination: string; /** Whether to overwrite existing files */
+  force: boolean; /** Additional metadata exported from the stub template */
+  attributes: Record<string, any>;
+};
+/**
+ * Base type for generated stubs, excluding the 'force' property
+ * which is only relevant during preparation phase.
+ */
+type GeneratedStubBase = Omit<PreparedStub, 'force'>;
+/**
+ * Represents the result of stub generation after attempting to write to disk.
+ * Indicates whether the file was created, skipped, or force-created with reasons.
+ *
+ * @example
+ * // File created successfully
+ * const result: GeneratedStub = {
+ *   status: 'created',
+ *   skipReason: null,
+ *   contents: '...',
+ *   destination: '/path/to/file.ts',
+ *   attributes: {}
+ * }
+ *
+ * @example
+ * // File already exists and force was not enabled
+ * const result: GeneratedStub = {
+ *   status: 'skipped',
+ *   skipReason: 'File already exists',
+ *   contents: '...',
+ *   destination: '/path/to/file.ts',
+ *   attributes: {}
+ * }
+ */
+type GeneratedStub = (GeneratedStubBase & {
+  /** File generation was skipped */status: 'skipped'; /** Reason why the file was skipped */
+  skipReason: string;
+}) | (GeneratedStubBase & {
+  /** File was successfully created */status: 'created';
+  skipReason: null;
+}) | (GeneratedStubBase & {
+  /** File was overwritten because force option was enabled */status: 'force_created';
+  skipReason: null;
+});
+//#endregion
+//#region src/generators/base_generator.d.ts
+declare abstract class BaseGenerator {
+  protected app: ApplicationService;
+  protected logger: any;
+  protected manifest?: string[] | undefined;
+  protected forceOverwrite: boolean;
+  protected codemods: Codemods;
+  constructor(app: ApplicationService, logger: any, manifest?: string[] | undefined, codemods?: Codemods, forceOverwrite?: boolean);
+  protected generateStub(stubPath: string, stubState: any, customStubPath?: string): Promise<GeneratedStub>;
+  abstract generate(name: string, definition: any, ...args: any[]): Promise<void>;
+}
+//#endregion
+export { BaseGenerator as t };