/**
 * Built-in Specifications
 *
 * This module provides commonly used specifications for validating
 * infrastructure resource configurations.
 *
 * @module declarative-api/specification
 */
import type { ValidationError } from '../../../lib/runtime-web/types/declarative-api/specification.types';
import type { Stage } from '../../../lib/runtime-web/types/declarative-api';
import { BaseSpecification } from './base-specification';
/**
 * Specification for validating AWS resource names.
 *
 * Validates that resource names follow AWS naming conventions:
 * - Must start with a letter
 * - Can contain letters, numbers, underscores, and hyphens
 * - Must be between 1 and 255 characters
 *
 * @example
 * ```typescript
 * const spec = new ValidResourceNameSpec();
 *
 * spec.isSatisfiedBy('my-table'); // true
 * spec.isSatisfiedBy('123-table'); // false (starts with number)
 * spec.isSatisfiedBy(''); // false (empty)
 * ```
 *
 * Validates: Requirements 11.3
 */
export declare class ValidResourceNameSpec extends BaseSpecification<string> {
    private readonly fieldPath;
    /**
     * Create a resource name specification.
     *
     * @param fieldPath - Optional path for error reporting (default: 'name')
     */
    constructor(fieldPath?: string);
    /**
     * Check if the name is a valid AWS resource name.
     *
     * @param candidate - The name to validate
     * @returns True if the name is valid
     */
    isSatisfiedBy(candidate: string): boolean;
    /**
     * Get validation errors for invalid resource names.
     *
     * @param candidate - The name to validate
     * @returns Array of validation errors
     */
    getErrors(candidate: string): ValidationError[];
}
/**
 * Specification for validating required fields in objects.
 *
 * Validates that a specified field exists and is not null/undefined.
 * Supports nested field paths using dot notation.
 *
 * @typeParam T - The type of object being validated
 *
 * @example
 * ```typescript
 * interface TableConfig {
 *   tableName: string;
 *   partitionKey?: string;
 * }
 *
 * const spec = new RequiredFieldSpec<TableConfig>('partitionKey');
 *
 * spec.isSatisfiedBy({ tableName: 'users', partitionKey: 'id' }); // true
 * spec.isSatisfiedBy({ tableName: 'users' }); // false
 * ```
 *
 * Validates: Requirements 11.3
 */
export declare class RequiredFieldSpec<T extends object> extends BaseSpecification<T> {
    private readonly fieldPath;
    private readonly customMessage?;
    /**
     * Create a required field specification.
     *
     * @param fieldPath - Path to the required field (supports dot notation)
     * @param customMessage - Optional custom error message
     */
    constructor(fieldPath: string, customMessage?: string);
    /**
     * Check if the required field exists and is not null/undefined.
     *
     * @param candidate - The object to validate
     * @returns True if the field exists and has a value
     */
    isSatisfiedBy(candidate: T): boolean;
    /**
     * Get validation error if the required field is missing.
     *
     * @param candidate - The object to validate
     * @returns Array with error if field is missing, empty otherwise
     */
    getErrors(candidate: T): ValidationError[];
    /**
     * Get a nested value from an object using dot notation path.
     *
     * @param obj - The object to traverse
     * @param path - Dot-notation path (e.g., 'a.b.c')
     * @returns The value at the path, or undefined if not found
     */
    private getNestedValue;
}
/**
 * Specification for stage-specific validation.
 *
 * Validates that a configuration meets requirements for a specific stage.
 * Different stages have different requirements (e.g., prod requires encryption).
 *
 * @typeParam T - The type of configuration being validated
 *
 * @example
 * ```typescript
 * interface TableConfig {
 *   encryption: boolean;
 *   pointInTimeRecovery: boolean;
 * }
 *
 * const prodSpec = new StageSpecificSpec<TableConfig>('prod', (config) => {
 *   const errors: ValidationError[] = [];
 *   if (!config.encryption) {
 *     errors.push({
 *       path: 'encryption',
 *       message: 'Encryption is required for production',
 *       code: 'PROD_ENCRYPTION_REQUIRED',
 *       severity: 'error',
 *     });
 *   }
 *   return errors;
 * });
 * ```
 *
 * Validates: Requirements 11.3
 */
export declare class StageSpecificSpec<T> extends BaseSpecification<T> {
    private readonly targetStage;
    private readonly currentStage;
    private readonly validator;
    /**
     * Create a stage-specific specification.
     *
     * @param targetStage - The stage this specification applies to
     * @param validator - Function that returns validation errors for the stage
     * @param currentStage - The current deployment stage (default: 'dev')
     */
    constructor(targetStage: Stage, validator: (candidate: T) => ValidationError[], currentStage?: Stage);
    /**
     * Check if the configuration satisfies stage-specific requirements.
     *
     * If the current stage doesn't match the target stage, always returns true.
     *
     * @param candidate - The configuration to validate
     * @returns True if satisfied or stage doesn't match
     */
    isSatisfiedBy(candidate: T): boolean;
    /**
     * Get stage-specific validation errors.
     *
     * Returns empty array if current stage doesn't match target stage.
     *
     * @param candidate - The configuration to validate
     * @returns Array of validation errors
     */
    getErrors(candidate: T): ValidationError[];
}
