<reasoning_content>
The user wants a Python implementation of a priority-based job scheduling queue.
Requirements:
1. Class `JobQueue`
2. `add_job(name, data, priority=0)` method
3. Higher priority values are processed first (priority 2 > 1 > 0)
4. FIFO for same priority
5. `get_next_job() -> tuple[str, dict] | None` method
6. Return only Python code

I'll use a heap or a sorted list. Since we need FIFO for same priority, I can use a counter to track insertion order.
Python's `heapq` module works well. I'll store tuples: `(-priority, insertion_order, (name, data))` in a min-heap.
Wait, `heapq` is a min-heap. So higher priority should be stored as negative priority to be popped first.
Insertion order can be a simple counter.

Let's design the class:
```python
import heapq

class JobQueue:
    def __init__(self):
        self._heap = []
        self._counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        # Use negative priority so higher priority comes first in min-heap
        heapq.heappush(self._heap, (-priority, self._counter, (name, data)))
        self._counter += 1

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

Check requirements:
1. `add_job` accepts optional priority parameter (default=0) -> Yes
2. Higher priority jobs processed before lower -> Yes, -priority ensures 2 becomes -2, which is smaller than -1 and 0, so popped first.
3. Same priority maintains FIFO -> Yes, counter ensures strict ordering.
4. `get_next_job() -> tuple[str, dict] | None` -> Yes
5. Only Python code -> Yes

Wait, type hints in the prompt use `tuple[str, dict] | None`. I'll include them for completeness, but standard Python 3.9+ supports this. I'll stick to standard typing or just use the syntax provided.

Let's verify the example:
```python
queue = JobQueue()
queue.add_job("normal", {"type": "normal"}, priority=0)
queue.add_job("critical", {"type": "critical"}, priority=2)
queue.add_job("high", {"type": "high"}, priority=1)

job = queue.get_next_job()  # Returns critical job first
```
Heap after adds:
[(-2, 1, ("critical", {"type": "critical"})), (-1, 2, ("high", {"type": "high"})), (0, 0, ("normal", {"type": "normal"}))]
Pop returns critical. Correct.

One minor thing: `tuple[str, dict] | None` is Python 3.10+ syntax. I'll use it as requested, or `Optional[Tuple[str, dict]]`. I'll stick to the requested syntax.

The prompt says "Write only the Python code, no explanations."
I will provide just the class definition.

Should I include `import heapq`? Yes.
Should I include type hints? Yes, as requested.

Code structure:
```python
import heapq
from typing import Optional, Tuple

class JobQueue:
    def __init__(self) -> None:
        self._heap: list[tuple[int, int, Tuple[str, dict]]] = []
        self._counter: int = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, (name, data)))
        self._counter += 1

    def get_next_job(self) -> Optional[Tuple[str, dict]]:
        if not self._heap:
            return None
        _, _, job = heapq.heappop(self._heap)
        return job
```

Wait, the prompt uses `tuple[str, dict] | None` which is Python 3.10+ syntax. I'll use exactly that or `typing.Optional` to be safe. I'll just use `tuple[str, dict] | None` as in the prompt.

Let's refine:
```python
import heapq

class JobQueue:
    def __init__(self) -> None:
        self._heap = []
        self._counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, (name, data)))
        self._counter += 1

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

This matches all requirements. I'll output only this code.
One detail: `tuple[str, dict] | None` might cause a syntax error in older Python versions if not using `from __future__ import annotations`, but the prompt explicitly uses it, so it's fine. I'll stick to it.

Final check of the prompt: "Write only the Python code, no explanations."
I will output exactly the code block.
All good.
Proceed. 
I'll make sure the indentation and syntax are correct.
The implementation uses a min-heap with negative priority to achieve max-heap behavior for priority, and a monotonic counter for FIFO stability. This is standard and efficient.
Complexity: O(log N) for add and get.
Matches requirements.
Output matches request.✅
Done. 
Generating response. 
```python
import heapq

class JobQueue:
    def __init__(self) -> None:
        self._heap: list[tuple[int, int, tuple[str, dict]]] = []
        self._counter: int = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, (name, data)))
        self._counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._heap:
            return None
        _, _, job = heapq.heappop(self._heap)
        return job
```
Wait, the type hint `list[tuple[int, int, tuple[str, dict]]]` might be slightly verbose but fine. I'll keep it simple without complex type hints inside the class to avoid version issues, or just use `Any` or omit them except for the method signature requested. The prompt only specifies the signature for `get_next_job`. I'll stick to minimal necessary type hints.

Actually, I'll just write it cleanly.

```python
import heapq

class JobQueue:
    def __init__(self) -> None:
        self._heap = []
        self._counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, (name, data)))
        self._counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._heap:
            return None
        _, _, job = heapq.heappop(self._heap)
        return job
```
This is perfect. Output matches.✅
Proceeds. 
(Self-Correction/Verification during thought)
Check requirement 3: "Jobs with the same priority should maintain FIFO order". The counter ensures that. Since heapq compares tuples element by element, if priorities are equal, it compares counters. Since counters increase monotonically, smaller counter (earlier job) comes first. Correct.
Check requirement 1: "default=0". Correct.
Check requirement 2: "Higher priority jobs should be processed before lower priority jobs". Priority 2 > 1 > 0. We store -priority, so -2 < -1 < 0. Min-heap pops smallest first, so -2 (priority 2) pops first. Correct.
Check requirement 4: signature matches. Correct.
All good.
Output matches request.✅
Proceeds. 
Output generation. 
[Done] 
```python
import heapq

class JobQueue:
    def __init__(self) -> None:
        self._heap = []
        self._counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, (name, data)))
        self._counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._heap:
            return None
        _, _, job = heapq.heappop(self._heap)
        return job
```
Matches exactly. No extra text. Ready. 
Output matches response.✅
(Note: I'll make sure the formatting is exactly as requested, just the code.) 
Proceeds. 
[Final Check]
The prompt says "Write only the Python code, no explanations."
I will output exactly the code block.
All constraints met.
Done. 
[Output Generation] -> *Proceeds*

</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self) -> None:
        self._heap = []
        self._counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, (name, data)))
        self._counter += 1

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