/**
 * Validation Error Classes
 *
 * This module provides error classes for validation-related failures.
 * These errors are thrown when configuration or input validation fails.
 *
 * @module declarative-api/errors/validation-errors
 */
import type { ValidationError } from '../../../lib/runtime-web/types/declarative-api/specification.types';
import { InfrastructureError } from './infrastructure-error';
/**
 * Error thrown when specification validation fails.
 *
 * Contains detailed validation errors with paths and messages.
 *
 * Validates: Requirements 11.4
 *
 * @example
 * ```typescript
 * try {
 *   builder.build();
 * } catch (error) {
 *   if (isSpecificationValidationError(error)) {
 *     for (const validationError of error.validationErrors) {
 *       console.log(`${validationError.path}: ${validationError.message}`);
 *     }
 *   }
 * }
 * ```
 */
export declare class SpecificationValidationError extends InfrastructureError {
    readonly validationErrors: readonly ValidationError[];
    readonly name: string;
    constructor(validationErrors: readonly ValidationError[], options?: {
        component?: string;
        operation?: string;
    });
    /**
     * Get validation errors filtered by severity.
     */
    getErrorsBySeverity(severity: 'error' | 'warning'): ValidationError[];
    /**
     * Get validation errors filtered by path prefix.
     */
    getErrorsByPath(pathPrefix: string): ValidationError[];
}
/**
 * Type guard for SpecificationValidationError.
 */
export declare function isSpecificationValidationError(error: unknown): error is SpecificationValidationError;
/**
 * Error thrown when a required field is missing.
 *
 * @example
 * ```typescript
 * if (!config.tableName) {
 *   throw new RequiredFieldError('tableName', 'DynamoDB table configuration');
 * }
 * ```
 */
export declare class RequiredFieldError extends InfrastructureError {
    readonly fieldName: string;
    readonly contextDescription?: string | undefined;
    readonly name: string;
    constructor(fieldName: string, contextDescription?: string | undefined, options?: {
        component?: string;
        operation?: string;
    });
}
/**
 * Type guard for RequiredFieldError.
 */
export declare function isRequiredFieldError(error: unknown): error is RequiredFieldError;
/**
 * Error thrown when a field value is invalid.
 *
 * @example
 * ```typescript
 * if (timeout < 0) {
 *   throw new InvalidFieldValueError('timeout', timeout, 'must be a positive number');
 * }
 * ```
 */
export declare class InvalidFieldValueError extends InfrastructureError {
    readonly fieldName: string;
    readonly actualValue: unknown;
    readonly reason: string;
    readonly name: string;
    constructor(fieldName: string, actualValue: unknown, reason: string, options?: {
        component?: string;
        operation?: string;
        expectedValue?: unknown;
    });
}
/**
 * Type guard for InvalidFieldValueError.
 */
export declare function isInvalidFieldValueError(error: unknown): error is InvalidFieldValueError;
/**
 * Error thrown when configuration is invalid.
 *
 * @example
 * ```typescript
 * if (!isValidConfig(config)) {
 *   throw new ConfigurationError('Invalid Lambda configuration', config);
 * }
 * ```
 */
export declare class ConfigurationError extends InfrastructureError {
    readonly configuration?: unknown | undefined;
    readonly name: string;
    constructor(message: string, configuration?: unknown | undefined, options?: {
        component?: string;
        operation?: string;
        cause?: Error;
    });
}
/**
 * Type guard for ConfigurationError.
 */
export declare function isConfigurationError(error: unknown): error is ConfigurationError;
/**
 * Error thrown when a resource name is invalid.
 *
 * @example
 * ```typescript
 * if (!isValidResourceName(name)) {
 *   throw new InvalidResourceNameError(name, 'must start with a letter');
 * }
 * ```
 */
export declare class InvalidResourceNameError extends InfrastructureError {
    readonly resourceName: string;
    readonly reason: string;
    readonly name: string;
    constructor(resourceName: string, reason: string, options?: {
        component?: string;
        operation?: string;
        pattern?: string;
    });
}
/**
 * Type guard for InvalidResourceNameError.
 */
export declare function isInvalidResourceNameError(error: unknown): error is InvalidResourceNameError;
