interface EnvSchema<TOutput = unknown> {
    parse(value: unknown): TOutput;
}
type EnvParser<TOutput = unknown> = EnvSchema<TOutput> | ((value: string | undefined, context: {
    key: string;
    scope: "server" | "public";
}) => TOutput);
type EnvShape = Record<string, EnvParser<any>>;
type InferEnvParser<TParser> = TParser extends EnvSchema<infer TOutput> ? TOutput : TParser extends (value: string | undefined, context: any) => infer TOutput ? TOutput : never;
type InferEnvShape<TShape> = TShape extends EnvShape ? {
    [K in keyof TShape]: InferEnvParser<TShape[K]>;
} : {};
interface FarmEnvConfig<TServer extends EnvShape = EnvShape, TPublic extends EnvShape = EnvShape> {
    server?: TServer;
    public?: TPublic;
}
interface ResolvedFarmEnv<TServer extends Record<string, any> = Record<string, unknown>, TPublic extends Record<string, any> = Record<string, unknown>> {
    server: TServer;
    public: TPublic;
}
type InferEnv<TConfig> = TConfig extends FarmEnvConfig<infer TServer, infer TPublic> ? ResolvedFarmEnv<InferEnvShape<TServer>, InferEnvShape<TPublic>> : ResolvedFarmEnv;
/**
 * Augmented by generated src/farm.d.ts for project-specific autocomplete.
 */
interface FarmEnvTypes {
}
type FarmServerEnv = FarmEnvTypes extends {
    server: infer TServer;
} ? TServer extends Record<string, any> ? TServer : Record<string, unknown> : Record<string, unknown>;
type FarmPublicEnv = FarmEnvTypes extends {
    public: infer TPublic;
} ? TPublic extends Record<string, any> ? TPublic : Record<string, unknown> : Record<string, unknown>;
type FarmTypedEnv = ResolvedFarmEnv<FarmServerEnv, FarmPublicEnv>;
declare function resolveEnv<TConfig extends FarmEnvConfig<any, any> | undefined>(config: TConfig, source?: Record<string, string | undefined>): InferEnv<NonNullable<TConfig>>;
declare function setEnv(env: ResolvedFarmEnv): void;
declare function getResolvedEnv<TEnv extends ResolvedFarmEnv = FarmTypedEnv>(): TEnv;
declare function getEnv<TServer extends Record<string, any> = FarmServerEnv>(): TServer;
declare function getEnv<TKey extends Extract<keyof FarmServerEnv, string>>(key: TKey): FarmServerEnv[TKey];
declare function getPublicEnv<TPublic extends Record<string, any> = FarmPublicEnv>(): TPublic;
declare function getPublicEnv<TKey extends Extract<keyof FarmPublicEnv, string>>(key: TKey): FarmPublicEnv[TKey];
declare const env: FarmServerEnv;
declare const serverEnv: Record<string, unknown>;
declare const publicEnv: FarmPublicEnv;

export { type EnvParser, type EnvSchema, type EnvShape, type FarmEnvConfig, type FarmEnvTypes, type FarmPublicEnv, type FarmServerEnv, type FarmTypedEnv, type InferEnv, type InferEnvParser, type InferEnvShape, type ResolvedFarmEnv, env, getEnv, getPublicEnv, getResolvedEnv, publicEnv, resolveEnv, serverEnv, setEnv };