/**
 * Minimal `@sinclair/typebox` runtime compatibility shim.
 *
 * Historically the coding agent injected the real `@sinclair/typebox` (~5MB
 * dependency) into extensions, hooks, custom tools, and custom commands so
 * they could author parameter schemas as `Type.Object({ name: Type.String() })`.
 *
 * This module provides the subset those integrations depend on:
 *
 *   - TypeBox-style `Type.*` builders.
 *   - Runtime validation through `schema.safeParse(input)` and `schema.__validator(input)`.
 *   - Enumerable JSON Schema keywords so `{ ...schema }`, `JSON.stringify(schema)`,
 *     and `toolWireSchema({ parameters: schema })` all see the same schema.
 *
 * Internal validator fields and methods are intentionally non-enumerable. The
 * object should look like JSON Schema at every serialization/wire boundary and
 * like a small validator at runtime.
 */
export type TSchema = ArkSchema;
export type Static<T extends ArkSchema> = T["__infer"];
export type TAny = ArkSchema;
export type TUnknown = ArkSchema;
export type TNever = ArkSchema;
export type TNull = ArkSchema;
export type TString = ArkSchema;
export type TNumber = ArkSchema;
export type TInteger = ArkSchema;
export type TBoolean = ArkSchema;
export type TLiteral<_V extends string | number | boolean> = ArkSchema;
export type TArray<_E extends ArkSchema> = ArkSchema;
export type TObject<_P extends Record<string, ArkSchema> = Record<string, ArkSchema>> = ArkSchema;
export type TOptional<_E extends ArkSchema> = ArkSchema;
export type TUnion<_T extends readonly ArkSchema[] = readonly ArkSchema[]> = ArkSchema;
export type TEnum<_T extends readonly (string | number)[] = readonly (string | number)[]> = ArkSchema;
export type TRecord<_K extends ArkSchema, _V extends ArkSchema> = ArkSchema;
declare const VALIDATION_FAILURE: unique symbol;
interface ValidationFailure {
    message: string;
    readonly [VALIDATION_FAILURE]: true;
}
interface SafeParseSuccess {
    success: true;
    data: unknown;
}
interface SafeParseFailure {
    success: false;
    error: ValidationFailure;
}
/**
 * JSON-Schema-shaped object with non-enumerable runtime helpers.
 * Validators return the validated data or a marked `{ message }` failure.
 */
interface ArkSchema {
    __validator: (data: unknown) => unknown;
    __metadata?: Record<string, unknown>;
    __optional?: true;
    __properties?: Record<string, ArkSchema>;
    __additionalProperties?: boolean | ArkSchema;
    __infer?: unknown;
    __inner?: ArkSchema;
    safeParse(input: unknown): SafeParseSuccess | SafeParseFailure;
    toJSON(): Record<string, unknown>;
    [key: string]: unknown;
}
interface Meta {
    title?: string;
    description?: string;
    default?: unknown;
    examples?: unknown[];
    [key: string]: unknown;
}
interface StringOpts extends Meta {
    minLength?: number;
    maxLength?: number;
    pattern?: string;
    format?: string;
}
interface NumberOpts extends Meta {
    minimum?: number;
    maximum?: number;
    exclusiveMinimum?: number;
    exclusiveMaximum?: number;
    multipleOf?: number;
}
interface ArrayOpts extends Meta {
    minItems?: number;
    maxItems?: number;
    uniqueItems?: boolean;
}
interface ObjectOpts extends Meta {
    /**
     * TypeBox default: extra keys are preserved. Set `false` to reject unknowns,
     * `true` to allow any, or a schema to validate them.
     */
    additionalProperties?: boolean | ArkSchema;
}
declare function tString(opts?: StringOpts): ArkSchema;
declare function tNumber(opts?: NumberOpts): ArkSchema;
declare function tInteger(opts?: NumberOpts): ArkSchema;
declare function tBoolean(opts?: Meta): ArkSchema;
declare function tNull(opts?: Meta): ArkSchema;
declare function tAny(opts?: Meta): ArkSchema;
declare function tUnknown(opts?: Meta): ArkSchema;
declare function tNever(opts?: Meta): ArkSchema;
declare function tLiteral<V extends string | number | boolean>(value: V, opts?: Meta): ArkSchema;
declare function tUnion<T extends readonly ArkSchema[]>(schemas: T, opts?: Meta): ArkSchema;
declare function tIntersect(schemas: readonly ArkSchema[], opts?: Meta): ArkSchema;
declare function tEnum<T extends Record<string, string | number> | readonly (string | number)[]>(values: T, opts?: Meta): ArkSchema;
declare function tArray<E extends ArkSchema>(item: E, opts?: ArrayOpts): ArkSchema;
declare function tTuple(items: readonly ArkSchema[], opts?: Meta): ArkSchema;
declare function tObject<P extends Record<string, ArkSchema>>(properties: P, opts?: ObjectOpts): ArkSchema;
declare function tRecord<K extends ArkSchema, V extends ArkSchema>(key: K, value: V, opts?: Meta): ArkSchema;
declare function tOptional<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
declare function tNullable<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
declare function tReadonly<E extends ArkSchema>(schema: E): ArkSchema;
declare function tPartial<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
declare function tRequired<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
declare function tPick<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
declare function tOmit<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
declare function tComposite(objects: readonly ArkSchema[], opts?: Meta): ArkSchema;
export declare const Type: {
    readonly String: typeof tString;
    readonly Number: typeof tNumber;
    readonly Integer: typeof tInteger;
    readonly Boolean: typeof tBoolean;
    readonly Null: typeof tNull;
    readonly Any: typeof tAny;
    readonly Unknown: typeof tUnknown;
    readonly Never: typeof tNever;
    readonly Literal: typeof tLiteral;
    readonly Union: typeof tUnion;
    readonly Intersect: typeof tIntersect;
    readonly Enum: typeof tEnum;
    readonly Array: typeof tArray;
    readonly Tuple: typeof tTuple;
    readonly Object: typeof tObject;
    readonly Record: typeof tRecord;
    readonly Optional: typeof tOptional;
    readonly Nullable: typeof tNullable;
    readonly Readonly: typeof tReadonly;
    readonly Partial: typeof tPartial;
    readonly Required: typeof tRequired;
    readonly Pick: typeof tPick;
    readonly Omit: typeof tOmit;
    readonly Composite: typeof tComposite;
};
export type TypeBuilder = typeof Type;
/** Default namespace export so `import * as typebox from "./typebox.js"` still resolves the `Type` key. */
declare const _default: {
    Type: {
        readonly String: typeof tString;
        readonly Number: typeof tNumber;
        readonly Integer: typeof tInteger;
        readonly Boolean: typeof tBoolean;
        readonly Null: typeof tNull;
        readonly Any: typeof tAny;
        readonly Unknown: typeof tUnknown;
        readonly Never: typeof tNever;
        readonly Literal: typeof tLiteral;
        readonly Union: typeof tUnion;
        readonly Intersect: typeof tIntersect;
        readonly Enum: typeof tEnum;
        readonly Array: typeof tArray;
        readonly Tuple: typeof tTuple;
        readonly Object: typeof tObject;
        readonly Record: typeof tRecord;
        readonly Optional: typeof tOptional;
        readonly Nullable: typeof tNullable;
        readonly Readonly: typeof tReadonly;
        readonly Partial: typeof tPartial;
        readonly Required: typeof tRequired;
        readonly Pick: typeof tPick;
        readonly Omit: typeof tOmit;
        readonly Composite: typeof tComposite;
    };
};
export default _default;
