<reasoning_content>
The user wants a Python implementation of a priority-based job scheduling queue.
Requirements:
1. `add_job` method with optional priority (default=0)
2. Higher priority processed first
3. Same priority maintains FIFO order
4. `get_next_job()` returns `tuple[str, dict] | None`
5. Priority levels: 0=Normal, 1=High, 2=Critical (though the logic just needs higher number = higher priority)
6. Only output Python code, no explanations.

I'll use a list or a heap to store jobs. Since we need FIFO for same priority, I'll keep a counter or use a list and sort it, or use `heapq` with a tuple `(priority, insertion_order, job_name, job_data)`. Since `heapq` is min-heap, and we want higher priority first, I can negate the priority: `(-priority, insertion_order, job_name, job_data)`.

Let's define a class `JobQueue`.
```python
import heapq
from typing import Optional, Tuple, Dict

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

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        # Negate priority for max-heap behavior with heapq (min-heap)
        heapq.heappush(self._queue, (-priority, self._counter, name, data))
        self._counter += 1

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

Wait, the requirement says `get_next_job() -> tuple[str, dict] | None`. In Python 3.10+, `tuple[str, dict] | None` is valid syntax. I'll stick to standard typing or just return type hints as requested. The prompt uses `tuple[str, dict] | None`, so I'll use that or `Optional[Tuple[str, dict]]`. I'll just use the exact signature requested.

Let's verify the requirements:
1. `add_job` accepts optional priority (default=0) -> `def add_job(self, name: str, data: dict, priority: int = 0) -> None:`
2. Higher priority processed first -> negated priority in heap handles this.
3. Same priority maintains FIFO -> counter handles this.
4. `get_next_job()` returns tuple or None -> handled.
5. Priority levels mentioned are just for context, logic handles any integer.
6. Only Python code.

One minor thing: `heapq` compares tuples element by element. `(-priority, self._counter, name, data)` works fine. `name` and `data` won't be compared unless priorities and counters are equal, which won't happen because counter is unique. So it's safe.

I'll write the complete class. I should make sure type hints match the prompt if possible, but standard `typing` module is fine.

```python
import heapq
from typing import Optional, Tuple, Dict

class JobQueue:
    def __init__(self):
        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
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```

Wait, `tuple[str, dict] | None` syntax requires Python 3.10+. The prompt uses it, so I'll keep it. Alternatively, I can just use `Optional[Tuple[str, dict]]` to be safe, but I'll stick to the prompt's syntax or standard typing. I'll use `Optional[Tuple[str, dict]]` for broader compatibility, or just keep the prompt's syntax. It's fine either way. I'll stick to `tuple[str, dict] | None` as requested.

Let's double check the prompt: "Write only the Python code, no explanations."
I will output exactly the class definition.

One thing: `heapq` might compare `name` if priorities and counters are equal, but counters are unique, so it won't happen. It's safe.

I'll produce the code now.
Check imports: `import heapq` is needed.
I'll add type hints as requested.

```python
import heapq
from typing import Optional, Tuple, Dict

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

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        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
```

Wait, `list[tuple[int, int, str, dict]]` syntax also requires 3.9+. I'll just use simple typing or no type annotations for internal variables to avoid version issues, or stick to standard `typing` module. The prompt uses `tuple[str, dict] | None`, so 3.10+ is assumed. I'll keep it simple.

Actually, I'll just write it cleanly.

```python
import heapq
from typing import Optional, Tuple, Dict

class JobQueue:
    def __init__(self):
        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
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```

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

Final check of the requirements:
1. `add_job` accepts optional priority (default=0) -> Yes
2. Higher priority processed first -> Yes, negated priority in min-heap
3. Same priority FIFO -> Yes, counter ensures order
4. `get_next_job() -> tuple[str, dict] | None` -> Yes
5. Only Python code -> Yes

Ready. Output matches.✅
I will generate the response now. 
I'll make sure the formatting is exact. No extra text.
One thing: `dict` and `str` in type hints are fine in Python 3.9+. I'll use `typing.Dict` and `typing.Tuple` just to be strictly compatible, or keep as is. The prompt uses `tuple[str, dict] | None`, so I'll match that style.

All good.
Output matches the code block.✅
Proceeds. 
Self-Correction/Refinement during thought: 
Should I handle the case where `data` might be mutated? The prompt says `{"type": "normal"}`, so passing reference is fine. 
The implementation is standard and correct. 
I will output just the code. 
Done. 
```python
import heapq
from typing import Optional, Tuple, Dict

class JobQueue:
    def __init__(self):
        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
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```
This looks solid. I'll provide it. 
Note: I'll remove the `typing` imports if not strictly necessary, but keeping them is fine. I'll stick to the exact signature requested.
All good. 
Output matches. 
Proceeds. 
[Output Generation] -> *Proceeds*

</reasoning_content>

<content>
```python
import heapq
from typing import Optional, Tuple, Dict

class JobQueue:
    def __init__(self) -> None:
        self._heap: list[tuple[int, int, 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
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```
</content>