import { RepoTherapyUtilBase } from './base.js';
import type RepoTherapy from './repo-therapy.js';
import type RTLogger from './logger.js';
import type { FilePath, ObjectDefinition } from './types.js';
import type { ValueTypeDefinition } from '../generated/types/value-types.js';
import type ObjectUtil from './object-util.js';
import type { RTValueTypeObject } from './value-type-definitions.js';
import type { ObjectMapper } from '../generated/types/object-util.js';
import type * as EnvDefinition from '../generated/types/env.js';
type FullBaseEnv<BaseEnv extends object = {}> = BaseEnv & {
    app?: string;
    appEnv: string;
};
export type Options<BaseEnv extends object = {}, AppEnv extends object = {}> = {
    definition: ReturnType<typeof RTEnv.define<BaseEnv>>;
    appDefinition?: ReturnType<typeof RTEnv.define<AppEnv>>;
    environment?: string;
    app?: string;
    mockWithDefault?: boolean;
};
export default class RTEnv<BaseEnv extends object = {}, AppEnv extends object = {}, CustomOptions extends object = {}> extends RepoTherapyUtilBase<{
    definition: Options['definition'];
    appDefinition?: Options['appDefinition'];
    mockWithDefault?: boolean;
    app?: string;
    environment?: string;
} & CustomOptions> {
    private _baseEnv;
    private _baseEnvRaw;
    protected readonly _baseEnvDefinition: ReturnType<RTValueTypeObject<FullBaseEnv<BaseEnv>>['chainable']>;
    protected readonly _appEnvDefinition?: ReturnType<RTValueTypeObject<AppEnv>['chainable']>;
    get baseEnv(): FullBaseEnv<BaseEnv>;
    get typeDefinition(): string;
    private _appEnv;
    private _appEnvRaw;
    get appEnv(): AppEnv;
    get env(): BaseEnv & {
        app?: string;
        appEnv: string;
    } & AppEnv;
    get appTypeDefinition(): string;
    private get _baseEnvPath();
    private get _appEnvPath();
    constructor(repoTherapy: RepoTherapy, options: Options<BaseEnv, AppEnv> & CustomOptions);
    protected _load<T extends object>(namespace: string, path: `${FilePath}/.env` | `${FilePath}/.env.${string}`, definition: ReturnType<RTValueTypeObject<T>['chainable']>): {
        data: T;
        rawData: T;
    };
    loadAppEnv(): void;
    static define<T extends object>(callback: (valueType: ValueTypeDefinition, objectUtil: ObjectUtil<ObjectMapper>, logger: RTLogger) => ObjectDefinition<T>): (repoTherapy: RepoTherapy, app?: string) => ObjectDefinition<T>;
    static loader(repoTherapy: RepoTherapy): Promise<RTEnv<Omit<EnvDefinition.BaseEnv, 'app' | 'appEnv'>, EnvDefinition.AppEnv>>;
    static generateTypeDefinition(repoTherapy: RepoTherapy): Promise<void>;
}
export {};
//# sourceMappingURL=env.d.ts.map