@bymax-one/nest-config 1.0.0

package/dist/internal/index.d.cts

@@ -0,0 +1,571 @@
+import * as _nestjs_common from '@nestjs/common';
+import { DynamicModule } from '@nestjs/common';
+import { z } from 'zod';
+
+/**
+ * @fileoverview Foundational schema shape types for the two-level environment
+ * configuration convention: top-level keys are namespaces (Zod object schemas)
+ * whose leaves are the individual environment-derived values. Everything the
+ * package builds (the `defineEnv` factory, the source-name mapping, the
+ * validator, and the `ConfigService` dot-path accessor) is expressed in terms
+ * of these types.
+ * @layer Types
+ */
+
+/**
+ * A single environment-derived leaf schema.
+ *
+ * Any Zod type may be a leaf (`z.string()`, `z.coerce.number()`, `z.enum(...)`,
+ * and so on). Leaves live one level below a namespace and never at the top
+ * level of a shape.
+ */
+type EnvLeaf = z.ZodType;
+/**
+ * A configuration namespace: a Zod object schema that groups related leaves
+ * under one top-level key (for example `server`, `database`, or `auth`).
+ */
+type EnvNamespace = z.ZodObject;
+/**
+ * The shape accepted by `defineEnv`.
+ *
+ * Encodes the two-level convention as a record of namespace keys, each mapped
+ * to a Zod object schema. A bare leaf at the top level is intentionally not
+ * assignable, which keeps the namespace boundary explicit and greppable.
+ */
+type EnvShape = Record<string, EnvNamespace>;
+/**
+ * The parsed, validated output type produced by a shape.
+ *
+ * Mirrors what Zod infers for `z.object(shape)`, so applied coercions and
+ * defaults are reflected exactly. Used to type the `infer` phantom accessor on
+ * the schema returned by `defineEnv`.
+ *
+ * @typeParam TShape - The env shape whose composed output is inferred.
+ */
+type EnvOutput<TShape extends EnvShape> = z.infer<z.ZodObject<TShape>>;
+/**
+ * The schema returned by `defineEnv`.
+ *
+ * The composed Zod object augmented with a phantom `infer` accessor that
+ * carries the inferred configuration type for ergonomic extraction via
+ * `typeof schema.infer`. The property exists only in the type system; reading
+ * it at runtime is not part of the contract.
+ *
+ * @typeParam TShape - The env shape the schema was composed from.
+ */
+type EnvSchema<TShape extends EnvShape = EnvShape> = z.ZodObject<TShape> & {
+    /** Phantom accessor exposing the inferred config type; use `typeof schema.infer`. */
+    readonly infer: EnvOutput<TShape>;
+};
+/**
+ * The union of every valid `namespace.leaf` dot-path for a config object.
+ *
+ * Given a parsed config type whose top-level keys are namespaces and whose
+ * second-level keys are leaves, this resolves to the union of `` `${namespace}.${leaf}` ``
+ * strings. Inference is deliberately fixed at exactly two levels (namespace and
+ * leaf) with no recursive conditional types, so the compiler cost stays flat
+ * even for large schemas. Deeper nesting stays typed through `getAll()` but is
+ * intentionally not addressable through a dot-path; this is a documented limit
+ * of the two-level convention, not an oversight.
+ *
+ * @typeParam TConfig - The parsed, two-level configuration object type.
+ * @example
+ * ```typescript
+ * type AppConfig = { server: { port: number }; database: { url: string } };
+ * type Paths = Path<AppConfig>; // 'server.port' | 'database.url'
+ * ```
+ */
+type Path<TConfig> = {
+    [Namespace in keyof TConfig & string]: TConfig[Namespace] extends Record<string, unknown> ? {
+        [Leaf in keyof TConfig[Namespace] & string]: `${Namespace}.${Leaf}`;
+    }[keyof TConfig[Namespace] & string] : never;
+}[keyof TConfig & string];
+/**
+ * The leaf value type addressed by a `namespace.leaf` path.
+ *
+ * Splits the path on its single dot and walks exactly the two fixed levels to
+ * resolve the leaf type, so `PathValue<AppConfig, 'server.port'>` is `number`.
+ * The split is a single template-literal inference with no recursion, matching
+ * the flat-cost guarantee of {@link Path}.
+ *
+ * @typeParam TConfig - The parsed, two-level configuration object type.
+ * @typeParam TPath - A path drawn from {@link Path}<TConfig>.
+ * @example
+ * ```typescript
+ * type AppConfig = { server: { port: number }; database: { url: string } };
+ * type Port = PathValue<AppConfig, 'server.port'>; // number
+ * ```
+ */
+type PathValue<TConfig, TPath extends Path<TConfig>> = TPath extends `${infer Namespace}.${infer Leaf}` ? Namespace extends keyof TConfig ? Leaf extends keyof TConfig[Namespace] ? TConfig[Namespace][Leaf] : never : never : never;
+
+/**
+ * @fileoverview Value-free error model for the configuration validation
+ * pipeline: the frozen issue-code catalog, the ConfigIssue shape, and the
+ * BymaxConfigValidationError aggregate. The error carries every violation as a
+ * structured, immutable issue list and renders a multi-line report that never
+ * echoes a raw source value.
+ * @layer Error
+ */
+/**
+ * Frozen catalog of stable, machine-readable configuration error codes.
+ *
+ * `VALIDATION` is the top-level code carried by the thrown error; the remaining
+ * three classify individual issues. Exported once and referenced everywhere so
+ * no code string is ever inlined at a use site.
+ *
+ * @example
+ * ```typescript
+ * if (issue.code === ConfigErrorCode.MISSING) {
+ *   // handle an absent required variable
+ * }
+ * ```
+ */
+declare const ConfigErrorCode: Readonly<{
+    /** Top-level error code: one or more schema violations were collected. */
+    readonly VALIDATION: "BYMAX_CONFIG_VALIDATION";
+    /** Issue code: a required variable is absent from the source. */
+    readonly MISSING: "BYMAX_CONFIG_MISSING";
+    /** Issue code: a variable is present but violates its constraint. */
+    readonly INVALID: "BYMAX_CONFIG_INVALID";
+    /** Issue code: strict mode found a source variable matching no declared leaf. */
+    readonly UNKNOWN_KEY: "BYMAX_CONFIG_UNKNOWN_KEY";
+}>;
+/** The stable top-level code carried by {@link BymaxConfigValidationError}. */
+type ConfigValidationCode = typeof ConfigErrorCode.VALIDATION;
+/** Machine-readable code classifying a single {@link ConfigIssue}. */
+type ConfigIssueCode = typeof ConfigErrorCode.MISSING | typeof ConfigErrorCode.INVALID | typeof ConfigErrorCode.UNKNOWN_KEY;
+/**
+ * A single configuration violation, described entirely without any raw value.
+ *
+ * Every field is value-free by contract: `message` states the expected
+ * constraint, never the received input, so an issue can be logged or serialized
+ * without leaking a secret.
+ */
+interface ConfigIssue {
+    /** Nested config path, e.g. `database.url`; the namespace alone (e.g. `database`) for an unknown-key issue. */
+    readonly path: string;
+    /** Resolved environment variable name, e.g. `DATABASE_URL`. */
+    readonly variable: string;
+    /** Stable machine-readable classification. */
+    readonly code: ConfigIssueCode;
+    /** Human-readable constraint description, value-free. */
+    readonly message: string;
+}
+/**
+ * Aggregated, value-free configuration validation error.
+ *
+ * Thrown once at bootstrap when the source fails the schema. It carries every
+ * violation in an immutable, structured {@link ConfigIssue} list and a
+ * human-readable message that lists the offending variables and their expected
+ * constraints, never their received values.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   validateEnv(schema, source);
+ * } catch (error) {
+ *   if (error instanceof BymaxConfigValidationError) {
+ *     for (const issue of error.issues) report(issue.variable, issue.code);
+ *   }
+ * }
+ * ```
+ */
+declare class BymaxConfigValidationError extends Error {
+    /** The stable top-level error code. */
+    readonly code: ConfigValidationCode;
+    /** The immutable, aggregated list of collected violations. */
+    readonly issues: ReadonlyArray<ConfigIssue>;
+    /**
+     * Build the aggregated error from a list of value-free issues.
+     *
+     * @param issues - Every collected violation; copied and frozen so neither the
+     * caller nor consumer code can mutate the reported list.
+     */
+    constructor(issues: ReadonlyArray<ConfigIssue>);
+}
+
+/**
+ * @fileoverview Public options contract for the BymaxConfigModule dynamic
+ * module: the schema to validate against, an optional raw source (defaulting to
+ * the process environment inside the provider factory), an optional value-free
+ * observability hook invoked before the fail-fast throw, and an optional strict
+ * unknown-key flag. This file declares only types and carries no runtime code.
+ * @layer Types
+ */
+
+/**
+ * Registration options for {@link BymaxConfigModule}.
+ *
+ * Passed to `forRoot` directly or produced by a `forRootAsync` factory. Only the
+ * schema is required; the remaining fields tune the source, observability, and
+ * strictness of the single bootstrap-time validation.
+ *
+ * @typeParam TSchema - The schema produced by `defineEnv`, carrying the inferred
+ * configuration type.
+ * @example
+ * ```typescript
+ * BymaxConfigModule.forRoot({ schema: envSchema, strict: true });
+ * ```
+ */
+interface BymaxConfigModuleOptions<TSchema extends EnvSchema = EnvSchema> {
+    /** Schema produced by `defineEnv`. Required. */
+    readonly schema: TSchema;
+    /**
+     * Raw source record. Defaults to the process environment in the provider
+     * factory. Injectable for tests and tooling; a supplied source is used
+     * verbatim, with no environment fallback or merge.
+     */
+    readonly source?: Record<string, string | undefined>;
+    /**
+     * Observability hook invoked once with the structured, value-free issue list
+     * immediately before the validation error is thrown. It is observability
+     * only and cannot suppress the failure: the error still propagates even when
+     * the hook itself throws.
+     */
+    readonly onValidationError?: (issues: ReadonlyArray<ConfigIssue>) => void;
+    /**
+     * When true, source variables that match a declared namespace prefix but no
+     * declared leaf produce `BYMAX_CONFIG_UNKNOWN_KEY` issues. Defaults to false.
+     */
+    readonly strict?: boolean;
+}
+
+/**
+ * Extra registration options that shape the module without being injected.
+ *
+ * `setExtras` keeps these out of the {@link BYMAX_CONFIG_OPTIONS} provider, so a
+ * consumer of the options token never sees `isGlobal`; it only influences the
+ * generated `DynamicModule`.
+ */
+interface BymaxConfigModuleExtras {
+    /**
+     * Register the module globally by mapping to `DynamicModule.global`. The
+     * builder applies the `true` default before the transform runs, so this is
+     * required at the extras level; consumers see it optional through the
+     * generated `OPTIONS_TYPE` (a `Partial` of the extras). Defaults to true.
+     */
+    readonly isGlobal: boolean;
+}
+/**
+ * The generated dynamic-module artifacts.
+ *
+ * `MODULE_OPTIONS_TOKEN` is the {@link BYMAX_CONFIG_OPTIONS} Symbol (bound
+ * through `optionsInjectionToken`), so the config provider factory and the
+ * generated options provider share one token. `OPTIONS_TYPE` and
+ * `ASYNC_OPTIONS_TYPE` type the `forRoot` / `forRootAsync` parameters, including
+ * the `isGlobal` extra.
+ */
+declare const ConfigurableModuleClass: _nestjs_common.ConfigurableModuleCls<BymaxConfigModuleOptions<EnvSchema>, "forRoot", "create", BymaxConfigModuleExtras>;
+declare const OPTIONS_TYPE: BymaxConfigModuleOptions<EnvSchema> & Partial<BymaxConfigModuleExtras>;
+declare const ASYNC_OPTIONS_TYPE: _nestjs_common.ConfigurableModuleAsyncOptions<BymaxConfigModuleOptions<EnvSchema>, "create"> & Partial<BymaxConfigModuleExtras>;
+/** Parameter type of `BymaxConfigModule.forRoot`: the options plus the `isGlobal` extra. */
+type BymaxConfigForRootOptions = typeof OPTIONS_TYPE;
+/** Parameter type of `BymaxConfigModule.forRootAsync`: async options plus the `isGlobal` extra. */
+type BymaxConfigForRootAsyncOptions = typeof ASYNC_OPTIONS_TYPE;
+
+/**
+ * @fileoverview BymaxConfigModule: the dynamic module consumers import once via
+ * `forRoot` / `forRootAsync`. It extends the generated ConfigurableModuleClass,
+ * inheriting the `isGlobal` extra mapping, and augments each returned definition
+ * with the validated, deep-frozen BYMAX_CONFIG provider and the typed
+ * ConfigService accessor, so the config is produced (and validation runs) as
+ * part of module resolution and both surfaces are exported for consumers.
+ * @layer Module
+ */
+
+/**
+ * NestJS dynamic module exposing typed, validated environment configuration.
+ *
+ * Import it once (typically in `AppModule`) with `forRoot` for a static schema
+ * or `forRootAsync` when the source is resolved through other providers. It is
+ * global by default; pass `isGlobal: false` to scope it to a submodule. Either
+ * entry point registers and exports the frozen {@link BYMAX_CONFIG} provider.
+ *
+ * @example
+ * ```typescript
+ * @Module({ imports: [BymaxConfigModule.forRoot({ schema: envSchema })] })
+ * export class AppModule {}
+ * ```
+ */
+declare class BymaxConfigModule extends ConfigurableModuleClass {
+    /**
+     * Register the module synchronously from a static schema.
+     *
+     * @param options - The module options plus the optional `isGlobal` extra.
+     * @returns The dynamic module augmented with the frozen config provider.
+     */
+    static forRoot(options: BymaxConfigForRootOptions): DynamicModule;
+    /**
+     * Register the module asynchronously, resolving options through a factory.
+     *
+     * @param options - The async options with `useFactory` and explicit `inject`.
+     * @returns The dynamic module augmented with the frozen config provider.
+     */
+    static forRootAsync(options: BymaxConfigForRootAsyncOptions): DynamicModule;
+    /**
+     * Append the config provider and typed accessor to a generated definition.
+     *
+     * Registers the frozen {@link BYMAX_CONFIG} provider and the {@link ConfigService}
+     * accessor (which injects that token), then exports both so consumers can
+     * inject either the raw frozen object or the typed service.
+     *
+     * @param definition - The dynamic module produced by the builder base class.
+     * @returns A definition that provides and exports {@link BYMAX_CONFIG} and
+     * {@link ConfigService}.
+     */
+    private static withConfigProvider;
+}
+
+/**
+ * @fileoverview ConfigService: the typed, injectable accessor over the frozen
+ * BYMAX_CONFIG object. It is the recommended consumption surface for the
+ * validated configuration, offering compile-time dot-path inference (`get`),
+ * the frozen root (`getAll`), and a declared-path presence check (`has`). The
+ * config is injected explicitly through the module-local Symbol token, so the
+ * service carries no decorator metadata and needs no `emitDecoratorMetadata`.
+ * @layer Service
+ */
+
+/**
+ * Typed accessor over the validated, deep-frozen configuration object.
+ *
+ * Wraps the frozen config registered under {@link BYMAX_CONFIG} and exposes it
+ * through dot-path access limited to the two-level `namespace.leaf` convention.
+ * Because validation completed at bootstrap, every declared leaf either passed
+ * validation or received its default (or the process never started), so `get`
+ * never throws for a declared path.
+ *
+ * @typeParam TConfig - The parsed, two-level configuration object type.
+ * @example
+ * ```typescript
+ * @Injectable()
+ * export class InvoiceService {
+ *   public constructor(
+ *     @Inject(ConfigService) private readonly config: ConfigService<AppConfig>,
+ *   ) {}
+ *
+ *   public connect(): Connection {
+ *     return connect(this.config.get('database.url'), this.config.get('server.port'));
+ *   }
+ * }
+ * ```
+ */
+declare class ConfigService<TConfig> {
+    private readonly config;
+    /** Precomputed `namespace.leaf` to value lookup, built once at construction. */
+    private readonly leaves;
+    /**
+     * Bind the accessor to the frozen configuration object.
+     *
+     * Builds a flat `namespace.leaf` lookup once so `get`/`has` are constant-time
+     * and never rebuild a map per call. Iteration over entries (rather than dynamic
+     * bracket indexing) avoids introducing a non-literal property sink.
+     *
+     * @param config - The validated, deep-frozen config injected via {@link BYMAX_CONFIG}.
+     */
+    constructor(config: Readonly<TConfig>);
+    /**
+     * Read a leaf value by its `namespace.leaf` dot-path.
+     *
+     * The return type is inferred from the path, so `get('server.port')` is typed
+     * `number` with no cast. Never throws for a declared path: validation ran once
+     * at bootstrap. An optional leaf without a default may still resolve to
+     * `undefined` when its type includes it.
+     *
+     * @typeParam TPath - A declared path drawn from {@link Path}<TConfig>.
+     * @param path - The two-level dot-path to resolve.
+     * @returns The leaf value, typed as {@link PathValue}<TConfig, TPath>.
+     * @example
+     * ```typescript
+     * const port = config.get('server.port'); // number
+     * ```
+     */
+    get<TPath extends Path<TConfig>>(path: TPath): PathValue<TConfig, TPath>;
+    /**
+     * Return the whole validated configuration as its deep-frozen root.
+     *
+     * Yields the same frozen reference the module registered, fully typed for
+     * arbitrary depth, which is the escape hatch for nesting deeper than the
+     * two-level dot-path inference covers.
+     *
+     * @returns The frozen configuration root.
+     * @example
+     * ```typescript
+     * const everything = config.getAll(); // Readonly<AppConfig>
+     * ```
+     */
+    getAll(): Readonly<TConfig>;
+    /**
+     * Report whether a declared path resolves to a defined value.
+     *
+     * Returns `false` when the leaf resolved to `undefined` (an optional leaf
+     * without a default), distinguishing "declared but unset" from "declared and
+     * set" without a truthiness pitfall on falsy values such as `0` or `''`.
+     *
+     * @param path - The two-level dot-path to check.
+     * @returns True when the resolved value is not `undefined`.
+     * @example
+     * ```typescript
+     * if (config.has('redis.url')) connectRedis(config.get('redis.url'));
+     * ```
+     */
+    has(path: Path<TConfig>): boolean;
+    /**
+     * Resolve a two-level dot-path to its raw leaf value.
+     *
+     * Looks the path up in the precomputed `namespace.leaf` map, so an unset leaf
+     * (or, defensively, an unexpected path) yields `undefined` instead of throwing.
+     *
+     * @param path - The declared two-level dot-path.
+     * @returns The leaf value as `unknown`, or `undefined` when the leaf is unset.
+     */
+    private resolve;
+}
+
+/**
+ * @fileoverview Symbol dependency-injection tokens for the configuration
+ * module. Both tokens are module-local Symbols, never strings and never
+ * registered in the global symbol registry, so their identity is unique across
+ * realms and cannot collide with another provider's token. Every injection site
+ * references these constants through an explicit `@Inject(...)`.
+ * @layer Constants
+ */
+/**
+ * Injection token for the resolved {@link BymaxConfigModuleOptions}.
+ *
+ * The `forRoot` value provider and the `forRootAsync` factory both register the
+ * options object under this token; the config provider factory injects it to
+ * read the schema, source, hook, and strict flag.
+ *
+ * @example
+ * ```typescript
+ * constructor(@Inject(BYMAX_CONFIG_OPTIONS) options: BymaxConfigModuleOptions) {}
+ * ```
+ */
+declare const BYMAX_CONFIG_OPTIONS: unique symbol;
+/**
+ * Injection token for the deep-frozen, validated configuration object.
+ *
+ * The provider factory registers the parsed, frozen config under this token and
+ * the module exports it, so consumers (and the typed accessor) can inject the
+ * validated config directly for factory-style wiring.
+ *
+ * @example
+ * ```typescript
+ * constructor(@Inject(BYMAX_CONFIG) config: Readonly<AppConfig>) {}
+ * ```
+ */
+declare const BYMAX_CONFIG: unique symbol;
+
+/**
+ * @fileoverview The `defineEnv` factory: a thin, typed wrapper over
+ * `z.object(...)` that establishes the two-level namespace convention of the
+ * package and exposes the inferred configuration type through a phantom
+ * accessor. It composes the caller's schemas as-is and never rewrites, clones,
+ * or wraps them, so coercion and defaults stay explicit consumer choices.
+ * @layer Utility
+ */
+
+/**
+ * Compose environment namespaces into a single typed schema.
+ *
+ * Wraps the passed shape in `z.object(...)` and returns it augmented with the
+ * `infer` phantom accessor, so the configuration type is extracted ergonomically
+ * via `typeof schema.infer`. The caller's namespace and leaf schemas are reused
+ * unchanged: `defineEnv` documents and encourages `z.coerce.*` for the
+ * string-shaped environment, but never injects coercion or defaults itself.
+ *
+ * @typeParam TShape - The two-level shape: namespace keys mapped to Zod objects.
+ * @param shape - Top-level namespaces, each a Zod object of leaf schemas.
+ * @returns The composed Zod object schema carrying the `infer` type helper.
+ * @example
+ * ```typescript
+ * import { defineEnv } from '@bymax-one/nest-config';
+ * import { z } from 'zod';
+ *
+ * export const envSchema = defineEnv({
+ *   server: z.object({
+ *     port: z.coerce.number().int().min(1).max(65535).default(3000),
+ *   }),
+ *   database: z.object({ url: z.url() }),
+ * });
+ *
+ * export type AppConfig = typeof envSchema.infer;
+ * ```
+ */
+declare function defineEnv<TShape extends EnvShape>(shape: TShape): EnvSchema<TShape>;
+
+/**
+ * @fileoverview The BYMAX_CONFIG provider factory: the fail-fast heart of the
+ * module. It resolves the source (defaulting to `process.env`, using a custom
+ * source verbatim), runs the single-pass validator, and on success returns the
+ * deep-frozen typed config. On failure it invokes the value-free observability
+ * hook exactly once before rethrowing the aggregated error; the hook is
+ * observability only and can never suppress or replace the failure, so a
+ * misconfigured process is stopped before any consumer provider is constructed.
+ * @layer Provider
+ */
+
+/**
+ * Validate the source against the schema, freeze the result, or fail fast.
+ *
+ * Resolves the source to the supplied record or `process.env`, runs exactly one
+ * validation pass, and returns the deep-frozen typed output. On a validation
+ * failure the hook runs once with the issues and the aggregated error is
+ * rethrown unchanged, aborting module resolution before any consumer provider
+ * is instantiated.
+ *
+ * @typeParam TShape - The two-level schema shape.
+ * @param options - The resolved module options (schema, source, hook, strict).
+ * @returns The validated, deep-frozen configuration output.
+ * @throws {BymaxConfigValidationError} When the source fails the schema.
+ * @example
+ * ```typescript
+ * const config = createValidatedConfig({ schema: envSchema });
+ * config.server.port; // typed, validated, frozen
+ * ```
+ */
+declare function createValidatedConfig<TShape extends EnvShape>(options: Omit<BymaxConfigModuleOptions, 'schema'> & {
+    readonly schema: EnvSchema<TShape>;
+}): Readonly<EnvOutput<TShape>>;
+
+/**
+ * @fileoverview Deterministic mapping between nested config paths and flat
+ * environment variable names. Each leaf resolves to exactly one variable:
+ * SCREAMING_SNAKE_CASE of the joined path (`database.url` reads `DATABASE_URL`),
+ * unless the leaf declares a `meta({ env })` override, which wins. This is an
+ * internal module consumed by the validator; it is not part of the public API.
+ * @layer Utility
+ */
+
+/**
+ * The resolved binding between one config leaf and its source variable name.
+ */
+interface SourceBinding {
+    /** Nested config path, e.g. `database.url`. */
+    readonly path: string;
+    /** Resolved environment variable name, e.g. `DATABASE_URL`. */
+    readonly variable: string;
+}
+/**
+ * Resolve the source variable name of every leaf in a `defineEnv` schema.
+ *
+ * Walks the two-level schema (namespaces then leaves) and yields one binding
+ * per leaf. The variable name is the `meta({ env })` override when present,
+ * otherwise the SCREAMING_SNAKE_CASE derivation of the joined path. The result
+ * is total: every declared leaf maps to exactly one variable, in declaration
+ * order.
+ *
+ * @typeParam TShape - The two-level shape the schema was composed from.
+ * @param schema - A schema produced by `defineEnv`.
+ * @returns The ordered list of leaf-to-variable bindings, typed `readonly`.
+ * @example
+ * ```typescript
+ * const schema = defineEnv({ database: z.object({ url: z.url() }) });
+ * resolveSourceNames(schema);
+ * // => [{ path: 'database.url', variable: 'DATABASE_URL' }]
+ * ```
+ */
+declare function resolveSourceNames<TShape extends EnvShape = EnvShape>(schema: EnvSchema<TShape>): readonly SourceBinding[];
+
+export { BYMAX_CONFIG, BYMAX_CONFIG_OPTIONS, BymaxConfigModule, type BymaxConfigModuleOptions, BymaxConfigValidationError, ConfigErrorCode, type ConfigIssue, type ConfigIssueCode, ConfigService, type ConfigValidationCode, type EnvLeaf, type EnvNamespace, type EnvOutput, type EnvSchema, type EnvShape, type Path, type PathValue, type SourceBinding, createValidatedConfig, defineEnv, resolveSourceNames };