import type { JTDSchemaJson, SignalDescriptorJson, SignalFormatJson } from '../api';
/** Generate a fuzzed (sample) value from a JTD schema. */
export declare function fuzzJTD(schema: JTDSchemaJson, definitions?: Record<string, JTDSchemaJson>, _depth?: number): unknown;
/**
 * Validate a value against a JTD schema, returning an array of error messages.
 * Delegates to the `jtd` npm package for spec-compliant validation.
 */
export declare function validateValueAgainstJTD(schema: JTDSchemaJson, value: unknown, definitions?: Record<string, JTDSchemaJson>): string[];
/** Validate a JSON value against a single SignalFormatJson. */
export declare function validateValueAgainstSignal(format: SignalFormatJson, jsonValue: unknown): string[];
/** Validate a JSON value against a SignalDescriptorJson (valid if value matches ANY JTD format). */
export declare function validateValueAgainstSignal(descriptor: SignalDescriptorJson, jsonValue: unknown): string[];
/**
 * Convert JTD (JSON Type Definition) schema to JSON Schema for validation.
 *
 * Supports all 8 JTD schema forms per RFC 8927:
 * - Empty form: {}
 * - Ref form: { ref: "..." }
 * - Type form: { type: "..." }
 * - Enum form: { enum: [...] }
 * - Elements form: { elements: {...} }
 * - Properties form: { properties: {...}, optionalProperties: {...} }
 * - Values form: { values: {...} }
 * - Discriminator form: { discriminator: "...", mapping: {...} }
 */
export declare function jtdToJsonSchema(jtdSchema: JTDSchemaJson, definitions?: Record<string, JTDSchemaJson>, isRoot?: boolean): any;
export interface UniversalJsonSchema {
    type?: string | string[];
    title?: string;
    description?: string;
    enum?: (string | number | null)[];
    format?: 'date-time' | 'date' | 'time';
    properties?: Record<string, UniversalJsonSchema>;
    required?: string[];
    additionalProperties?: false;
    items?: UniversalJsonSchema;
}
export interface ConversionSuccess {
    success: true;
    schema: UniversalJsonSchema;
}
export interface ConversionFailure {
    success: false;
    error: string;
}
export type ConversionResult = ConversionSuccess | ConversionFailure;
/** Convert JTD schema to Universal JSON Schema compatible with Claude, Gemini, and OpenAI. */
export declare function jtdToUniversalJsonSchema(jtdSchema: JTDSchemaJson): ConversionResult;
export declare const MAX_VALIDATION_DEPTH = 32;
export declare const MAX_VALIDATION_ERRORS = 100;
/** Validate that the input is a valid JTD schema. */
export declare function validateJTDSchema(schema: unknown): {
    valid: true;
    schema: JTDSchemaJson;
} | {
    valid: false;
    error: string;
};
/**
 * Validate that the input is a valid JTD schema compatible with universal JSON schema
 * (Anthropic Claude, Google Gemini, and OpenAI structured outputs).
 */
export declare function validateUniversalJTD(schema: unknown): {
    valid: true;
    schema: JTDSchemaJson;
} | {
    valid: false;
    error: string;
};
/** Parse and validate a JSON string. */
export declare function validateJSON(jsonString: string): {
    valid: boolean;
    data?: unknown;
    error?: string;
};
/** Parse a JSON string and validate it as a JTD schema. */
export declare function validateJTDSchemaString(schemaString: string): {
    valid: true;
    schema: JTDSchemaJson;
} | {
    valid: false;
    error: string;
};
/** Parse a JSON string and validate it as a universal JTD schema (compatible with Claude, Gemini, OpenAI). */
export declare function validateUniversalJTDSchemaString(schemaString: string): {
    valid: true;
    schema: JTDSchemaJson;
} | {
    valid: false;
    error: string;
};
/**
 * Monaco editor JSON schema configuration for JTD schemas compatible with
 * Anthropic Claude, Google Gemini, and OpenAI structured outputs.
 * This is a restricted subset of JTD that excludes discriminator unions, refs, and values (dictionaries).
 */
export declare const UNIVERSAL_JTD_SCHEMA_CONFIG: {
    uri: string;
    fileMatch: string[];
    schema: {
        $schema: string;
        title: string;
        description: string;
        type: string;
        properties: {
            type: {
                description: string;
                enum: string[];
            };
            enum: {
                description: string;
                type: string;
                items: {
                    type: string;
                };
                minItems: number;
            };
            elements: {
                description: string;
                $ref: string;
            };
            properties: {
                description: string;
                type: string;
                additionalProperties: {
                    $ref: string;
                };
            };
            optionalProperties: {
                description: string;
                type: string;
                additionalProperties: {
                    $ref: string;
                };
            };
            nullable: {
                description: string;
                type: string;
            };
            metadata: {
                description: string;
                type: string;
                properties: {
                    title: {
                        type: string;
                        description: string;
                    };
                    description: {
                        type: string;
                        description: string;
                    };
                };
                additionalProperties: boolean;
            };
        };
    };
};
/** Monaco editor JSON schema configuration for JTD schema IntelliSense and validation. */
export declare const JTD_SCHEMA_CONFIG: {
    uri: string;
    fileMatch: string[];
    schema: {
        $schema: string;
        type: string;
        properties: {
            type: {
                description: string;
                enum: string[];
            };
            enum: {
                description: string;
                type: string;
                items: {
                    type: string;
                };
            };
            elements: {
                description: string;
                $ref: string;
            };
            properties: {
                description: string;
                type: string;
                additionalProperties: {
                    $ref: string;
                };
            };
            optionalProperties: {
                description: string;
                type: string;
                additionalProperties: {
                    $ref: string;
                };
            };
            values: {
                description: string;
                $ref: string;
            };
            discriminator: {
                description: string;
                type: string;
            };
            mapping: {
                description: string;
                type: string;
                additionalProperties: {
                    $ref: string;
                };
            };
            ref: {
                description: string;
                type: string;
            };
            definitions: {
                description: string;
                type: string;
                additionalProperties: {
                    $ref: string;
                };
            };
            nullable: {
                description: string;
                type: string;
            };
            metadata: {
                description: string;
                type: string;
            };
            additionalProperties: {
                description: string;
                type: string;
            };
        };
    };
};
//# sourceMappingURL=index.d.ts.map