class MatchDomainError(Exception):
    """Base exception for fixture/match-domain failures."""


class FixtureGenerationError(MatchDomainError):
    pass


class FixtureGenerationNotAllowedError(FixtureGenerationError):
    pass


class FixtureIntegrityError(FixtureGenerationError):
    pass


class MatchNotFoundError(MatchDomainError):
    pass


class MatchValidationError(MatchDomainError, ValueError):
    pass


class InvalidKickoffError(MatchValidationError):
    pass


class InvalidScoreError(MatchValidationError):
    pass


class MatchInvalidStatusError(MatchDomainError):
    pass


class MatchNotSchedulableError(MatchInvalidStatusError):
    pass


class MatchNotStartableError(MatchInvalidStatusError):
    pass


class MatchNotCompletableError(MatchInvalidStatusError):
    pass


class MatchNotCancellableError(MatchInvalidStatusError):
    pass


class CompetitionNotCompletableError(MatchDomainError):
    pass


class LineupError(MatchDomainError):
    """Base exception for lineup/configuration failures."""


class LineupNotFoundError(LineupError):
    pass


class LineupValidationError(LineupError, ValueError):
    pass


class InvalidFormationError(LineupValidationError):
    pass


class InvalidLineupClubError(LineupValidationError):
    pass


class InvalidLineupPlayerError(LineupValidationError):
    pass


class MedicallyUnavailableLineupPlayerError(InvalidLineupPlayerError):
    pass


class DuplicateLineupPlayerError(LineupValidationError):
    pass


class InvalidLineupSlotError(LineupValidationError):
    pass


class InvalidLineupRoleError(LineupValidationError):
    pass


class InvalidCaptainError(LineupValidationError):
    pass


class IncompleteLineupError(LineupValidationError):
    pass


class LineupNotEditableError(LineupError):
    pass


class LineupNotSubmittableError(LineupError):
    pass


class LineupNotReopenableError(LineupError):
    pass


class MatchLineupsNotReadyError(MatchNotStartableError):
    pass


class SimulationError(MatchDomainError):
    """Base exception for snapshot/engine/persistence failures."""


class SimulationSnapshotNotFoundError(SimulationError):
    pass


class SimulationSnapshotIntegrityError(SimulationError):
    pass


class SimulationEvidenceImmutableError(SimulationError):
    pass


class MatchNotSimulatableError(SimulationError):
    pass


class SimulationEngineContractError(SimulationError, ValueError):
    pass


class SimulationExecutionError(SimulationError):
    pass


class SimulationAlreadyResolvedError(SimulationError):
    pass


class SimulationReportError(SimulationError):
    """Base exception for deterministic detailed-report generation/persistence."""


class SimulationReportContractError(SimulationReportError, ValueError):
    pass


class SimulationReportGenerationError(SimulationReportError):
    pass


class MatchSchedulingPolicyError(MatchDomainError):
    """Scheduling policy/configuration cannot produce a valid kickoff."""


class MatchSchedulingConfigurationError(MatchSchedulingPolicyError):
    pass


class MatchSchedulingConflictError(MatchSchedulingPolicyError):
    pass


class MatchRescheduleNotAllowedError(MatchSchedulingPolicyError):
    pass


class MatchScheduleEvidenceError(MatchSchedulingPolicyError):
    pass


class MatchdayOperationsError(MatchDomainError):
    """Base exception for matchday/pre-match operations."""


class MatchdayConfigurationError(MatchdayOperationsError):
    pass


class MatchdayNotPreparedError(MatchdayOperationsError):
    pass


class MatchdayCheckInError(MatchdayOperationsError):
    pass


class MatchdayLineupDeadlineError(LineupError):
    pass


class MatchdayReadinessError(MatchdayOperationsError):
    pass


class MatchdayAutoStartError(MatchdayOperationsError):
    pass


class MatchdayEvidenceImmutableError(MatchdayOperationsError):
    pass


class MatchSuspensionError(MatchdayOperationsError):
    pass


class CompetitionDisciplineError(MatchDomainError):
    """Base exception for competition discipline/cards workflows."""


class DisciplineConfigurationError(CompetitionDisciplineError):
    pass


class DisciplineCardError(CompetitionDisciplineError):
    pass


class DisciplineProcessingError(CompetitionDisciplineError):
    pass


class DisciplineEvidenceImmutableError(CompetitionDisciplineError):
    pass


class DisciplineAppealError(CompetitionDisciplineError):
    pass


class AdministrativeResultError(CompetitionDisciplineError):
    pass

class LiveTacticsError(MatchDomainError):
    """Base exception for tactical plans, intelligence and live decisions."""


class TacticalPlanError(LiveTacticsError):
    pass


class TacticalPlanNotEditableError(TacticalPlanError):
    pass


class TacticalInstructionError(TacticalPlanError):
    pass


class TacticalSnapshotError(LiveTacticsError):
    pass


class TacticalEvidenceImmutableError(LiveTacticsError):
    pass


class InteractiveMatchError(MatchDomainError):
    """Base exception for interactive match runner/live command workflows."""


class InteractiveMatchConfigurationError(InteractiveMatchError):
    pass


class InteractiveMatchSessionError(InteractiveMatchError):
    pass


class InteractiveMatchSessionNotFoundError(InteractiveMatchSessionError):
    pass


class InteractiveMatchCommandError(InteractiveMatchError):
    pass


class InteractiveMatchAuthorizationError(InteractiveMatchError):
    pass


class InteractiveMatchRevisionConflictError(InteractiveMatchCommandError):
    pass


class InteractiveMatchCommandWindowClosedError(InteractiveMatchCommandError):
    pass


class InteractiveMatchEvidenceImmutableError(InteractiveMatchError):
    pass

class LiveMatchStreamError(InteractiveMatchError):
    """Base exception for durable live-stream synchronization."""


class LiveMatchStreamCursorError(LiveMatchStreamError):
    pass


class LiveMatchStreamIntegrityError(LiveMatchStreamError):
    pass
