import { Json } from "./json.js";
import { OneOf } from "./oneof.js";
import { Record as RecordBuilder } from "./record.js";
import { Union } from "./union.js";
import { validate } from "./validate.js";
import type { JsonValue, JsonValueSchema } from "./json.js";
import type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
import type { OneOfSchema } from "./oneof.js";
import type { RecordSchema } from "./record.js";
import type { UnionSchema } from "./union.js";
import type { ValidationIssue, ValidationResult } from "./validate.js";
type JsonSchemaType = "string" | "number" | "integer" | "boolean" | "array" | "object";
type SchemaKind = "string" | "number" | "boolean" | "enum" | "array" | "object" | "optional" | "oneOf" | "union" | "record" | "json";
type EnumValue = string | number | boolean;
type JsonSchemaEnumValue = EnumValue | null;
type NumberJsonType = "number" | "integer";
type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
type ObjectShape = Record<string, AnySchema>;
type EmptyOptions = Record<never, never>;
type SchemaScope = "cli" | "mcp" | "sdk";
export type CliOutputMode = "rich" | "md" | "json";
export interface CliMissingParameterChoice<TValue> {
    label: string;
    value: TValue;
}
export interface CliMissingParameterContext {
    commandPath: string;
    params: Readonly<Record<string, unknown>>;
    output: CliOutputMode;
    stdinTTY: boolean;
    stdoutTTY: boolean;
}
export interface CliMissingParameterResolution<TValue> {
    choices: readonly CliMissingParameterChoice<TValue>[];
    message?: string;
}
export interface CliSchemaOptions<TValue> {
    resolveMissing?: (context: CliMissingParameterContext) => CliMissingParameterResolution<TValue> | undefined | Promise<CliMissingParameterResolution<TValue> | undefined>;
}
type StringMetadata = {
    format?: string;
    maxLength?: number;
    minLength?: number;
    pattern?: string;
    secret?: boolean;
};
type NumberMetadata = {
    maximum?: number;
    minimum?: number;
    secret?: boolean;
};
type ArrayMetadata = {
    maxItems?: number;
    minItems?: number;
};
type ObjectMetadata = {
    additionalProperties?: boolean;
};
type OptionalKeys<TShape extends ObjectShape> = {
    [TKey in keyof TShape]: TShape[TKey] extends OptionalSchema<any> ? TKey : never;
}[keyof TShape];
type RequiredKeys<TShape extends ObjectShape> = Exclude<keyof TShape, OptionalKeys<TShape>>;
type PropertyStatic<TSchema extends AnySchema> = TSchema extends OptionalSchema<infer TInner> ? Static<TInner> : Static<TSchema>;
type InferObject<TShape extends ObjectShape> = {
    [TKey in RequiredKeys<TShape>]: PropertyStatic<TShape[TKey]>;
} & {
    [TKey in OptionalKeys<TShape>]?: PropertyStatic<TShape[TKey]>;
};
type SchemaOptions<TDefault> = {
    cli?: CliSchemaOptions<TDefault>;
    description?: string;
    cliDescription?: string;
    cliAliases?: readonly string[];
    default?: TDefault;
    nullable?: boolean;
    requiredScopes?: readonly SchemaScope[];
    short?: string;
    scope?: readonly SchemaScope[];
    global?: boolean;
};
type WithNullable<TSchema extends AnySchema, TOptions extends {
    nullable?: boolean;
}> = TOptions extends {
    readonly nullable: true;
} ? TSchema & {
    readonly nullable: true;
} : TSchema;
export interface SchemaBase<TKind extends SchemaKind, TStatic> {
    readonly kind: TKind;
    readonly cli?: CliSchemaOptions<TStatic>;
    readonly description?: string;
    readonly cliDescription?: string;
    readonly cliAliases?: readonly string[];
    readonly default?: TStatic;
    readonly nullable?: boolean;
    readonly requiredScopes?: readonly SchemaScope[];
    readonly short?: string;
    readonly scope?: readonly SchemaScope[];
    readonly global?: boolean;
    readonly __static?: TStatic;
}
export interface JsonSchema {
    additionalProperties?: boolean | JsonSchema;
    type?: JsonSchemaType;
    description?: string;
    default?: unknown;
    enum?: ReadonlyArray<JsonSchemaEnumValue>;
    format?: string;
    items?: JsonSchema;
    maxItems?: number;
    maximum?: number;
    maxLength?: number;
    minItems?: number;
    minimum?: number;
    minLength?: number;
    nullable?: boolean;
    oneOf?: JsonSchema[];
    pattern?: string;
    properties?: Record<string, JsonSchema>;
    required?: string[];
}
export interface StringSchema extends SchemaBase<"string", string>, StringMetadata {
}
export interface NumberSchema extends SchemaBase<"number", number>, NumberMetadata {
    readonly jsonType?: NumberJsonType;
}
export type BooleanSchema = SchemaBase<"boolean", boolean>;
export interface EnumSchema<TValues extends NonEmptyReadonlyArray<EnumValue>> extends SchemaBase<"enum", TValues[number]> {
    readonly values: TValues;
    readonly jsonType?: "integer";
    readonly labels?: Partial<Record<string, string>>;
    readonly loadOptions?: (() => Array<{
        label: string;
        value: string;
    }>) | (() => Promise<Array<{
        label: string;
        value: string;
    }>>);
}
export interface ArraySchema<TItem extends AnySchema> extends SchemaBase<"array", Array<Static<TItem>>>, ArrayMetadata {
    readonly item: TItem;
}
export interface ObjectSchema<TShape extends ObjectShape> extends SchemaBase<"object", InferObject<TShape>>, ObjectMetadata {
    readonly shape: TShape;
}
export interface OptionalSchema<TInner extends AnySchema> extends SchemaBase<"optional", Static<TInner> | undefined> {
    readonly inner: TInner;
}
export type AnySchema = StringSchema | NumberSchema | BooleanSchema | EnumSchema<NonEmptyReadonlyArray<EnumValue>> | ArraySchema<AnySchema> | ObjectSchema<ObjectShape> | OptionalSchema<AnySchema> | OneOfSchema<Record<string, ObjectSchema<any>>, string> | UnionSchema<readonly ObjectSchema<any>[]> | RecordSchema<AnySchema> | JsonValueSchema;
export type Static<TSchema extends AnySchema> = TSchema extends {
    readonly nullable: true;
} ? TSchema extends SchemaBase<any, infer TStatic> ? TStatic | null : never : TSchema extends SchemaBase<any, infer TStatic> ? TStatic : never;
export declare const S: {
    readonly String: <const TOptions extends SchemaOptions<string> & StringMetadata = EmptyOptions>(options?: TOptions) => WithNullable<StringSchema, TOptions>;
    readonly Number: <const TOptions extends SchemaOptions<number> & NumberMetadata & {
        jsonType?: NumberJsonType;
    } = EmptyOptions>(options?: TOptions) => WithNullable<NumberSchema, TOptions>;
    readonly Boolean: <const TOptions extends SchemaOptions<boolean> = EmptyOptions>(options?: TOptions) => WithNullable<BooleanSchema, TOptions>;
    readonly Enum: <const TValues extends NonEmptyReadonlyArray<EnumValue>, const TOptions extends SchemaOptions<TValues[number]> & {
        jsonType?: "integer";
        labels?: Partial<Record<string, string>>;
        loadOptions?: (() => Array<{
            label: string;
            value: string;
        }>) | (() => Promise<Array<{
            label: string;
            value: string;
        }>>);
    } = EmptyOptions>(values: TValues, options?: TOptions) => WithNullable<EnumSchema<TValues>, TOptions>;
    readonly Array: <TItem extends AnySchema, const TOptions extends SchemaOptions<Array<Static<TItem>>> & ArrayMetadata = EmptyOptions>(item: TItem, options?: TOptions) => WithNullable<ArraySchema<TItem>, TOptions>;
    readonly Object: <const TShape extends ObjectShape, const TOptions extends SchemaOptions<InferObject<TShape>> & ObjectMetadata = EmptyOptions>(shape: TShape, options?: TOptions) => WithNullable<ObjectSchema<TShape>, TOptions>;
    readonly Optional: <TInner extends AnySchema>(inner: TInner) => OptionalSchema<TInner>;
    readonly OneOf: typeof OneOf;
    readonly Union: typeof Union;
    readonly Record: typeof RecordBuilder;
    readonly Json: typeof Json;
};
export declare function toJsonSchema(schema: AnySchema): JsonSchema;
export declare function toJsonSchemaDocument(schema: AnySchema, options?: JsonSchemaDocumentOptions): JsonSchemaDocument;
export { Json, OneOf, RecordBuilder as Record, Union, validate };
export { compileJsonSchema, formatIssues } from "./json-schema/index.js";
export type { CompileJsonSchemaOptions, CompiledJsonSchema } from "./json-schema/index.js";
export type { JsonSchemaDocument, JsonSchemaDocumentOptions } from "./json-schema-document.js";
export type { JsonValue, JsonValueSchema, OneOfSchema, RecordSchema, UnionSchema, ValidationIssue, ValidationResult };