@adonisjs/env 7.0.0-next.0 → 7.0.0-next.2

package/build/{chunk-EIJZNYI6.js → chunk-KE5AFOK2.js}

@@ -15,14 +15,29 @@ var debug_default = debuglog("adonisjs:env");
 
 // src/loader.ts
 var EnvLoader = class {
+  /**
+   * The application root directory path
+   */
   #appRoot;
+  /**
+   * Whether to load the .env.example file
+   */
   #loadExampleFile;
+  /**
+   * Creates a new EnvLoader instance
+   *
+   * @param appRoot - The application root directory as string or URL
+   * @param loadExampleFile - Whether to load .env.example file
+   */
   constructor(appRoot, loadExampleFile = false) {
     this.#appRoot = typeof appRoot === "string" ? appRoot : fileURLToPath(appRoot);
     this.#loadExampleFile = loadExampleFile;
   }
   /**
    * Optionally read a file from the disk
+   *
+   * @param filePath - Path to the file to read
+   * @returns Promise resolving to file existence status and contents
    */
   async #loadFile(filePath) {
     try {
@@ -38,6 +53,8 @@ var EnvLoader = class {
   /**
    * Load contents of the main dot-env file and the current
    * environment dot-env file
+   *
+   * @returns Promise resolving to array of loaded environment files
    */
   async load() {
     const ENV_PATH = process.env.ENV_PATH;

package/build/index.d.ts

@@ -1,5 +1,5 @@
-export { Env } from './src/env.js';
-export { EnvParser } from './src/parser.js';
-export { EnvLoader } from './src/loader.js';
-export * as errors from './src/errors.js';
-export { EnvProcessor } from './src/processor.js';
+export { Env } from './src/env.ts';
+export { EnvParser } from './src/parser.ts';
+export { EnvLoader } from './src/loader.ts';
+export * as errors from './src/errors.ts';
+export { EnvProcessor } from './src/processor.ts';

package/build/index.js

@@ -2,13 +2,12 @@ import {
   EnvLoader,
   __export,
   debug_default
-} from "./chunk-EIJZNYI6.js";
-
-// src/env.ts
-import { schema as envSchema } from "@poppinss/validator-lite";
+} from "./chunk-KE5AFOK2.js";
 
 // src/parser.ts
+import { readFile } from "fs/promises";
 import dotenv from "dotenv";
+import { RuntimeException } from "@poppinss/utils/exception";
 
 // src/errors.ts
 var errors_exports = {};
@@ -30,14 +29,53 @@ var E_IDENTIFIER_ALREADY_DEFINED = createError(
 
 // src/parser.ts
 var EnvParser = class _EnvParser {
+  /**
+   * Raw environment file contents
+   */
   #envContents;
+  /**
+   * Application root directory URL
+   */
+  #appRoot;
+  /**
+   * Whether to prefer process.env values over parsed values
+   */
   #preferProcessEnv = true;
-  static #identifiers = {};
-  constructor(envContents, options) {
+  /**
+   * Static collection of registered identifiers with their callbacks
+   */
+  static #identifiers = {
+    async file(value, key, appRoot) {
+      const filePath = new URL(value, appRoot);
+      try {
+        const contents = await readFile(filePath, "utf-8");
+        return contents;
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          throw new RuntimeException(
+            `Cannot process "${key}" env variable. Unable to locate file "${filePath}"`,
+            {
+              cause: error
+            }
+          );
+        }
+        throw error;
+      }
+    }
+  };
+  /**
+   * Creates a new EnvParser instance
+   *
+   * @param envContents - Raw environment file contents
+   * @param appRoot - Application root directory URL
+   * @param options - Parser options
+   */
+  constructor(envContents, appRoot, options) {
     if (options?.ignoreProcessEnv) {
       this.#preferProcessEnv = false;
     }
     this.#envContents = envContents;
+    this.#appRoot = appRoot;
   }
   /**
    * Define an identifier for any environment value. The callback is invoked
@@ -45,12 +83,23 @@ var EnvParser = class _EnvParser {
    *
    * @deprecated use `EnvParser.defineIdentifier` instead
    */
+  /**
+   * Define an identifier for any environment value. The callback is invoked
+   * when the value match the identifier to modify its interpolation.
+   *
+   * @deprecated use `EnvParser.defineIdentifier` instead
+   * @param name - The identifier name
+   * @param callback - Callback function to process the identifier value
+   */
   static identifier(name, callback) {
     _EnvParser.defineIdentifier(name, callback);
   }
   /**
    * Define an identifier for any environment value. The callback is invoked
    * when the value match the identifier to modify its interpolation.
+   *
+   * @param name - The identifier name
+   * @param callback - Callback function to process the identifier value
    */
   static defineIdentifier(name, callback) {
     if (this.#identifiers[name]) {
@@ -62,6 +111,9 @@ var EnvParser = class _EnvParser {
    * Define an identifier for any environment value, if it's not already defined.
    * The callback is invoked when the value match the identifier to modify its
    * interpolation.
+   *
+   * @param name - The identifier name
+   * @param callback - Callback function to process the identifier value
    */
   static defineIdentifierIfMissing(name, callback) {
     if (typeof this.#identifiers[name] === "undefined") {
@@ -70,12 +122,18 @@ var EnvParser = class _EnvParser {
   }
   /**
    * Remove an identifier
+   *
+   * @param name - The identifier name to remove
    */
   static removeIdentifier(name) {
     delete this.#identifiers[name];
   }
   /**
    * Returns the value from the parsed object
+   *
+   * @param key - The environment variable key
+   * @param parsed - Parsed environment variables object
+   * @returns The resolved environment variable value
    */
   #getValue(key, parsed) {
     if (this.#preferProcessEnv && process.env[key]) {
@@ -88,6 +146,10 @@ var EnvParser = class _EnvParser {
   }
   /**
    * Interpolating the token wrapped inside the mustache braces.
+   *
+   * @param token - The token to interpolate
+   * @param parsed - Parsed environment variables object
+   * @returns Interpolated value
    */
   #interpolateMustache(token, parsed) {
     const closingBrace = token.indexOf("}");
@@ -102,6 +164,10 @@ var EnvParser = class _EnvParser {
    * `$`. We only capture numbers,letter and underscore.
    * For other characters, one can use the mustache
    * braces.
+   *
+   * @param token - The token to interpolate
+   * @param parsed - Parsed environment variables object
+   * @returns Interpolated value
    */
   #interpolateVariable(token, parsed) {
     return token.replace(/[a-zA-Z0-9_]+/, (key) => {
@@ -110,6 +176,10 @@ var EnvParser = class _EnvParser {
   }
   /**
    * Interpolates the referenced values
+   *
+   * @param value - The value to interpolate
+   * @param parsed - Parsed environment variables object
+   * @returns Interpolated value
    */
   #interpolate(value, parsed) {
     const tokens = value.split("$");
@@ -139,6 +209,8 @@ var EnvParser = class _EnvParser {
   }
   /**
    * Parse the env string to an object of environment variables.
+   *
+   * @returns Promise resolving to parsed environment variables
    */
   async parse() {
     const envCollection = dotenv.parse(this.#envContents.trim());
@@ -150,7 +222,9 @@ var EnvParser = class _EnvParser {
         for (const identifier of identifiers) {
           if (value.startsWith(`${identifier}:`)) {
             result[key] = await _EnvParser.#identifiers[identifier](
-              value.substring(identifier.length + 1)
+              value.substring(identifier.length + 1),
+              key,
+              this.#appRoot
             );
             continue $keyLoop;
           }
@@ -170,10 +244,21 @@ var EnvParser = class _EnvParser {
 
 // src/validator.ts
 var EnvValidator = class {
+  /**
+   * The validation schema for environment variables
+   */
   #schema;
+  /**
+   * The error instance for validation failures
+   */
   #error;
-  constructor(schema) {
-    this.#schema = schema;
+  /**
+   * Creates a new EnvValidator instance
+   *
+   * @param schema - The validation schema object
+   */
+  constructor(schema2) {
+    this.#schema = schema2;
     this.#error = new E_INVALID_ENV_VARIABLES();
   }
   /**
@@ -182,6 +267,9 @@ var EnvValidator = class {
    *
    * The return value is a merged copy of the original object and the
    * values mutated by the schema validator.
+   *
+   * @param values - Object of environment variable values to validate
+   * @returns Validated and transformed environment variables
    */
   validate(values) {
     const help = [];
@@ -211,17 +299,26 @@ var EnvProcessor = class {
    * App root is needed to load files
    */
   #appRoot;
+  /**
+   * Creates a new EnvProcessor instance
+   *
+   * @param appRoot - The application root directory URL
+   */
   constructor(appRoot) {
     this.#appRoot = appRoot;
   }
   /**
    * Parse env variables from raw contents
+   *
+   * @param envContents - Raw environment file contents
+   * @param store - Store object to collect parsed variables
+   * @returns Updated store with parsed variables
    */
   async #processContents(envContents, store) {
     if (!envContents.trim()) {
       return store;
     }
-    const parser = new EnvParser(envContents);
+    const parser = new EnvParser(envContents, this.#appRoot);
     const values = await parser.parse();
     Object.keys(values).forEach((key) => {
       let value = process.env[key];
@@ -237,6 +334,8 @@ var EnvProcessor = class {
   }
   /**
    * Parse env variables by loading dot files.
+   *
+   * @returns Promise resolving to collected environment variables
    */
   async #loadAndProcessDotFiles() {
     const loader = new EnvLoader(this.#appRoot);
@@ -253,18 +352,57 @@ var EnvProcessor = class {
   }
   /**
    * Process env variables
+   *
+   * @returns Promise resolving to processed environment variables
    */
   async process() {
     return this.#loadAndProcessDotFiles();
   }
 };
 
+// src/schema.ts
+import { Secret } from "@poppinss/utils";
+import { schema as envSchema } from "@poppinss/validator-lite";
+function secret(options) {
+  return function validate(key, value) {
+    if (!value) {
+      throw new Error(options?.message ?? `Missing environment variable "${key}"`);
+    }
+    return new Secret(value);
+  };
+}
+secret.optional = function optionalString() {
+  return function validate(_, value) {
+    if (!value) {
+      return void 0;
+    }
+    return new Secret(value);
+  };
+};
+secret.optionalWhen = function optionalWhenString(condition, options) {
+  return function validate(key, value) {
+    if (typeof condition === "function" ? condition(key, value) : condition) {
+      return secret.optional()(key, value);
+    }
+    return secret(options)(key, value);
+  };
+};
+var schema = {
+  ...envSchema,
+  secret
+};
+
 // src/env.ts
 var Env = class _Env {
   /**
    * A cache of env values
    */
   #values;
+  /**
+   * Creates a new Env instance
+   *
+   * @param values - Validated environment values
+   */
   constructor(values) {
     this.#values = values;
   }
@@ -272,10 +410,14 @@ var Env = class _Env {
    * Create an instance of the env class by validating the
    * environment variables. Also, the `.env` files are
    * loaded from the appRoot
+   *
+   * @param appRoot - The application root directory URL
+   * @param schema - Validation schema for environment variables
+   * @returns Promise resolving to an Env instance with validated values
    */
-  static async create(appRoot, schema) {
+  static async create(appRoot, schema2) {
     const values = await new EnvProcessor(appRoot).process();
-    const validator = this.rules(schema);
+    const validator = this.rules(schema2);
     return new _Env(validator.validate(values));
   }
   /**
@@ -283,6 +425,8 @@ var Env = class _Env {
    * when the value match the identifier to modify its interpolation.
    *
    * @deprecated use `Env.defineIdentifier` instead
+   * @param name - The identifier name
+   * @param callback - Callback function to process the identifier value
    */
   static identifier(name, callback) {
     return EnvParser.defineIdentifier(name, callback);
@@ -290,6 +434,9 @@ var Env = class _Env {
   /**
    * Define an identifier for any environment value. The callback is invoked
    * when the value match the identifier to modify its interpolation.
+   *
+   * @param name - The identifier name
+   * @param callback - Callback function to process the identifier value
    */
   static defineIdentifier(name, callback) {
     EnvParser.defineIdentifier(name, callback);
@@ -298,12 +445,17 @@ var Env = class _Env {
    * Define an identifier for any environment value, if it's not already defined.
    * The callback is invoked when the value match the identifier to modify its
    * interpolation.
+   *
+   * @param name - The identifier name
+   * @param callback - Callback function to process the identifier value
    */
   static defineIdentifierIfMissing(name, callback) {
     EnvParser.defineIdentifierIfMissing(name, callback);
   }
   /**
    * Remove an identifier
+   *
+   * @param name - The identifier name to remove
    */
   static removeIdentifier(name) {
     EnvParser.removeIdentifier(name);
@@ -311,14 +463,17 @@ var Env = class _Env {
   /**
    * The schema builder for defining validation rules
    */
-  static schema = envSchema;
+  static schema = schema;
   /**
    * Define the validation rules for validating environment
    * variables. The return value is an instance of the
    * env validator
+   *
+   * @param schema - Validation schema object
+   * @returns EnvValidator instance
    */
-  static rules(schema) {
-    const validator = new EnvValidator(schema);
+  static rules(schema2) {
+    const validator = new EnvValidator(schema2);
     return validator;
   }
   get(key, defaultValue) {

package/build/src/editor.d.ts

@@ -1,28 +1,53 @@
+/**
+ * Environment editor for managing and modifying .env files.
+ * Provides functionality to load, edit, and save environment configuration files.
+ */
 export declare class EnvEditor {
     #private;
     /**
      * Creates an instance of env editor and loads .env files
      * contents.
+     *
+     * @param appRoot - The application root directory URL
+     * @returns Promise resolving to an EnvEditor instance
      */
     static create(appRoot: URL): Promise<EnvEditor>;
+    /**
+     * Constructs a new EnvEditor instance
+     *
+     * @param appRoot - The application root directory URL
+     */
     constructor(appRoot: URL);
     /**
      * Loads .env files for editing. Only ".env" and ".env.example"
      * files are picked for editing.
+     *
+     * @returns Promise that resolves when files are loaded
      */
     load(): Promise<void>;
     /**
      * Add key-value pair to the dot-env files.
      * If `withEmptyExampleValue` is true then the key will be added with an empty value
      * to the `.env.example` file.
+     *
+     * @param key - The environment variable key
+     * @param value - The environment variable value
+     * @param withEmptyExampleValue - Whether to add empty value to .env.example file
      */
     add(key: string, value: string | number | boolean, withEmptyExampleValue?: boolean): void;
+    /**
+     * Returns the loaded files as JSON
+     *
+     * @returns Array of file objects with contents and paths
+     */
     toJSON(): {
         contents: string[];
         path: string;
     }[];
     /**
      * Save changes to the disk
+     *
+     * @returns Promise that resolves when files are saved
      */
     save(): Promise<void>;
 }

package/build/src/editor.js

@@ -1,24 +1,41 @@
 import {
   EnvLoader
-} from "../chunk-EIJZNYI6.js";
+} from "../chunk-KE5AFOK2.js";
 
 // src/editor.ts
 import splitLines from "split-lines";
 import lodash from "@poppinss/utils/lodash";
 import { writeFile } from "fs/promises";
 var EnvEditor = class _EnvEditor {
+  /**
+   * The application root directory URL
+   */
   #appRoot;
+  /**
+   * Environment file loader instance
+   */
   #loader;
+  /**
+   * Array of loaded environment files with their contents and paths
+   */
   #files = [];
   /**
    * Creates an instance of env editor and loads .env files
    * contents.
+   *
+   * @param appRoot - The application root directory URL
+   * @returns Promise resolving to an EnvEditor instance
    */
   static async create(appRoot) {
     const editor = new _EnvEditor(appRoot);
     await editor.load();
     return editor;
   }
+  /**
+   * Constructs a new EnvEditor instance
+   *
+   * @param appRoot - The application root directory URL
+   */
   constructor(appRoot) {
     this.#appRoot = appRoot;
     this.#loader = new EnvLoader(this.#appRoot, true);
@@ -26,6 +43,8 @@ var EnvEditor = class _EnvEditor {
   /**
    * Loads .env files for editing. Only ".env" and ".env.example"
    * files are picked for editing.
+   *
+   * @returns Promise that resolves when files are loaded
    */
   async load() {
     const envFiles = await this.#loader.load();
@@ -42,6 +61,10 @@ var EnvEditor = class _EnvEditor {
    * Add key-value pair to the dot-env files.
    * If `withEmptyExampleValue` is true then the key will be added with an empty value
    * to the `.env.example` file.
+   *
+   * @param key - The environment variable key
+   * @param value - The environment variable value
+   * @param withEmptyExampleValue - Whether to add empty value to .env.example file
    */
   add(key, value, withEmptyExampleValue = false) {
     this.#files.forEach((file) => {
@@ -54,11 +77,18 @@ var EnvEditor = class _EnvEditor {
       }
     });
   }
+  /**
+   * Returns the loaded files as JSON
+   *
+   * @returns Array of file objects with contents and paths
+   */
   toJSON() {
     return this.#files;
   }
   /**
    * Save changes to the disk
+   *
+   * @returns Promise that resolves when files are saved
    */
   async save() {
     await Promise.all(

package/build/src/env.d.ts

@@ -1,6 +1,6 @@
-import { schema as envSchema } from '@poppinss/validator-lite';
 import type { ValidateFn } from '@poppinss/validator-lite/types';
-import { EnvValidator } from './validator.js';
+import { EnvValidator } from './validator.ts';
+import { schema as envSchema } from './schema.ts';
 /**
  * A wrapper over "process.env" with types information.
  *
@@ -17,11 +17,20 @@ import { EnvValidator } from './validator.js';
  */
 export declare class Env<EnvValues extends Record<string, any>> {
     #private;
+    /**
+     * Creates a new Env instance
+     *
+     * @param values - Validated environment values
+     */
     constructor(values: EnvValues);
     /**
      * Create an instance of the env class by validating the
      * environment variables. Also, the `.env` files are
      * loaded from the appRoot
+     *
+     * @param appRoot - The application root directory URL
+     * @param schema - Validation schema for environment variables
+     * @returns Promise resolving to an Env instance with validated values
      */
     static create<Schema extends {
         [key: string]: ValidateFn<unknown>;
@@ -33,21 +42,31 @@ export declare class Env<EnvValues extends Record<string, any>> {
      * when the value match the identifier to modify its interpolation.
      *
      * @deprecated use `Env.defineIdentifier` instead
+     * @param name - The identifier name
+     * @param callback - Callback function to process the identifier value
      */
     static identifier(name: string, callback: (value: string) => Promise<string> | string): void;
     /**
      * Define an identifier for any environment value. The callback is invoked
      * when the value match the identifier to modify its interpolation.
+     *
+     * @param name - The identifier name
+     * @param callback - Callback function to process the identifier value
      */
     static defineIdentifier(name: string, callback: (value: string) => Promise<string> | string): void;
     /**
      * Define an identifier for any environment value, if it's not already defined.
      * The callback is invoked when the value match the identifier to modify its
      * interpolation.
+     *
+     * @param name - The identifier name
+     * @param callback - Callback function to process the identifier value
      */
     static defineIdentifierIfMissing(name: string, callback: (value: string) => Promise<string> | string): void;
     /**
      * Remove an identifier
+     *
+     * @param name - The identifier name to remove
      */
     static removeIdentifier(name: string): void;
     /**
@@ -58,6 +77,9 @@ export declare class Env<EnvValues extends Record<string, any>> {
      * Define the validation rules for validating environment
      * variables. The return value is an instance of the
      * env validator
+     *
+     * @param schema - Validation schema object
+     * @returns EnvValidator instance
      */
     static rules<T extends {
         [key: string]: ValidateFn<unknown>;
@@ -76,6 +98,10 @@ export declare class Env<EnvValues extends Record<string, any>> {
      * // With default value
      * Env.get('PORT', 3000)
      * ```
+     *
+     * @param key - The environment variable key
+     * @param defaultValue - Default value if key is not found
+     * @returns The environment variable value or default
      */
     get<K extends keyof EnvValues>(key: K): EnvValues[K];
     get<K extends keyof EnvValues>(key: K, defaultValue: Exclude<EnvValues[K], undefined>): Exclude<EnvValues[K], undefined>;
@@ -93,6 +119,9 @@ export declare class Env<EnvValues extends Record<string, any>> {
      * Env.get('PORT') === 3000 // true
      * process.env.PORT === '3000' // true
      * ```
+     *
+     * @param key - The environment variable key
+     * @param value - The value to set
      */
     set<K extends keyof EnvValues>(key: K, value: EnvValues[K]): void;
     set(key: string, value: string): void;

package/build/src/errors.d.ts

@@ -1,7 +1,6 @@
 import { Exception } from '@poppinss/utils/exception';
 /**
- * Exception raised when one or more env variables
- * are invalid
+ * Exception raised when one or more env variables are invalid
  */
 export declare const E_INVALID_ENV_VARIABLES: {
     new (message?: string, options?: ErrorOptions & {
@@ -27,4 +26,7 @@ export declare const E_INVALID_ENV_VARIABLES: {
     prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
     stackTraceLimit: number;
 };
+/**
+ * Exception raised when the identifier is already defined
+ */
 export declare const E_IDENTIFIER_ALREADY_DEFINED: new (args: [string], options?: ErrorOptions) => Exception;

package/build/src/loader.d.ts

@@ -22,10 +22,18 @@
  */
 export declare class EnvLoader {
     #private;
+    /**
+     * Creates a new EnvLoader instance
+     *
+     * @param appRoot - The application root directory as string or URL
+     * @param loadExampleFile - Whether to load .env.example file
+     */
     constructor(appRoot: string | URL, loadExampleFile?: boolean);
     /**
      * Load contents of the main dot-env file and the current
      * environment dot-env file
+     *
+     * @returns Promise resolving to array of loaded environment files
      */
     load(): Promise<{
         contents: string;

package/build/src/parser.d.ts

@@ -3,7 +3,7 @@ import { type DotenvParseOutput } from 'dotenv';
  * Env parser parses the environment variables from a string formatted
  * as a key-value pair seperated using an `=`. For example:
  *
- * ```dotenv
+ * ```
  * PORT=3333
  * HOST=127.0.0.1
  * ```
@@ -11,7 +11,7 @@ import { type DotenvParseOutput } from 'dotenv';
  * The variables can reference other environment variables as well using `$`.
  * For example:
  *
- * ```dotenv
+ * ```
  * PORT=3333
  * REDIS_PORT=$PORT
  * ```
@@ -19,14 +19,14 @@ import { type DotenvParseOutput } from 'dotenv';
  * The variables using characters other than letters can wrap variable
  * named inside a curly brace.
  *
- * ```dotenv
+ * ```
  * APP-PORT=3333
  * REDIS_PORT=${APP-PORT}
  * ```
  *
  * You can escape the `$` sign with a backtick.
  *
- * ```dotenv
+ * ```
  * REDIS_PASSWORD=foo\$123
  * ```
  *
@@ -41,7 +41,14 @@ import { type DotenvParseOutput } from 'dotenv';
  */
 export declare class EnvParser {
     #private;
-    constructor(envContents: string, options?: {
+    /**
+     * Creates a new EnvParser instance
+     *
+     * @param envContents - Raw environment file contents
+     * @param appRoot - Application root directory URL
+     * @param options - Parser options
+     */
+    constructor(envContents: string, appRoot: URL, options?: {
         ignoreProcessEnv: boolean;
     });
     /**
@@ -50,24 +57,42 @@ export declare class EnvParser {
      *
      * @deprecated use `EnvParser.defineIdentifier` instead
      */
+    /**
+     * Define an identifier for any environment value. The callback is invoked
+     * when the value match the identifier to modify its interpolation.
+     *
+     * @deprecated use `EnvParser.defineIdentifier` instead
+     * @param name - The identifier name
+     * @param callback - Callback function to process the identifier value
+     */
     static identifier(name: string, callback: (value: string) => Promise<string> | string): void;
     /**
      * Define an identifier for any environment value. The callback is invoked
      * when the value match the identifier to modify its interpolation.
+     *
+     * @param name - The identifier name
+     * @param callback - Callback function to process the identifier value
      */
     static defineIdentifier(name: string, callback: (value: string) => Promise<string> | string): void;
     /**
      * Define an identifier for any environment value, if it's not already defined.
      * The callback is invoked when the value match the identifier to modify its
      * interpolation.
+     *
+     * @param name - The identifier name
+     * @param callback - Callback function to process the identifier value
      */
     static defineIdentifierIfMissing(name: string, callback: (value: string) => Promise<string> | string): void;
     /**
      * Remove an identifier
+     *
+     * @param name - The identifier name to remove
      */
     static removeIdentifier(name: string): void;
     /**
      * Parse the env string to an object of environment variables.
+     *
+     * @returns Promise resolving to parsed environment variables
      */
     parse(): Promise<DotenvParseOutput>;
 }

package/build/src/processor.d.ts

@@ -3,9 +3,16 @@
  */
 export declare class EnvProcessor {
     #private;
+    /**
+     * Creates a new EnvProcessor instance
+     *
+     * @param appRoot - The application root directory URL
+     */
     constructor(appRoot: URL);
     /**
      * Process env variables
+     *
+     * @returns Promise resolving to processed environment variables
      */
     process(): Promise<Record<string, any>>;
 }

package/build/src/schema.d.ts

@@ -0,0 +1,13 @@
+import { Secret } from '@poppinss/utils';
+import { type Prettify } from '@poppinss/utils/types';
+import { schema as envSchema } from '@poppinss/validator-lite';
+import { type SchemaFnOptions } from '@poppinss/validator-lite/types';
+declare function secret(options?: SchemaFnOptions): (key: string, value?: string) => Secret<string>;
+declare namespace secret {
+    var optional: () => (_: string, value?: string) => Secret<string> | undefined;
+    var optionalWhen: (condition: boolean | ((key: string, value?: string) => boolean), options?: SchemaFnOptions) => (key: string, value?: string) => Secret<string> | undefined;
+}
+export declare const schema: Prettify<typeof envSchema & {
+    secret: typeof secret;
+}>;
+export {};

package/build/src/types.d.ts

@@ -0,0 +1 @@
+export type EnvIdentifierCallback = (value: string, key: string, appRoot: URL) => Promise<string> | string;

package/build/src/validator.d.ts

@@ -9,6 +9,11 @@ export declare class EnvValidator<Schema extends {
     [key: string]: ValidateFn<unknown>;
 }> {
     #private;
+    /**
+     * Creates a new EnvValidator instance
+     *
+     * @param schema - The validation schema object
+     */
     constructor(schema: Schema);
     /**
      * Accepts an object of values to validate against the pre-defined
@@ -16,6 +21,9 @@ export declare class EnvValidator<Schema extends {
      *
      * The return value is a merged copy of the original object and the
      * values mutated by the schema validator.
+     *
+     * @param values - Object of environment variable values to validate
+     * @returns Validated and transformed environment variables
      */
     validate(values: {
         [K: string]: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/env",
-  "version": "7.0.0-next.0",
+  "version": "7.0.0-next.2",
   "description": "Environment variable manager for Node.js",
   "main": "build/index.js",
   "type": "module",
@@ -12,6 +12,7 @@
   ],
   "exports": {
     ".": "./build/index.js",
+    "./types": "./build/src/types.js",
     "./editor": "./build/src/editor.js"
   },
   "engines": {
@@ -33,29 +34,30 @@
     "quick:test": "node --import=@poppinss/ts-exec --enable-source-maps bin/test.ts"
   },
   "devDependencies": {
-    "@adonisjs/eslint-config": "^3.0.0-next.0",
+    "@adonisjs/eslint-config": "^3.0.0-next.1",
     "@adonisjs/prettier-config": "^1.4.5",
     "@adonisjs/tsconfig": "^2.0.0-next.0",
     "@japa/assert": "^4.1.1",
     "@japa/expect-type": "^2.0.3",
     "@japa/file-system": "^2.3.2",
-    "@japa/runner": "^4.3.0",
-    "@poppinss/ts-exec": "^1.4.0",
+    "@japa/runner": "^4.4.0",
+    "@poppinss/ts-exec": "^1.4.1",
     "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^24.1.0",
+    "@types/node": "^24.3.1",
     "c8": "^10.1.3",
     "cross-env": "^10.0.0",
     "del-cli": "^6.0.0",
-    "eslint": "^9.32.0",
+    "eslint": "^9.35.0",
     "prettier": "^3.6.2",
     "release-it": "^19.0.4",
     "tsup": "^8.5.0",
-    "typescript": "^5.8.3"
+    "typedoc": "^0.28.12",
+    "typescript": "^5.9.2"
   },
   "dependencies": {
     "@poppinss/utils": "^7.0.0-next.3",
     "@poppinss/validator-lite": "^2.1.2",
-    "dotenv": "^17.2.1",
+    "dotenv": "^17.2.2",
     "split-lines": "^3.0.0"
   },
   "homepage": "https://github.com/adonisjs/env#readme",
@@ -83,6 +85,7 @@
   "tsup": {
     "entry": [
       "./index.ts",
+      "./src/types.ts",
       "./src/editor.ts"
     ],
     "outDir": "./build",