<reasoning_content>
*   Goal: Implement a priority-based job queue.
    *   Requirements:
        1.  `add_job` signature: `add_job(self, name: str, data: dict, priority: int = 0)`.
        2.  Ordering: Highest priority first (higher number = higher priority).
        3.  Secondary ordering: FIFO for same priority.
        4.  `get_next_job()` signature: Returns `tuple[str, dict] | None`.
    *   Priority levels: 0 (Normal), 1 (High), 2 (Critical).

    *   Since we need priority + FIFO, a `heapq` (min-priority queue) or a sorted list is suitable.
    *   However, `heapq` is a min-heap. If higher number = higher priority, we can store priorities as negative values (e.g., -2, -1, 0) or use a custom sorting mechanism.
    *   To maintain FIFO for same priority, we need a unique sequence number (counter).
    *   The data structure should store `(priority, sequence_number, name, data)`.
    *   Since `heapq` is a min-heap, to get the highest priority (max value) first, we store `(-priority, sequence_number)`.

    *   `__init__`: Initialize a list `self._queue` and a counter `self._counter`.
    *   `add_job(name, data, priority=0)`:
        *   Increment counter.
        *   Push `(-priority, counter, name, data)` into the heap.
    *   `get_next_job()`:
        *   Pop from heap if not empty.
        *   Return `(name, data)`.

    *   Python `heapq` is efficient for this.
    *   Ensure type hints are used.

    ```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 priority numbers as higher priority,
            # we use the negative of the priority.
            # The counter ensures FIFO 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
            priority, count, name, data = heapq.heappop(self._queue)
            return (name, data)
    ```

    *   `add_job` accepts `priority=0`? Yes.
    *   Higher priority first? Yes (using `-priority` in min-heap).
    *   FIFO for same priority? Yes (using `self._counter`).
    *   `get_next_job` returns tuple? Yes.

    *Wait, let me double check the "Higher priority jobs should be processed before lower priority jobs" logic.*
    If priority is 2 (Critical), -2 is smaller than -1 (High) and 0 (Normal).
    In a min-heap, -2 comes out first. Correct.
</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):
        # We use a min-heap to store tuples. 
        # To make higher priority numbers come out first, we store priority as a negative value.
        # The counter ensures that jobs with the same priority follow FIFO order.
        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>