<reasoning_content>
The objective is to implement a priority-based job queue in Python.

    *   `add_job(job_name: str, job_data: dict, priority: int = 0)`: Add a job with a specific priority.
    *   `get_next_job() -> tuple[str, dict] | None`: Retrieve and remove the job with the highest priority. If priorities are tied, use FIFO (First-In-First-Out).

    *   Priority levels: 0 (Normal), 1 (High), 2 (Critical). Higher numbers mean higher priority.
    *   FIFO for same priority: This means if two jobs have priority 2, the one added first should be returned first.

    *   *List with Sorting:* Easy to implement but $O(N \log N)$ or $O(N)$ per operation.
    *   *Heap Queue (`heapq`):* Efficient for priority queues. $O(\log N)$ for insertion and deletion.

    *   `heapq` implements a min-heap.
    *   Requirement: Higher priority (higher number) should be processed first.
    *   Standard heap approach: Store negative priority (e.g., -2 for critical, -1 for high, 0 for normal).
    *   Requirement: FIFO for same priority.
    *   `heapq` handles ties by looking at the next element in the tuple. To ensure FIFO, we need an insertion counter (a monotonically increasing integer).

    *   `self.jobs = []` (The heap)
    *   `self.counter = 0` (To maintain FIFO)
    *   `add_job(name, data, priority=0)`:
        *   `entry = (-priority, self.counter, name, data)`
        *   `heapq.heappush(self.jobs, entry)`
        *   `self.counter += 1`
    *   `get_next_job()`:
        *   `if not self.jobs: return None`
        *   `priority, count, name, data = heapq.heappop(self.jobs)`
        *   `return (name, data))`

    *   `JobQueue` class definition.
    *   `import heapq`.
    *   Docstrings/types matching the prompt.

    *   Input `priority`: 0, 1, 2.
    *   Higher priority processed first? Yes, `-2` is smaller than `-1`.
    *   FIFO? Yes, if priorities are same, `self.counter` will be smaller for the earlier job.

    ```python
    import heapq

    class JobQueue:
        def __init__(self):
            self.queue = []
            self.counter = 0

        def add_job(self, name: str, data: dict, priority: int = 0):
            # Negate priority because heapq is a min-heap
            # counter ensures FIFO for same priority
            heapq.heappush(self.queue, (-priority, self.counter, name, data))
            self.counter += 1

        def get_next_job(self) -> tuple[str, dict] | None:
            if not self.queue:
                return None
            _, _, name, data = heapq.heappop(self.queue)
            return (name, data)
    ```

    "Write only the Python code, no explanations."

    (Wait, I should check if there is a base class provided. The prompt says "Modify...", but usually implies providing the whole class or the specific class requested.)

    Let's ensure the signature matches the request exactly.
    `add_job(self, name: str, data: dict, priority: int = 0)`
    `get_next_job(self) -> tuple[str, dict] | None`
</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self):
        self.queue = []
        self.counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0):
        # heapq is a min-heap. To treat higher numbers as higher priority,
        # we store the priority as a negative number.
        # We use a counter to ensure FIFO behavior for equal priorities.
        heapq.heappush(self.queue, (-priority, self.counter, name, data))
        self.counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self.queue:
            return None
        
        _, _, name, data = heapq.heappop(self.queue)
        return (name, data)
```
</content>