/**
 * Validate a triple pattern query
 *
 * @param {unknown} data - Data to validate
 * @returns {ValidationResult<{s?: string|null, p?: string|null, o?: string|null}>}
 *
 * @example
 * const result = validateTriplePattern({ s: 'http://example.org/alice' });
 * if (result.success) {
 *   const { s, p, o } = result.data;
 * }
 */
export function validateTriplePattern(data: unknown): ValidationResult<{
    s?: string | null;
    p?: string | null;
    o?: string | null;
}>;
/**
 * Validate an RPC call message
 *
 * @param {unknown} data - Data to validate
 * @returns {ValidationResult<{target: string, module: string, function: string, args: any[]}>}
 *
 * @example
 * const result = validateRPCCall({
 *   target: 'node1',
 *   module: 'graph',
 *   function: 'query',
 *   args: []
 * });
 */
export function validateRPCCall(data: unknown): ValidationResult<{
    target: string;
    module: string;
    function: string;
    args: any[];
}>;
/**
 * Validate an RPC result message
 *
 * @param {unknown} data - Data to validate
 * @returns {ValidationResult<{ok: boolean, result: any, error?: string|null}>}
 *
 * @example
 * const result = validateRPCResult({ ok: true, result: { count: 10 } });
 */
export function validateRPCResult(data: unknown): ValidationResult<{
    ok: boolean;
    result: any;
    error?: string | null;
}>;
/**
 * Validate a SPARQL query message
 *
 * @param {unknown} data - Data to validate
 * @returns {ValidationResult<{query: string, params?: Record<string, any>|null}>}
 *
 * @example
 * const result = validateSPARQLQuery({
 *   query: 'SELECT * WHERE { ?s ?p ?o }',
 *   params: { limit: 100 }
 * });
 */
export function validateSPARQLQuery(data: unknown): ValidationResult<{
    query: string;
    params?: Record<string, any> | null;
}>;
/**
 * Validate a batch operation message
 *
 * @param {unknown} data - Data to validate
 * @returns {ValidationResult<{operation: string, triples: Array, transactionId?: string|null}>}
 *
 * @example
 * const result = validateBatchOperation({
 *   operation: 'insert',
 *   triples: [{ s: 'http://example.org/alice', p: 'http://xmlns.com/foaf/0.1/name', o: 'Alice' }]
 * });
 */
export function validateBatchOperation(data: unknown): ValidationResult<{
    operation: string;
    triples: any[];
    transactionId?: string | null;
}>;
/**
 * Validate a health check message
 *
 * @param {unknown} data - Data to validate
 * @returns {ValidationResult<{nodeId: string, timestamp: number, status: string, metrics?: Object}>}
 *
 * @example
 * const result = validateHealthCheck({
 *   nodeId: 'node-1',
 *   timestamp: Date.now(),
 *   status: 'healthy'
 * });
 */
export function validateHealthCheck(data: unknown): ValidationResult<{
    nodeId: string;
    timestamp: number;
    status: string;
    metrics?: any;
}>;
/**
 * Validate data against any registered schema
 *
 * @param {string} schemaType - Schema type key from messageSchemas
 * @param {unknown} data - Data to validate
 * @returns {ValidationResult<any>}
 *
 * @example
 * const result = validateMessage('rpcCall', { target: 'node1', ... });
 */
export function validateMessage(schemaType: string, data: unknown): ValidationResult<any>;
/**
 * Validate triple pattern strictly (throws on error)
 *
 * @param {unknown} data - Data to validate
 * @returns {{s?: string|null, p?: string|null, o?: string|null}} Validated data
 * @throws {Error} If validation fails
 */
export function parseTriplePattern(data: unknown): {
    s?: string | null;
    p?: string | null;
    o?: string | null;
};
/**
 * Validate RPC call strictly (throws on error)
 *
 * @param {unknown} data - Data to validate
 * @returns {{target: string, module: string, function: string, args: any[]}} Validated data
 * @throws {Error} If validation fails
 */
export function parseRPCCall(data: unknown): {
    target: string;
    module: string;
    function: string;
    args: any[];
};
/**
 * Validate RPC result strictly (throws on error)
 *
 * @param {unknown} data - Data to validate
 * @returns {{ok: boolean, result: any, error?: string|null}} Validated data
 * @throws {Error} If validation fails
 */
export function parseRPCResult(data: unknown): {
    ok: boolean;
    result: any;
    error?: string | null;
};
/**
 * Validate SPARQL query strictly (throws on error)
 *
 * @param {unknown} data - Data to validate
 * @returns {{query: string, params?: Record<string, any>|null}} Validated data
 * @throws {Error} If validation fails
 */
export function parseSPARQLQuery(data: unknown): {
    query: string;
    params?: Record<string, any> | null;
};
/**
 * Create a validation wrapper for circuit breaker integration
 * Validates incoming messages before execution
 *
 * @param {string} schemaType - Schema type to validate against
 * @returns {Function} Validation middleware function
 *
 * @example
 * import { CircuitBreaker } from './orchestration/circuit-breaker.mjs';
 * import { createValidationMiddleware } from './message-validator.mjs';
 *
 * const breaker = new CircuitBreaker({ name: 'rpc-handler' });
 * const validateRPC = createValidationMiddleware('rpcCall');
 *
 * async function handleRPCCall(message) {
 *   const validated = validateRPC(message);
 *   return await breaker.execute(() => processRPC(validated));
 * }
 */
export function createValidationMiddleware(schemaType: string): Function;
/**
 * Wrap a function with message validation
 * Validates the first argument before calling the wrapped function
 *
 * @param {Function} fn - Function to wrap
 * @param {string} schemaType - Schema type to validate against
 * @returns {Function} Wrapped function with validation
 *
 * @example
 * const processRPC = withValidation(
 *   async (call) => {
 *     // call is guaranteed to be valid
 *     return await executeRPC(call);
 *   },
 *   'rpcCall'
 * );
 */
export function withValidation(fn: Function, schemaType: string): Function;
/**
 * Collection of all message schemas for external access
 * @type {Object}
 */
export const messageSchemas: any;
/**
 * Validation result type
 */
export type ValidationResult = {
    /**
     * - Whether validation passed
     */
    success: boolean;
    /**
     * - Validated and typed data (if success)
     */
    data?: T;
    /**
     * - Error message (if failure)
     */
    error?: string;
    /**
     * - Original Zod error (if failure)
     */
    zodError?: z.ZodError;
};
import { z } from 'zod';