//#region src/standard.d.ts
/** The Standard Schema interface. */
interface StandardSchemaV1<Input = unknown, Output = Input> {
  /** The Standard Schema properties. */
  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
}
declare namespace StandardSchemaV1 {
  /** The Standard Schema properties interface. */
  interface Props<Input = unknown, Output = Input> {
    /** The version number of the standard. */
    readonly version: 1;
    /** The vendor name of the schema library. */
    readonly vendor: string;
    /** Validates unknown input values. */
    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
    /** Inferred types associated with the schema. */
    readonly types?: Types<Input, Output> | undefined;
  }
  /** The result interface of the validate function. */
  type Result<Output> = SuccessResult<Output> | FailureResult;
  /** The result interface if validation succeeds. */
  interface SuccessResult<Output> {
    /** The typed output value. */
    readonly value: Output;
    /** The non-existent issues. */
    readonly issues?: undefined;
  }
  /** The result interface if validation fails. */
  interface FailureResult {
    /** The issues of failed validation. */
    readonly issues: ReadonlyArray<Issue>;
  }
  /** The issue interface of the failure output. */
  interface Issue {
    /** The error message of the issue. */
    readonly message: string;
    /** The path of the issue, if any. */
    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
  }
  /** The path segment interface of the issue. */
  interface PathSegment {
    /** The key representing a path segment. */
    readonly key: PropertyKey;
  }
  /** The Standard Schema types interface. */
  interface Types<Input = unknown, Output = Input> {
    /** The input type of the schema. */
    readonly input: Input;
    /** The output type of the schema. */
    readonly output: Output;
  }
  /** Infers the input type of a Standard Schema. */
  type InferInput<Schema$1 extends StandardSchemaV1> = NonNullable<Schema$1["~standard"]["types"]>["input"];
  /** Infers the output type of a Standard Schema. */
  type InferOutput<Schema$1 extends StandardSchemaV1> = NonNullable<Schema$1["~standard"]["types"]>["output"];
}
/** A dictionary of Standard Schema objects mapping input keys to their corresponding schemas. */
type StandardSchemaDictionary<Input = Record<string, unknown>, Output extends Record<keyof Input, unknown> = Input> = { [K in keyof Input]-?: StandardSchemaV1<Input[K], Output[K]> };
declare namespace StandardSchemaDictionary {
  /** Infers the input types from a Standard Schema Dictionary. */
  type InferInput<T extends StandardSchemaDictionary> = { [K in keyof T]: StandardSchemaV1.InferInput<T[K]> };
  /** Infers the output types from a Standard Schema Dictionary. */
  type InferOutput<T extends StandardSchemaDictionary> = { [K in keyof T]: StandardSchemaV1.InferOutput<T[K]> };
}
//#endregion
//#region src/types.d.ts
/** Type for error messages that must be strings */
type ErrorMessage<T extends string> = T;
/** Creates a type where all properties are impossible to set */
type Impossible<T extends Record<string, any>> = Partial<Record<keyof T, never>>;
/** Merges two types, with B taking precedence over A */
type Merge<A, B> = Omit<A, keyof B> & B;
/** Simplifies a type by removing intersections and making it more readable */
type Simplify<T> = { [P in keyof T]: T[P] } & {};
/** Gets all keys from T that can be undefined */
type PossiblyUndefinedKeys<T> = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T];
/** Makes properties that can be undefined optional */
type UndefinedOptional<T> = Partial<Pick<T, PossiblyUndefinedKeys<T>>> & Omit<T, PossiblyUndefinedKeys<T>>;
/** Converts a readonly type to a mutable type */
type Mutable<T> = T extends Readonly<infer U> ? U : T;
/** Extracts the combined schema from validation options */
type ExtractExtendsArray<T> = T extends {
  extends?: infer E;
} ? E extends ExtendsFormat ? E : [] : [];
type Depth = 0 | 1 | 2 | 3 | 4;
type DefaultDepth = 2;
type Prev = [0, 0, 1, 2, 3];
type Dec<N extends Depth> = Prev[N];
type AsDictionary<T> = T extends object ? StandardSchemaDictionary<object, object> & T : StandardSchemaDictionary<object, object>;
type ExtractCombinedSchema<T, D extends Depth = DefaultDepth> = T extends ValidationOptions<PrefixFormat, infer Shared, infer Server, infer Client> ? CombinedSchema<AsDictionary<Reduce<ExtractExtendsArray<T>, StandardSchemaDictionary<object, object>, D>>, AsDictionary<CombinedSchema<Shared, Server, Client>>> : T extends Readonly<ValidationOptions<PrefixFormat, infer Shared, infer Server, infer Client>> ? CombinedSchema<AsDictionary<Reduce<ExtractExtendsArray<T>, StandardSchemaDictionary<object, object>, D>>, AsDictionary<CombinedSchema<Shared, Server, Client>>> : CombinedSchema<AsDictionary<Reduce<ExtractExtendsArray<T>, StandardSchemaDictionary<object, object>, D>>, AsDictionary<CombinedSchema<T extends {
  shared: infer S;
} ? S extends SharedFormat ? S : StandardSchemaDictionary<object, object> : StandardSchemaDictionary<object, object>, T extends {
  server: infer Sv;
} ? Sv extends ServerFormat ? Sv : StandardSchemaDictionary<object, object> : StandardSchemaDictionary<object, object>, T extends {
  client: infer C;
} ? C extends ClientFormat ? C : StandardSchemaDictionary<object, object> : StandardSchemaDictionary<object, object>>>>;
/** Reduces an array of schemas to a single schema */
type Reduce<Arr extends readonly unknown[] | unknown[], Acc extends StandardSchemaDictionary<object, object> = StandardSchemaDictionary<object, object>, D extends Depth = DefaultDepth> = D extends 0 ? Acc : Arr extends readonly [] | [] ? Acc : Arr extends readonly [infer Head, ...infer Tail] | [infer Head, ...infer Tail] ? Tail extends readonly unknown[] | unknown[] ? Mutable<Reduce<Tail, CombinedSchema<AsDictionary<Acc>, AsDictionary<ExtractCombinedSchema<Head, Dec<D>>>>, D>> : never : never;
type InferPresetOutput<T extends ExtendsFormat[number]> = StandardSchemaDictionary.InferOutput<ExtractCombinedSchema<T>>;
type CombinedSchema<Shared$1 extends SharedFormat = SharedFormat, Server$1 extends ServerFormat = ServerFormat, Client$1 extends ClientFormat = ClientFormat> = StandardSchemaDictionary<object, object> & Merge<Shared$1, Merge<Server$1, Client$1>>;
type PrefixFormat = string | undefined;
type SharedFormat = StandardSchemaDictionary<object, object>;
type ServerFormat = StandardSchemaDictionary<object, object>;
type ClientFormat = StandardSchemaDictionary<object, object>;
type ExtendsFormat = (Preset | Readonly<Preset>)[] | ReadonlyArray<Preset>;
type Preset<Prefix extends PrefixFormat = PrefixFormat, Shared$1 extends SharedFormat = SharedFormat, Server$1 extends ServerFormat = ServerFormat, Client$1 extends ClientFormat = ClientFormat, Extends extends ExtendsFormat = ExtendsFormat> = ValidationOptions<Prefix, Shared$1, Server$1, Client$1> & {
  id?: string;
  extends?: Extends;
};
type Schema = StandardSchemaV1<object, object>;
interface BaseOptions<Extends extends ExtendsFormat> {
  /**
   * Array of preset configurations to extend from.
   */
  extends?: Extends;
  /**
   * Whether to skip validation of environment variables.
   * @default false
   */
  skip?: boolean;
  /**
   * Whether to treat environment as server-side.
   * @default typeof window === "undefined" || "Deno" in window
   */
  isServer?: boolean;
  /**
   * Called when validation fails. By default the error is logged,
   * and an error is thrown telling what environment variables are invalid.
   */
  onError?: (issues: StandardSchemaV1.FailureResult["issues"]) => never;
  /**
   * Called when a server-side environment variable is accessed on the client.
   * By default an error is thrown.
   */
  onInvalidAccess?: (variable: string) => never;
}
interface LooseOptions<Extends extends ExtendsFormat> extends BaseOptions<Extends> {
  /**
   * Must be undefined when using loose options. Use `env` instead.
   */
  envStrict?: never;
  /**
   * What object holds the environment variables at runtime. This is usually
   * `process.env` or `import.meta.env`.
   * This doesn't enforce that all environment variables are set.
   */
  env?: Record<string, string | boolean | number | undefined>;
}
interface StrictOptions<Prefix extends PrefixFormat, Server$1 extends ServerFormat, Client$1 extends ClientFormat, Shared$1 extends SharedFormat, Extends extends ExtendsFormat> extends BaseOptions<Extends> {
  /**
   * Runtime Environment variables to use for validation - `process.env`, `import.meta.env` or similar.
   * Enforces all environment variables to be set. Required in for example Next.js Edge and Client runtimes.
   */
  envStrict?: Record<{ [Key in keyof Client$1]: Prefix extends undefined ? never : Key extends `${Prefix}${string}` ? Key : never }[keyof Client$1] | { [Key in keyof Server$1]: Prefix extends undefined ? Key : Key extends `${Prefix}${string}` ? never : Key }[keyof Server$1] | { [Key in keyof Shared$1]: Key extends string ? Key : never }[keyof Shared$1] | keyof StandardSchemaDictionary.InferOutput<FullSchemaShape<Shared$1, Server$1, Client$1, Extends>>, string | boolean | number | undefined>;
  /**
   * Must be undefined when using strict options. Use `envStrict` instead.
   */
  env?: never;
}
interface SharedOptions<Shared$1 extends SharedFormat> {
  /**
   * Specify your shared environment variables schema here. These variables are available on both client and server.
   */
  shared?: Shared$1;
}
interface ClientOptions<Prefix extends PrefixFormat, Client$1 extends ClientFormat> {
  /**
   * The prefix that client-side variables must have. This is enforced both at
   * a type-level and at runtime.
   */
  clientPrefix?: Prefix;
  /**
   * Specify your client-side environment variables schema here. This way you can ensure the app isn't
   * built with invalid env vars.
   */
  client?: Partial<{ [Key in keyof Client$1]: Key extends `${Prefix}${string}` ? Client$1[Key] : ErrorMessage<`${Key extends string ? Key : never} is not prefixed with ${Prefix}.`> }>;
}
interface ServerOptions<Prefix extends PrefixFormat, Server$1 extends ServerFormat> {
  /**
   * Specify your server-side environment variables schema here. This way you can ensure the app isn't
   * built with invalid env vars.
   */
  server: Partial<{ [Key in keyof Server$1]: Prefix extends undefined ? Server$1[Key] : Prefix extends "" ? Server$1[Key] : Key extends `${Prefix}${string}` ? ErrorMessage<`${Key extends `${Prefix}${string}` ? Key : never} should not prefixed with ${Prefix}.`> : Server$1[Key] }>;
}
type ValidationOptions<Prefix extends PrefixFormat = PrefixFormat, Shared$1 extends SharedFormat = SharedFormat, Server$1 extends ServerFormat = ServerFormat, Client$1 extends ClientFormat = ClientFormat> = ((ClientOptions<Prefix, Client$1> & ServerOptions<Prefix, Server$1>) | (ServerOptions<Prefix, Server$1> & Impossible<ClientOptions<never, never>>) | (ClientOptions<Prefix, Client$1> & Impossible<ServerOptions<never, never>>)) & SharedOptions<Shared$1>;
interface TransformSchemaOptions<Shared$1 extends SharedFormat, Server$1 extends ServerFormat, Client$1 extends ClientFormat, Extends extends ExtendsFormat, FinalSchema$1 extends Schema> {
  /**
   * A custom function to combine the schemas.
   * Can be used to add further refinement or transformation.
   */
  transform?: (shape: Simplify<FullSchemaShape<Shared$1, Server$1, Client$1, Extends>>, isServer: boolean) => FinalSchema$1;
}
type EnvOptions<Prefix extends PrefixFormat = PrefixFormat, Shared$1 extends SharedFormat = SharedFormat, Server$1 extends ServerFormat = ServerFormat, Client$1 extends ClientFormat = ClientFormat, Extends extends ExtendsFormat = ExtendsFormat, FinalSchema$1 extends Schema = Schema> = (LooseOptions<Extends> | StrictOptions<Prefix, Server$1, Client$1, Shared$1, Extends>) & ValidationOptions<Prefix, Shared$1, Server$1, Client$1> & TransformSchemaOptions<Shared$1, Server$1, Client$1, Extends, FinalSchema$1>;
type FullSchemaShape<Shared$1 extends SharedFormat, Server$1 extends ServerFormat, Client$1 extends ClientFormat, Extends extends ExtendsFormat, D extends Depth = DefaultDepth> = CombinedSchema<AsDictionary<Reduce<Extends, StandardSchemaDictionary<object, object>, D>>, CombinedSchema<Shared$1, Server$1, Client$1>>;
type FinalSchema<Shared$1 extends SharedFormat, Server$1 extends ServerFormat, Client$1 extends ClientFormat, Extends extends ExtendsFormat, D extends Depth = DefaultDepth> = StandardSchemaV1<object, UndefinedOptional<StandardSchemaDictionary.InferOutput<FullSchemaShape<Shared$1, Server$1, Client$1, Extends, D>>>>;
type DefineEnv<FinalSchema$1 extends Schema = Schema> = Simplify<Readonly<StandardSchemaV1.InferOutput<FinalSchema$1> & {
  _schema: FinalSchema$1;
}>>;
//#endregion
export { ValidationOptions as C, TransformSchemaOptions as S, ServerOptions as _, DefineEnv as a, Simplify as b, ExtendsFormat as c, InferPresetOutput as d, LooseOptions as f, ServerFormat as g, Schema as h, CombinedSchema as i, FinalSchema as l, Preset as m, ClientFormat as n, EnvOptions as o, PrefixFormat as p, ClientOptions as r, ErrorMessage as s, BaseOptions as t, FullSchemaShape as u, SharedFormat as v, StrictOptions as x, SharedOptions as y };