<reasoning_content>
Here's a thinking process:

1.  **Understand the Goal**: The user wants a priority-based job scheduling queue in Python. The queue needs to support adding jobs with an optional priority (default 0), processing higher priority jobs first, maintaining FIFO order for same priority, and providing a `get_next_job()` method that returns a tuple of (job_name, job_data) or None.

2.  **Key Requirements**:
   - `add_job(name, data, priority=0)`
   - Higher priority processed first
   - FIFO for same priority
   - `get_next_job() -> tuple[str, dict] | None`
   - Priority levels: 0=Normal, 1=High, 2=Critical (but the implementation should just use the numeric value, higher is better)
   - Return type hint: `tuple[str, dict] | None`
   - Only output Python code, no explanations.

3.  **Data Structure Choice**:
   - A priority queue is ideal. Python's `heapq` module provides a min-heap.
   - To make higher priority come first with a min-heap, I can negate the priority value.
   - To maintain FIFO order for same priority, I need a tie-breaker. I can use a counter that increments with each job added. Since it's a min-heap, a lower counter means earlier arrival.
   - Heap entries will be: `(-priority, counter, name, data)`
   - `heapq` will sort by `-priority` first, then `counter`, which gives exactly the desired behavior.

4.  **Implementation Details**:
   - Need to initialize the heap and a counter.
   - `add_job`: push to heap, increment counter.
   - `get_next_job`: pop from heap, return `(name, data)`. If empty, return `None`.
   - Type hints as requested.
   - Handle the case where `get_next_job` is called on an empty queue.

   Let's draft it:
   ```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:
           # Negate 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) -> Optional[Tuple[str, dict]]:
           if not self._heap:
               return None
           _, _, name, data = heapq.heappop(self._heap)
           return name, data
   ```

5.  **Check Requirements**:
   - `add_job` accepts optional priority parameter (default=0)? Yes.
   - Higher priority processed first? Yes, `-priority` ensures higher numbers come first.
   - FIFO for same priority? Yes, `_counter` ensures insertion order.
   - `get_next_job() -> tuple[str, dict] | None`? Yes, matches type hint.
   - Example works? Let's trace:
     - `add_job("normal", {...}, 0)` -> heap: `(0, 0, "normal", {...})`
     - `add_job("critical", {...}, 2)` -> heap: `(-2, 1, "critical", {...}), (0, 0, "normal", {...})` (heapified)
     - `add_job("high", {...}, 1)` -> heap: `(-2, 1, "critical", {...}), (0, 0, "normal", {...}), (-1, 2, "high", {...})` -> heapify maintains order
     - `get_next_job()` pops `(-2, 1, "critical", {...})` -> returns `("critical", {...})`. Correct.
   - Only Python code? Yes.
   - Type hints match exactly? `tuple[str, dict] | None` is Python 3.10+ syntax. I'll use it as requested, but might need to import `Tuple` and `Optional` if not using `from __future__ import annotations`. The prompt uses `tuple[str, dict] | None`, so I'll stick to that syntax directly in the signature. Python 3.10+ supports it natively. I'll just write it as is.

   One minor thing: The prompt says `tuple[str, dict] | None`. I'll use exactly that.
   I should make sure the class name is `JobQueue` as implied by the example.
   I'll add `from typing import Optional, Tuple, Dict` just in case, but the prompt uses modern syntax. I'll stick to modern syntax for the return type, and maybe just use `list`/`dict`/`tuple` directly. Actually, I'll just write it cleanly.

   Let's refine:
   ```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
   ```

   Wait, `list[tuple[...]]` syntax is also Python 3.9+. I'll keep it simple and avoid over-annotating internal types unless necessary. The prompt only requires the specific signature. I'll stick to minimal, clean code.

   Let's verify the exact requirement: "Write only the Python code, no explanations."
   I'll output just the class implementation.

   One thing: `heapq` is standard library, so importing it is fine.
   I'll make sure the code matches the example exactly.
   The example uses `queue = JobQueue()`, so class name is `JobQueue`.
   All good.

   Final check of the code:
   ```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
           _, _, name, data = heapq.heappop(self._heap)
           return name, data
   ```
   This meets all requirements. Higher priority (larger number) comes first due to negation. FIFO due to counter. Returns tuple or None. Uses modern type hints as requested. Only code. Ready.✅
   I will output exactly this. No extra text.
   One minor point: `tuple[str, dict] | None` might require `from __future__ import annotations` in older Python, but the prompt uses it directly, so I'll assume Python 3.10+ environment. I'll just write it as is.
   All good.✅
   Output matches response. 
   Proceeds. 
   [Output Generation] -> *Proceeds*
   *(Self-Correction/Refinement during thought)*: 
   Should I include type hints for `add_job` parameters? The prompt says `add_job` to accept an optional priority parameter (default=0). It doesn't specify exact type hints for `add_job`, but I'll add standard ones for clarity. The prompt specifically asks for `get_next_job() -> tuple[str, dict] | None`. I'll keep it precise.
   I'll make sure the code is complete and runnable.
   ```python
   import heapq

   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
   ```
   This is solid. I'll output it. 
   One thing: `list[tuple[...]]` might cause syntax error in Python 3.9 or below if not using `from __future__ import annotations`. To be safe and strictly follow the prompt's style, I'll just use `self._heap = []` without complex internal type hints, as they aren't required. The prompt only specifies the return type for `get_next_job`. I'll keep it simple.
   Final code:
   ```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
           _, _, name, data = heapq.heappop(self._heap)
           return name, data
   ```
   Matches all constraints. Output matches.✅
   Proceeds. 
   [Output Generation] -> *Outputs the code block*
   *(Done.)*

</reasoning_content>

<content>
```python
import heapq

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>