<reasoning_content>
The user wants a Python implementation of a priority-based job scheduling queue.
Key requirements:
1. `add_job` method with optional `priority` parameter (default 0).
2. Higher priority values processed first.
3. FIFO for same priority.
4. `get_next_job` method returning a tuple of (job_name, job_data) or None.
5. Priority levels: 0 (Normal), 1 (High), 2 (Critical).
6. Output only Python code.

Implementation options:
- Use a list and sort on each add/get (inefficient but simple).
- Use a heap (priority queue). Python's `heapq` module implements a min-heap. To make it a max-heap for priorities, we can negate the priority. To maintain FIFO for same priorities, we can add a counter/incrementing ID to the heap tuple.
- Use `queue.PriorityQueue` from `queue` module, but it's thread-safe and might be overkill, plus it compares tuples directly. We can store tuples like `(-priority, counter, job_name, job_data)`.

Let's go with the `heapq` approach or just a simple list with sorting if performance isn't specified. Given it's a coding task, a heap is more appropriate for a queue. However, maintaining FIFO order with a heap requires a tie-breaker.

Tuple structure for heap: `(-priority, counter, job_name, job_data)`
- Negate priority so higher priority comes first in min-heap.
- Counter ensures FIFO for same priority.

Alternatively, use a simple list and sort it. Since no performance constraints are given, simplicity might be preferred, but a heap is more "queue-like". Let's stick to a simple list with sorting for clarity unless performance is critical, but actually, a heap is standard for priority queues. Let's use `heapq`.

Wait, the requirement says "Implement priority-based job scheduling for the queue." It doesn't specify using existing modules, but it's Python. I'll implement a class `JobQueue`.

Let's draft:

```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._counter = 0
        
    def add_job(self, job_name: str, job_data: dict, priority: int = 0) -> None:
        # Negate priority for max-heap behavior (higher priority first)
        # Use counter to maintain FIFO order for same priorities
        heapq.heappush(self._queue, (-priority, self._counter, job_name, job_data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        _, _, job_name, job_data = heapq.heappop(self._queue)
        return (job_name, job_data)
```

Check requirements:
1. `add_job` accepts optional priority (default=0) - Yes.
2. Higher priority processed first - Yes, due to negation.
3. FIFO for same priority - Yes, due to counter.
4. `get_next_job()` returns `tuple[str, dict] | None` - Yes.
5. Priority levels match example - Yes.
6. Output only Python code - Yes.

One minor thing: type hints. Python 3.10+ supports `tuple[str, dict] | None`. I'll use it as requested.
The example shows:
```python
queue = JobQueue()
queue.add_job("normal", {"type": "normal"}, priority=0)
...
```
Matches.

Let's verify the tuple unpacking: `heapq.heappush(self._queue, (-priority, self._counter, job_name, job_data))`
When popping: `_, _, job_name, job_data = heapq.heappop(self._queue)`
Returns `(job_name, job_data)`
Matches requirement.

Is there any edge case? Empty queue returns None. Correct.
Priority levels: 0, 1, 2. Higher is processed first. Correct.
FIFO for same priority. Correct.

One thing: `queue.PriorityQueue` from `queue` module is also an option, but `heapq` is standard library and doesn't require imports if we just use a list and sort, but `heapq` is fine. I'll stick with `heapq`.

Wait, should I include imports? Yes, standard practice.
The prompt says "Write only the Python code, no explanations."

Let's produce the code.

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

class JobQueue:
    def __init__(self):
        self._heap: list = []
        self._counter: int = 0
        
    def add_job(self, job_name: str, job_data: dict, priority: int = 0) -> None:
        heapq.heappush(self._heap, (-priority, self._counter, job_name, job_data))
        self._counter += 1
        
    def get_next_job(self) -> Optional[Tuple[str, dict]]:
        if not self._heap:
            return None
        _, _, job_name, job_data = heapq.heappop(self._heap)
        return (job_name, job_data)
```

Wait, the prompt uses `tuple[str, dict] | None` in the requirement, which is Python 3.10+ syntax. I'll stick to that or use `typing.Optional`. I'll just use the exact signature requested.

Let's adjust to match exactly:
```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._counter = 0
        
    def add_job(self, job_name: str, job_data: dict, priority: int = 0) -> None:
        heapq.heappush(self._queue, (-priority, self._counter, job_name, job_data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        _, _, job_name, job_data = heapq.heappop(self._queue)
        return (job_name, job_data)
```

This looks solid. I'll output exactly this.
Check if any imports are needed: `heapq` is standard.
Check type hints: `tuple[str, dict] | None` is fine for 3.10+.
All requirements met.
Ready. 
One minor point: `job_data` is `dict` in signature, but type hint says `dict`. That's fine.
I will wrap it in a clean code block.
No extra text.
Proceed. 
Self-Correction/Verification during thought:
Does `heapq` maintain order for equal priorities? Yes, because the second element in the tuple is the counter, which strictly increases. So when priorities are equal, it compares counters, ensuring FIFO.
The example shows `priority=0`, `priority=2`, `priority=1`. Output order should be critical (2), high (1), normal (0). My code negates priority, so heap stores (-2, ...), (-1, ...), (0, ...). Min-heap pops smallest first, which is -2 (highest priority). Correct.
All good.
Output matches request.✅
Code:
```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._counter = 0
        
    def add_job(self, job_name: str, job_data: dict, priority: int = 0) -> None:
        heapq.heappush(self._queue, (-priority, self._counter, job_name, job_data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        _, _, job_name, job_data = heapq.heappop(self._queue)
        return (job_name, job_data)
```
Matches exactly. Outputting. 
Wait, should I include `from typing import ...`? Not strictly necessary if using built-in generics. I'll stick to built-ins.
All set. 
Output matches response. 
Proceeds. 
[Done] 
Output Generation. 
(Self-Correction/Refinement during generation prep)
I'll make sure the code block is clean and contains only the implementation as requested.
The prompt says "Write only the Python code, no explanations."
I will provide exactly that.
Code looks good.
Final check of the prompt: "Implement priority-based job scheduling for the queue."
It implies creating a class `JobQueue`.
All good. 
Output matches. 
Proceeds. 
[Output Generation] -> *Proceeds*

</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._counter = 0
        
    def add_job(self, job_name: str, job_data: dict, priority: int = 0) -> None:
        heapq.heappush(self._queue, (-priority, self._counter, job_name, job_data))
        self._counter += 1
        
    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        _, _, job_name, job_data = heapq.heappop(self._queue)
        return (job_name, job_data)
```
</content>