<reasoning_content>
Here's a thinking process:

1.  **Understand the Goal**: The user wants a priority-based job scheduling queue in Python. It needs to support adding jobs with optional priority levels, processing higher priority jobs first, maintaining FIFO for same-priority jobs, and provide a method to get the next job.

2.  **Key Requirements**:
   - `add_job(name: str, data: dict, priority: int = 0)`
   - Higher priority processed first
   - Same priority: FIFO
   - `get_next_job() -> tuple[str, dict] | None`
   - Priority levels: 0 (Normal), 1 (High), 2 (Critical) - though the code should just handle numeric priorities flexibly, with 0 as default.
   - Output: Only Python code, no explanations.

3.  **Data Structure Choice**:
   - A priority queue is needed. Python's `heapq` module provides a min-heap.
   - To handle higher priority first with a min-heap, I can negate the priority value, or use a max-heap approach. Since `heapq` is a min-heap, I'll store `(-priority, insertion_order, job_name, job_data)`.
   - `insertion_order` ensures FIFO for same priorities. I'll use a simple counter that increments on each `add_job` call.
   - `get_next_job` will pop from the heap and return `(job_name, job_data)`. If empty, return `None`.

4.  **Implementation Details**:
   - Class: `JobQueue`
   - Attributes: `self._heap`, `self._counter`
   - `__init__`: Initialize heap and counter.
   - `add_job`: Append `(-priority, self._counter, name, data)` to heap, increment counter, `heapq.heappush`.
   - `get_next_job`: If heap empty, return `None`. Else, `heapq.heappop`, return `(name, data)`.
   - Type hints: Use `typing` or built-in generics as requested. The prompt uses `tuple[str, dict] | None`, which is Python 3.10+ syntax. I'll stick to that or use `Optional`/`Tuple` if needed, but modern syntax is fine. I'll assume Python 3.10+ based on the prompt's type hints.

5.  **Draft Code**:
```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) -> Optional[Tuple[str, dict]]:
        if not self._heap:
            return None
        _, _, name, data = heapq.heappop(self._heap)
        return name, data
```

6.  **Check Requirements**:
   - `add_job` accepts optional priority (default=0)? Yes.
   - Higher priority processed first? Yes, using `-priority` in min-heap.
   - Same priority FIFO? Yes, using `_counter`.
   - `get_next_job() -> tuple[str, dict] | None`? Yes.
   - Priority levels mentioned in prompt are just examples/documentation, not strict enum enforcement needed unless specified. The prompt says "Priority levels: 0: Normal, 1: High, 2: Critical", but doesn't require validation. I'll stick to numeric.
   - Only Python code, no explanations? Yes.

   One minor thing: The prompt uses `tuple[str, dict] | None` syntax. I'll use that exact syntax in the type hint to match the prompt, or use `Optional[Tuple[str, dict]]`. I'll stick to `Optional[Tuple[str, dict]]` for broader compatibility, or just use the prompt's syntax. Actually, Python 3.10+ supports `tuple[str, dict] | None`. I'll use it as requested.

   Let's refine:
```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, `dict` and `tuple` in type hints might need `from __future__ import annotations` for older Python, but the prompt uses `tuple[str, dict] | None`, so I'll assume Python 3.10+. I'll keep it as is.

   Check if any edge cases: 
   - What if `data` is mutated after adding? Not our problem unless specified.
   - The prompt says `get_next_job() -> tuple[str, dict] | None`. I'll match that exactly.
   - I should ensure the class name is `JobQueue` as implied by the example.
   - All good.

   One thing: `heapq` stores tuples. The counter ensures strict ordering. Negative priority ensures higher numbers come first. This satisfies all constraints.

   Final check of the code:
```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:
        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 output exactly this. No extra text. Matches requirements. Uses standard library. Handles priority, FIFO, default priority, and return type. Ready. 
   One minor point: `dict` and `tuple` in type hints might trigger warnings in some environments if not using `from __future__ import annotations`, but the prompt explicitly uses that syntax, so it's fine. I'll keep it as is.
   All good. Output matches request.✅
   Proceeds. 
   Output generation. 
   [Done] 
   *Self-Correction/Verification during thought*:
   - Should I include type imports? The prompt uses `tuple[str, dict] | None`, which is valid in Python 3.10+. I'll just use it directly.
   - The prompt says "Write only the Python code, no explanations."
   - I'll make sure the code is complete and runnable.
   - `heapq` is standard.
   - `self._counter` guarantees FIFO for same priorities.
   - `-priority` ensures higher priority pops first.
   - Matches example exactly.
   - All constraints met.
   - Output matches exactly.✅
   Proceeds. 
   [Output Generation] -> *See response.* 
   *(Note: I'll add `from typing import Optional, Tuple` just in case, but the prompt's syntax is fine. I'll stick to the prompt's syntax to be safe. Actually, I'll just use the exact syntax requested.)*
   Final code:
   ```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:
           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 is correct. Output matches.✅
   [Done]

</reasoning_content>

<content>
```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:
        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>