import * as _$arktype from "arktype";
import { type } from "arktype";
import * as _$arktype_internal_keywords_string_ts0 from "arktype/internal/keywords/string.ts";
import * as _$arktype_internal_attributes_ts0 from "arktype/internal/attributes.ts";

//#region ../internal/scope/dist/index.d.ts
//#region src/root.d.ts
/**
 * The root scope for the ArkEnv library,
 * containing extensions to the ArkType scopes with ArkEnv-specific types
 * like `string.host` and `number.port`.
 */
declare const $: _$arktype.Scope<{
  string: _$arktype.Submodule<{
    trim: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.trim.$ & {
      " arkInferred": (In: string) => _$arktype_internal_attributes_ts0.To<string>;
    }>;
    normalize: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.normalize.$ & {
      " arkInferred": (In: string) => _$arktype_internal_attributes_ts0.To<string>;
    }>;
    root: string;
    alpha: string;
    alphanumeric: string;
    hex: string;
    base64: _$arktype.Submodule<{
      root: string;
      url: string;
    } & {
      " arkInferred": string;
    }>;
    capitalize: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.capitalize.$ & {
      " arkInferred": (In: string) => _$arktype_internal_attributes_ts0.To<string>;
    }>;
    creditCard: string;
    date: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.stringDate.$ & {
      " arkInferred": string;
    }>;
    digits: string;
    email: string;
    integer: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.stringInteger.$ & {
      " arkInferred": string;
    }>;
    ip: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.ip.$ & {
      " arkInferred": string;
    }>;
    json: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.stringJson.$ & {
      " arkInferred": string;
    }>;
    lower: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.lower.$ & {
      " arkInferred": (In: string) => _$arktype_internal_attributes_ts0.To<string>;
    }>;
    numeric: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.stringNumeric.$ & {
      " arkInferred": string;
    }>;
    regex: string;
    semver: string;
    upper: _$arktype.Submodule<{
      root: (In: string) => _$arktype_internal_attributes_ts0.To<string>;
      preformatted: string;
    } & {
      " arkInferred": (In: string) => _$arktype_internal_attributes_ts0.To<string>;
    }>;
    url: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.url.$ & {
      " arkInferred": string;
    }>;
    uuid: _$arktype.Submodule<_$arktype_internal_keywords_string_ts0.uuid.$ & {
      " arkInferred": string;
    }>;
    " arkInferred": string;
    host: string;
  }>;
  number: _$arktype.Submodule<{
    NaN: number;
    Infinity: number;
    root: number;
    integer: number;
    " arkInferred": number;
    epoch: number;
    safe: number;
    NegativeInfinity: number;
    port: number;
  }>;
}>;
type $ = (typeof $)["t"]; //#endregion
//#endregion
//#region ../internal/types/dist/helpers.d.ts
type Dict<T> = Record<string, T | undefined>;
//#endregion
//#region ../internal/types/dist/standard-schema.d.ts
/**
 * @see https://github.com/standard-schema/standard-schema/tree/3130ce43fdd848d9ab49dbb0458d04f18459961c/packages/spec
 *
 * Copied from standard-schema (MIT License)
 * Copyright (c) 2024 Colin McDannell
 */
/** The Standard Typed interface. This is a base type extended by other specs. */
interface StandardTypedV1<Input = unknown, Output = Input> {
  /** The Standard properties. */
  readonly "~standard": StandardTypedV1.Props<Input, Output>;
}
declare namespace StandardTypedV1 {
  /** The Standard Typed 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;
    /** Inferred types associated with the schema. */
    readonly types?: Types<Input, Output> | undefined;
  }
  /** The Standard Typed 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 Typed. */
  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
  /** Infers the output type of a Standard Typed. */
  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
}
/** 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> extends StandardTypedV1.Props<Input, Output> {
    /** Validates unknown input values. */
    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
  }
  /** 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;
    /** A falsy value for `issues` indicates success. */
    readonly issues?: undefined;
  }
  interface Options {
    /** Explicit support for additional vendor-specific parameters, if needed. */
    readonly libraryOptions?: Record<string, unknown> | 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 types interface. */
  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
  /** Infers the input type of a Standard. */
  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
  /** Infers the output type of a Standard. */
  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
}
//#endregion
//#region ../internal/types/dist/infer-type.d.ts
/**
 * Extract the inferred type from a schema definition.
 * Supports both ArkType type definitions and Standard Schema 1.0 validators.
 *
 * For Standard Schema validators (e.g., Zod, Valibot), extracts the output type.
 * For ArkType definitions, checks the call signature or type properties.
 *
 * @template T - The schema definition to infer from
 */
type InferType<T> = T extends StandardSchemaV1<infer _Input, infer Output> ? Output : T extends ((value: Dict<string>) => infer R) ? R extends type.errors ? never : R : T extends {
  t: infer U;
} ? U : T extends type.Any<infer U, infer _Scope> ? U : never;
//#endregion
//#region ../internal/types/dist/schema.d.ts
type SchemaShape = Record<string, unknown>;
//#endregion
//#region src/types.d.ts
/**
 * Shared type utilities for Next.js entry points.
 */
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
type ResolveExtendsElement<T> = [InferType<T>] extends [never] ? T : InferType<T>;
type MergeExtends<TExtends extends readonly unknown[] | undefined> = TExtends extends readonly unknown[] ? UnionToIntersection<ResolveExtendsElement<TExtends[number]>> : {};
//#endregion
export { $ as i, SchemaShape as n, Dict as r, MergeExtends as t };
//# sourceMappingURL=types-BzoNhHhq.d.ts.map