# Source code for AuraGen.core

    """
    Core module containing global configuration and constants for the Guardian engine.
    """

    from typing import List, Dict, Any
    from dataclasses import dataclass, field
    from enum import Enum

    class OutputFormat(str, Enum):
        """Supported output formats for generated data."""
        JSON = "json"
        JSONL = "jsonl"
        CSV = "csv"
        PARQUET = "parquet"

    class Language(str, Enum):
        """Supported languages for data generation."""
        ENGLISH = "en"
        CHINESE = "zh"
        SPANISH = "es"
        FRENCH = "fr"
        GERMAN = "de"
        JAPANESE = "ja"

    class RiskSeverity(str, Enum):
        """Risk severity levels."""
        LOW = "low"
        MEDIUM = "medium"
        HIGH = "high"
        CRITICAL = "critical"

    @dataclass
    class GlobalConfig:
        """
        Global configuration constants for the Guardian engine.
        These are hardcoded in the source code and not read from configuration files.
        """

        # Engine metadata
        ENGINE_VERSION: str = "0.1.0"
        ENGINE_NAME: str = "Guardian"

        # Default settings
        DEFAULT_LANGUAGE: Language = Language.ENGLISH
        DEFAULT_OUTPUT_FORMAT: OutputFormat = OutputFormat.JSONL
        DEFAULT_BATCH_SIZE: int = 100
        DEFAULT_MAX_RETRIES: int = 3

        # Supported configurations
        SUPPORTED_OUTPUT_FORMATS: List[OutputFormat] = field(default_factory=lambda: [
            OutputFormat.JSON,
            OutputFormat.JSONL,
            OutputFormat.CSV,
            OutputFormat.PARQUET
        ])

        SUPPORTED_LANGUAGES: List[Language] = field(default_factory=lambda: [
            Language.ENGLISH,
            Language.CHINESE,
            Language.SPANISH,
            Language.FRENCH,
            Language.GERMAN,
            Language.JAPANESE
        ])

        SUPPORTED_RISK_SEVERITIES: List[RiskSeverity] = field(default_factory=lambda: [
            RiskSeverity.LOW,
            RiskSeverity.MEDIUM,
            RiskSeverity.HIGH,
            RiskSeverity.CRITICAL
        ])

        # Quality thresholds
        MIN_QUALITY_SCORE: float = 0.7
        MAX_HALLUCINATION_PROBABILITY: float = 0.3

        # Generation limits
        MAX_SCENARIO_DEPTH: int = 10
        MAX_RISK_COMBINATIONS: int = 5

        def get_supported_formats(self) -> List[str]:
            """Get list of supported output formats as strings."""
            return [fmt.value for fmt in self.SUPPORTED_OUTPUT_FORMATS]

        def get_supported_languages(self) -> List[str]:
            """Get list of supported languages as strings."""
            return [lang.value for lang in self.SUPPORTED_LANGUAGES]

        def validate_output_format(self, format_str: str) -> bool:
            """Validate if the given format is supported."""
            return format_str in self.get_supported_formats()

        def validate_language(self, lang_str: str) -> bool:
            """Validate if the given language is supported."""
            return lang_str in self.get_supported_languages()

    # Global instance
    GLOBAL_CONFIG = GlobalConfig()