import { Value } from '@sinclair/typebox/value';
import type { TSchema } from '@sinclair/typebox';
import type { ValueErrorIterator } from '@sinclair/typebox/errors';
import type { FromSchema, JSONSchema } from 'json-schema-to-ts';
export type SyntaxRegistry = Record<string, string>;
export type PlainJsonSchemaEntry<K extends string = string> = readonly [K, JSONSchema];
export interface RemotePayload<S extends SyntaxRegistry = SyntaxRegistry, E extends readonly PlainJsonSchemaEntry[] = readonly PlainJsonSchemaEntry[]> {
    version: string;
    syntax: S;
    schemas: E;
}
export declare function fetchAndBuildPayload<S extends SyntaxRegistry>(url: string, fetchFn?: typeof fetch): Promise<RemotePayload<S, (readonly [keyof S & string, TSchema])[]>>;
/** Helper: identifies selector-like strings */
type _IsSelector<S extends string> = S extends `${string}selector${string}` | `${string}_selector${string}` ? true : false;
/**
 * `StripSelectorKeys` recursively:
 *  • removes object keys that look like selectors
 *  • removes *string values* that look like selectors (e.g. in string unions)
 *  • filters selector strings out of arrays/tuples
 */
export type StripSelectorKeys<T> = T extends readonly (infer U)[] ? Exclude<StripSelectorKeys<U>, never>[] : T extends object ? {
    [K in keyof T as K extends string ? _IsSelector<K> extends true ? never : K : K]: StripSelectorKeys<T[K]>;
} : T extends string ? (_IsSelector<T> extends true ? never : T) : T;
/**
 * Lightweight structural interface used to cast the heavy inferred client
 * object, preventing the compiler from expanding the full literal type.
 */
export interface TypeSafeClient<S extends Record<string, string>, E extends readonly (readonly [string, any])[]> {
    version: string;
    syntax: S;
    schemas: Record<E[number][0], TSchema>;
    check<K extends E[number][0]>(key: K, data: unknown): data is StripSelectorKeys<FromSchema<Extract<E[number], readonly [K, any]>[1]>>;
    assert<K extends E[number][0]>(key: K, data: unknown): asserts data is StripSelectorKeys<FromSchema<Extract<E[number], readonly [K, any]>[1]>>;
    validate<K extends E[number][0]>(key: K, data: unknown): {
        value: StripSelectorKeys<FromSchema<Extract<E[number], readonly [K, any]>[1]>>;
    } | {
        issues: ValueErrorIterator;
    };
    value: typeof Value;
    type: <K extends E[number][0]>(key: K) => StripSelectorKeys<FromSchema<Extract<E[number], readonly [K, any]>[1]>>;
}
/**
 * **For Block 2:** Creates a type-safe client.
 * This definitive version uses a simplified generic signature to prevent compiler errors
 * with large schema registries.
 */
export declare function createClient<T extends {
    version: string;
    syntax: Record<string, string>;
    schemas: readonly (readonly [string, any])[];
}>(payload: T): TypeSafeClient<T["syntax"], T["schemas"]>;
export {};