@layerfig/config/dist/index.d.ts

Layer and runtime-validate type-safe configs for JavaScript apps.

import { z, z as z$1 } from "zod";
import { z as z$2 } from "zod/mini";

//#region src/types.d.ts
interface ResultSuccess<TSuccess = undefined> {
  ok: true;
  data: TSuccess;
}
interface ResultError<TError = undefined> {
  ok: false;
  error?: TError;
}
type Result<TSuccess = undefined, TError = undefined> = ResultSuccess<TSuccess> | ResultError<TError>;
type PartialDeepUnknown<T> = { [K in keyof T]?: T[K] extends Record<string, unknown> ? T[K] extends unknown[] ? unknown : T[K] extends Date ? unknown : T[K] extends Function ? unknown : PartialDeepUnknown<T[K]> : unknown };
/**
 * Utility type to resolves complex types (specially the ones with intersection types)
 * to a more readable format.
 */
type Prettify<T> = { [K in keyof T]: T[K] } & {};
declare const RuntimeEnv: z$2.ZodMiniPipe<z$2.ZodMiniTransform<{}, unknown>, z$2.ZodMiniRecord<z$2.ZodMiniString<string>, z$2.ZodMiniUnion<readonly [z$2.ZodMiniBoolean<boolean>, z$2.ZodMiniNull, z$2.ZodMiniNumber<number>, z$2.ZodMiniString<string>, z$2.ZodMiniUndefined]>>>;
type RuntimeEnv = z$2.output<typeof RuntimeEnv>;
type UnknownRecord = Record<string, unknown>;
interface BaseConfigBuilderOptions {
  /**
   * Prefix used to search for slotted values
   * @default "$"
   */
  slotPrefix?: string;
}
interface ClientConfigBuilderOptions<T extends object = UnknownRecord> extends BaseConfigBuilderOptions {
  /**
   * The runtime environment variables to use (e.g., import.meta.env, object, etc.)
   * @default import.meta.env or {}
   */
  runtimeEnv?: RuntimeEnv;
  /**
   * A function to validate the configuration object.
   * @param config - The configuration object to be validated
   * @param z - The zod 4 (mini) instance
   */
  validate: (config: UnknownRecord, z: typeof z$2) => T;
}
type ValidatedClientConfigBuilderOptions<T extends object = UnknownRecord> = Required<ClientConfigBuilderOptions<T>>;
interface ServerConfigBuilderOptions<T extends object = UnknownRecord> extends BaseConfigBuilderOptions {
  /**
   * The absolute path to the folder where the configuration files are located.
   * @default "<process.cwd()>/config"
   */
  absoluteConfigFolderPath?: string;
  /**
   * The runtime environment variables to use (e.g., process.env, import.meta.env, etc.)
   * @default process.env
   */
  runtimeEnv?: RuntimeEnv;
  /**
   * Load source from different source types
   *
   * @default basicJsonParser
   */
  parser?: ConfigParser;
  /**
   * A function to validate the configuration object.
   * @param config - The configuration object to be validated
   * @param z - The zod 4 instance
   */
  validate: (config: Record<string, unknown>, z: typeof z$1) => T;
}
type ValidatedServerConfigBuilderOptions<T extends object = UnknownRecord> = Required<ServerConfigBuilderOptions<T>>;
type LoadSourceOptions<T extends object = UnknownRecord> = ValidatedClientConfigBuilderOptions<T> | ValidatedServerConfigBuilderOptions<T>;
//#endregion
//#region src/parser/config-parser.d.ts
/**
 * Abstract class for parsing configuration files.
 * It defines the interface for loading configuration data
 * and checks if a file extension is accepted.
 */
declare abstract class ConfigParser {
  acceptedFileExtensions: string[];
  abstract load(fileContent: string): Result<Record<string, unknown>, Error>;
  constructor(options: {
    acceptedFileExtensions: string[];
  });
  acceptsExtension(fileExtension: string): boolean;
}
//#endregion
//#region src/sources/source.d.ts
declare abstract class Source<T = Record<string, unknown>> {
  #private;
  /**
   * An abstract method that must be implemented by any subclass.
   * It defines the contract for loading a source.
   * @param loadSourceOptions - The options for loading the source.
   * @returns A record representing the loaded source data.
   */
  abstract loadSource(loadSourceOptions: LoadSourceOptions$1): Prettify<T>;
  maybeReplaceSlots<T>(options: MaybeReplaceSlotsOptions<T>): any;
}
type LoadSourceOptions$1 = Prettify<Required<ClientConfigBuilderOptions | ServerConfigBuilderOptions>>;
interface MaybeReplaceSlotsOptions<T = unknown> extends Pick<LoadSourceOptions$1, "runtimeEnv" | "slotPrefix"> {
  contentString: string;
  transform: (contentString: string) => T;
}
//#endregion
//#region src/sources/env-var.d.ts
declare class EnvironmentVariableSource extends Source {
  #private;
  constructor(options?: EnvironmentVariableSourceOptions);
  loadSource({
    runtimeEnv,
    slotPrefix
  }: Pick<LoadSourceOptions, "runtimeEnv" | "slotPrefix">): Record<string, unknown>;
}
interface EnvironmentVariableSourceOptions {
  /**
   * The environment variable prefix to use
   * @default 'APP
   */
  prefix?: string;
  /**
   * The separator to use between the prefix and the key
   * @default '_'
   */
  prefixSeparator?: string;
  /**
   * The separator to navigate the object
   * @default '__'
   */
  separator?: string;
}
declare const EnvironmentVariableSourceOptions: z$2.ZodMiniObject<{
  prefix: z$2.ZodMiniDefault<z$2.ZodMiniOptional<z$2.ZodMiniString<string>>>;
  prefixSeparator: z$2.ZodMiniDefault<z$2.ZodMiniOptional<z$2.ZodMiniString<string>>>;
  separator: z$2.ZodMiniDefault<z$2.ZodMiniOptional<z$2.ZodMiniString<string>>>;
}, z$2.core.$strip>;
//#endregion
//#region src/sources/object.d.ts
declare class ObjectSource<T extends object = Record<string, unknown>> extends Source<T> {
  #private;
  constructor(object: T);
  constructor(object: PartialDeepUnknown<T>);
  loadSource({
    slotPrefix,
    runtimeEnv
  }: Pick<LoadSourceOptions, "runtimeEnv" | "slotPrefix">): Prettify<T>;
}
//#endregion
//#region src/server/types.d.ts
type ConfigBuilderOptions<T extends object = UnknownRecord> = ServerConfigBuilderOptions<T>;
//#endregion
//#region src/server/config-builder.d.ts
declare class ConfigBuilder<T extends object = UnknownRecord> {
  #private;
  constructor(options: ConfigBuilderOptions<T>);
  build(): T;
  addSource(source: Source): this;
}
//#endregion
//#region src/server/file-source.d.ts
declare class FileSource extends Source {
  #private;
  constructor(fileName: string);
  loadSource(options: LoadSourceOptions): UnknownRecord;
}
//#endregion
export { ConfigBuilder, type ConfigBuilderOptions, ConfigParser, EnvironmentVariableSource, FileSource, ObjectSource, z };
//# sourceMappingURL=index.d.ts.map