<reasoning_content>
*   Goal: Implement priority-based job scheduling for a queue.
    *   Requirements:
        1.  `add_job(name: str, data: dict, priority: int = 0)`: Add job with priority.
        2.  Priority processing: Higher priority (2 > 1 > 0) first.
        3.  Tie-breaking: Same priority follows FIFO (First-In, First-Out).
        4.  `get_next_job() -> tuple[str, dict] | None`: Retrieve and remove the highest priority job.

    *   A standard `queue.Queue` is FIFO.
    *   A `heapq` (priority queue) is the standard way to handle priority in Python.
    *   *Problem with `heapq`*: It's a min-heap. We want higher priority numbers first (2, then 1, then 0). So we need to negate the priority.
    *   *Problem with `heapq` and FIFO*: If priorities are equal, `heapq` compares the next elements in the tuple. If we store `(-priority, job_name, job_data)`, and two jobs have the same priority, it will compare `job_name`. This is NOT FIFO; it's alphabetical.
    *   *Solution for FIFO tie-breaking*: Use an incrementing counter as the second element in the tuple: `(-priority, entry_count, name, data)`.

    *   `self.queue = []` (as a list for `heapq`).
    *   `self.counter = 0` (to ensure FIFO).

    *   `add_job(name, data, priority)`:
        *   `heapq.heappush(self.queue, (-priority, self.counter, name, data))`
        *   `self.counter += 1`

    *   `get_next_job()`:
        *   If queue empty, return `None`.
        *   `priority, count, name, data = heapq.heappop(self.queue)`
        *   Return `(name, data)`.

    ```python
    import heapq

    class JobQueue:
        def __init__(self):
            self._queue = []
            self._count = 0

        def add_job(self, name: str, data: dict, priority: int = 0):
            # Use -priority because heapq is a min-heap, 
            # and we want higher numbers to be processed first.
            # Use self._count to maintain FIFO for same priority.
            heapq.heappush(self._queue, (-priority, self._count, name, data))
            self._count += 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)
    ```

    *   Requirements:
        1. `add_job` accepts optional priority (default 0). (Check)
        2. Higher priority first. (Check, via `-priority`)
        3. Same priority = FIFO. (Check, via `self._count`)
        4. `get_next_job` returns `tuple[str, dict] | None`. (Check)

    *   `import heapq` is required.
    *   Class definition.
    *   Method implementations.
</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._count = 0

    def add_job(self, name: str, data: dict, priority: int = 0):
        # heapq is a min-heap. To make higher priority numbers come out first,
        # we store the priority as a negative value.
        # We include self._count to ensure FIFO order for jobs with the same priority.
        heapq.heappush(self._queue, (-priority, self._count, name, data))
        self._count += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        
        # Pop the element with the lowest value (which is the highest priority)
        _, _, name, data = heapq.heappop(self._queue)
        return (name, data)
```
</content>