<reasoning_content>
The user wants a Python implementation of a priority-based job scheduler.
Requirements:
1. A class `JobQueue` (implied by the example).
2. `add_job(name, data, priority=0)` method.
3. Higher priority values should be processed first.
4. FIFO for same priority.
5. `get_next_job() -> tuple[str, dict] | None` method.
6. Priority levels: 0 (Normal), 1 (High), 2 (Critical).
7. Output only the Python code.

Implementation details:
- Need a data structure that supports efficient insertion and retrieval of max priority.
- A heap (priority queue) is suitable, but standard `heapq` in Python is a min-heap.
- To use `heapq` for max-heap behavior, we can negate the priority.
- Need to maintain FIFO order for equal priorities. `heapq` is stable if we add a counter/timestamp as a tie-breaker.
- Since higher priority (e.g., 2) should come before lower (e.g., 0), and `heapq` pops smallest, we should store `(-priority, counter, job_name, job_data)`.
- `counter` ensures FIFO for same priority.
- `add_job` should append to the heap.
- `get_next_job` should pop from the heap.

Let's refine the class structure.

```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:
        # Higher priority means larger number, but heap is min-heap.
        # So we negate priority.
        # We use counter to maintain FIFO order for same priority.
        # Tuple comparison in Python compares element by element.
        # (-priority, counter, name, data)
        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
        # Pop smallest tuple
        _, _, name, data = heapq.heappop(self._heap)
        return (name, data)
```

Wait, looking at the example usage:
`queue.add_job("normal", {"type": "normal"}, priority=0)`
`queue.add_job("critical", {"type": "critical"}, priority=2)`
`queue.add_job("high", {"type": "high"}, priority=1)`

If I push:
1. `(-0, 0, "normal", ...)`
2. `(-2, 1, "critical", ...)`
3. `(-1, 2, "high", ...)`

Heap order (min-heap on first element):
1. `(-2, 1, "critical", ...)` -> Priority 2 (Critical)
2. `(-1, 2, "high", ...)` -> Priority 1 (High)
3. `(-0, 0, "normal", ...)` -> Priority 0 (Normal)

Pop 1: Returns critical. Correct.
Pop 2: Returns high. Correct.
Pop 3: Returns normal. Correct.

What if priorities are same?
Push A (priority 0, counter 0): `(-0, 0, A)`
Push B (priority 0, counter 1): `(-0, 1, B)`
Heap order: `(-0, 0, A)` comes before `(-0, 1, B)`.
Pop A, then Pop B. FIFO maintained. Correct.

Data types:
`name` is str.
`data` is dict.
Return type `tuple[str, dict] | None`.

Imports needed: `heapq`, `typing`.

Let's double check the requirements.
"Modify `add_job` to accept an optional priority parameter (default=0)" - Done.
"Higher priority jobs should be processed before lower priority jobs" - Done (2 > 0).
"Jobs with the same priority should maintain FIFO order" - Done (counter).
"Add `get_next_job()`" - Done.

Code structure:
The prompt asks for "Implement priority-based job scheduling for the queue." and "Write only the Python code". It doesn't specify if I need to provide imports, but usually it's safer to include them or assume standard library. I will include imports.

One detail: The prompt example uses `queue = JobQueue()`. So the class name should be `JobQueue`.

Let's write the 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:
        # Use negative priority for max-heap behavior with min-heap implementation
        # Counter ensures FIFO order for same priority
        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)
```

Is there any ambiguity about "queue"? Usually implies FIFO, but requirement 2 overrides it with priority. The class name `JobQueue` is appropriate.

Let's verify the example manually again.
`queue.add_job("normal", {"type": "normal"}, priority=0)` -> heap: `[(0, 0, "normal", {...})]`
`queue.add_job("critical", {"type": "critical"}, priority=2)` -> heap: `[(-2, 1, "critical", {...}), (0, 0, "normal", {...})]`
`queue.add_job("high", {"type": "high"}, priority=1)` -> heap: `[(-2, 1, "critical", {...}), (0, 0, "normal", {...}), (-1, 2, "high", {...})]` -> re-heapified -> `[(-2, 1, "critical", {...}), (-1, 2, "high", {...}), (0, 0, "normal", {...})]`

`get_next_job()` pops `(-2, 1, "critical", {...})`. Returns `("critical", {"type": "critical"})`.
Matches example comment: "Returns critical job first".

Wait, in my manual trace:
1. Push (0, 0, "normal"). Heap: `[(0, 0, "normal", ...)]` (Note: priority is 0, negated is 0).
2. Push (-2, 1, "critical"). Heap: `[(-2, 1, "critical", ...), (0, 0, "normal", ...)]`.
3. Push (-1, 2, "high"). Heap: `[(-2, 1, "critical", ...), (0, 0, "normal", ...), (-1, 2, "high", ...)]`.
   `heappush` maintains heap property.
   Root is smallest. -2 is smallest.
   Left child of root (index 0) is index 1. Right child is index 2.
   Index 1: (-2, 1, "critical").
   Index 2: (0, 0, "normal"). Wait, (-1, 2, "high") is pushed.
   Heap structure:
   0: (-2, 1, "critical")
   1: (-1, 2, "high")  <-- because -1 < 0
   2: (0, 0, "normal")
   Wait, is -1 < 0? Yes.
   So order in list might be `[(-2, 1, "critical"), (-1, 2, "high"), (0, 0, "normal")]`.
   Pop returns index 0: "critical".
   Next pop returns index 0 (was index 1): "high".
   Next pop returns index 0 (was index 2): "normal".
   
   Wait, counter logic check.
   Original list of pushes:
   1. name="normal", p=0, c=0 -> key=(0, 0, ...)
   2. name="critical", p=2, c=1 -> key=(-2, 1, ...)
   3. name="high", p=1, c=2 -> key=(-1, 2, ...)
   
   Sorted keys:
   1. (-2, 1, "critical") -> Priority 2
   2. (-1, 2, "high") -> Priority 1
   3. (0, 0, "normal") -> Priority 0
   
   Wait, if I had two items with same priority, say p=0.
   Item A: p=0, c=0 -> key=(0, 0, ...)
   Item B: p=0, c=1 -> key=(0, 1, ...)
   Comparison: (0, 0) < (0, 1). So A comes before B. FIFO.
   
   Wait, if I had p=1 and p=1.
   Item A: p=1, c=0 -> key=(-1, 0, ...)
   Item B: p=1, c=1 -> key=(-1, 1, ...)
   Comparison: (-1, 0) < (-1, 1). A comes before B. FIFO.
   
   Wait, what about priority 2 vs 1?
   Item A: p=2 -> key=(-2, ...)
   Item B: p=1 -> key=(-1, ...)
   -2 < -1. A comes before B. Higher priority processed first. Correct.
   
   Looks solid.

One small thing: The prompt says "Modify `add_job`". This implies there might be an existing class, but since I'm writing the code from scratch based on the prompt, I will define the class `JobQueue`. The prompt example instantiates `JobQueue`.

The prompt asks for "Write only the Python code". I will provide the class definition and imports.

```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:
        # Store (-priority, counter, name, data)
        # Negative priority allows using min-heap for max-priority logic
        # Counter ensures FIFO order for equal priorities
        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)
```
The type hint `dict` is fine, `Dict` from typing is deprecated in newer Python versions in favor of `dict`, but standard `dict` works. I'll stick to standard or typing imports if needed. The prompt uses `dict` in the example return type hint `tuple[str, dict] | None` which suggests Python 3.10+ syntax or just loose typing. I will use standard type hints.

Actually, the prompt example `tuple[str, dict] | None` is valid Python 3.10+. I should probably stick to that or use `typing.Optional` and `typing.Tuple` for broader compatibility, but since the prompt uses the pipe syntax, I can use it too or just standard imports. However, to be safe and clean, I'll use imports.

Wait, `tuple[str, dict] | None` is valid syntax in 3.10+. If the environment is older, it fails. But usually, these prompts assume a reasonably modern environment. I'll stick to the provided syntax style or standard typing. I'll provide imports to be safe.

Actually, looking at the prompt's example return type hint `tuple[str, dict] | None`, it's specific. I will just write the code.

One detail: The prompt example `queue.add_job("normal", {"type": "normal"}, priority=0)` passes `data` as the second argument. My signature `add_job(self, name: str, data: dict, priority: int = 0)` matches.

Wait, checking the prompt example again:
`queue.add_job("normal", {"type": "normal"}, priority=0)`
Arguments:
1. "normal" -> name
2. {"type": "normal"} -> data
3. priority=0 -> keyword arg

My signature: `def add_job(self, name: str, data: dict, priority: int = 0)`
Positional args: name, data. Keyword: priority. Matches perfectly.

Final check on logic.
Priority 2 (Critical) -> key -2.
Priority 1 (High) -> key -1.
Priority 0 (Normal) -> key 0.
Min heap pops -2 first. Correct.

FIFO check.
Job A: priority 0, counter 0. Key (0, 0, A).
Job B: priority 0, counter 1. Key (0, 1, B).
(0, 0) < (0, 1). A popped before B. Correct.

Double check the `get_next_job` return type.
Prompt: `tuple[str, dict] | None`.
My code: `Optional[Tuple[str, dict]]`. Equivalent.
Inside: returns `(name, data)`. `name` is str, `data` is dict. Correct.

One edge case: `get_next_job` on empty queue.
Returns `None`. Correct.

Code looks good.

```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:
        # Use negative priority to simulate max-heap with min-heap
        # Use counter to maintain FIFO order for same priority
        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)
```
I'll remove the comments to keep it clean, or keep them for clarity? "Write only the Python code". Comments are fine. I'll keep it concise.

Wait, should I handle the case where `data` is not a dict? The prompt implies it is.
The prompt asks to "Implement priority-based job scheduling for the queue." and "Modify `add_job`". This might imply I should just provide the class.

I will provide the full class implementation.

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

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)
```
I removed `Dict` import since `dict` is builtin and used in type hint `data: dict`. `Tuple` and `Optional` are used in return type.
Actually, `Optional[Tuple[str, dict]]` requires imports if not using `from __future__ import annotations` or Python 3.10+. The prompt used `|` syntax which is 3.10+. I will use `from typing import ...` to be safe or just use the syntax if I assume 3.10+.
However, standard practice in these solutions is to make it runnable.
I'll stick to `typing` imports.

Wait, the prompt example `tuple[str, dict] | None` is valid syntax. I can just use that in the signature.
But `heapq` is needed.

Let's refine the code block.

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

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)
```
This looks robust.

One detail: The prompt example `queue.add_job("normal", {"type": "normal"}, priority=0)`
If I run this code:
`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()`
`print(job)` -> `('critical', {'type': 'critical'})`
Matches requirement.

Final check on "Write only the Python code". I will output the code block.

One minor point: The prompt says "Modify `add_job`". It might be referring to a specific context, but without the base class provided, I must define the class. The example usage `queue = JobQueue()` confirms the class name.

I will output the solution now.

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

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

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        # Store (-priority, counter, name, data)
        # Negative priority ensures higher priority values are popped first (min-heap behavior)
        # Counter ensures FIFO order for jobs with the same priority
        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)
```
I'll strip comments to be concise as requested "Write only the Python code", though comments are code. I'll keep it clean.

Actually, the type hint `Optional[Tuple[str, dict]]` is safer than `tuple[str, dict] | None` for compatibility unless specified. But the prompt used the pipe syntax. I'll stick to standard typing imports to be safe across versions or just use the syntax if I want to match the prompt's style. I'll use imports.

Wait, `dict` is a type hint in `data: dict`. That's fine.

Final check:
1. `add_job` accepts `priority` default 0. Yes.
2. Higher priority processed before lower. Yes (-2 < -1 < 0).
3. FIFO for same priority. Yes (counter).
4. `get_next_job` returns tuple or None. Yes.
5. Priority levels 0, 1, 2. Handled by integer values. Yes.

Code is ready.

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

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)
```
I'll output this.

One detail: The prompt asks for "Implement priority-based job scheduling for the queue."
It might be interpreted as just the methods if the class existed, but the example creates the class. So full class is needed.

I will output the code now.

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

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 for max-heap behavior (higher number = higher priority)
        # Use counter to maintain FIFO order for equal priorities
        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)
```
The prompt example uses `tuple[str, dict] | None`. I will use `Optional[Tuple[str, dict]]` to be safe with imports, but it's functionally identical.

Actually, to be extremely precise with the prompt's style, I could use the pipe syntax, but I need to ensure imports don't clash or I just don't import `Tuple` and `Optional` if I use the syntax.
`from __future__ import annotations` allows forward references, but not syntax changes for `|`. `|` is syntax sugar in 3.10.
I'll stick to `typing` imports as it's the standard way to ensure compatibility.

Wait, `data: dict` in argument list.
If I use `from typing import Dict`, I should use `Dict`. But `dict` is valid in 3.9+.
I'll use `dict`.

Final Code Structure:
```python
import heapq
from typing import Optional, Tuple

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)
```
This is good.

Double check the prompt requirement: "Write only the Python code, no explanations."
I will provide just the code block.

One thought: The prompt says "Modify `add_job`". If I am providing the whole class, that's fine.
If the prompt meant "Here is a class, add this logic", I don't have the class. So I must provide the class.

I'll proceed.

One last check on the tuple return order.
`get_next_job() -> tuple[str, dict]`
My code returns `(name, data)`.
`name` is str, `data` is dict.
Order matches.

The prompt example:
`job = queue.get_next_job()  # Returns critical job first`
If critical job has name "critical" and data `{"type": "critical"}`, it returns `("critical", {"type": "critical"})`.
This is a tuple of (str, dict).
Correct.

The priority logic:
`add_job("normal", ..., priority=0)` -> key 0
`add_job("critical", ..., priority=2)` -> key -2
`add_job("high", ..., priority=1)` -> key -1
Heap order: -2, -1, 0.
Pop order: critical, high, normal.
Correct.

FIFO logic:
If I add "A" priority 0, then "B" priority 0.
Keys: (0, 0, A), (0, 1, B).
Pop order: A, B.
Correct.

If I add "B" priority 0, then "A" priority 0.
Keys: (0, 0, B), (0, 1, A).
Pop order: B, A.
Correct.

Looks perfect.

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

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)
```
I'll output this.

Wait, I can make it slightly more compact or cleaner?
No, this is standard.

One detail: `data` type hint. `dict` is fine.
`name` type hint. `str` is fine.

I will write the code now.

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

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

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        # Store (-priority, counter, name, data) to prioritize higher numbers
        # and maintain FIFO order with the counter.
        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)
```
I'll remove comments to be strictly "only code" if comments are considered explanation, but comments are usually acceptable in code blocks. I'll leave them out to be safe and clean.

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

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)
```
This is the final code.

Wait, I should check if `Tuple` and `Optional` are strictly necessary if I use `|` syntax.
If I use `tuple[str, dict] | None`, I don't need `typing` imports for that.
But `heapq` is needed.
However, `Optional` and `Tuple` are good practice. I'll stick to imports.

Actually, the prompt used `tuple[str, dict] | None`. It might be nice to match that.
```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 cleaner and matches the prompt's type hint style exactly. Python 3.10+ supports this. Given the prompt used it, it's likely the expected environment or acceptable.
However, `typing` imports are safer. I will stick to the safer `typing` imports version or just standard types. But `tuple` and `dict` are built-ins.
I will use the `typing` imports version just to be absolutely standard across 3.7-3.9 if the user is on an older env, although the prompt syntax suggests 3.10+.
Actually, if the prompt uses 3.10 syntax, I should probably use it or compatible code.
But `from typing import Optional, Tuple` works in 3.10 too.
I'll provide the version with `typing` imports as it is more robust.

Wait, `data: dict` in argument.
If I use `typing.Dict`, it's `Dict[str, Any]` usually, but here just `dict`.
I'll stick to the code I wrote before.

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

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)
```
This is safe.

One detail: `data` is `dict`. In type hint `dict` is valid in 3.9+. In 3.8 it's fine too.
I'm overthinking the version. The logic is what matters.

Final check of the prompt requirements again.
1. `add_job` optional priority default 0. (Check)
2. Higher priority processed first. (Check)
3. FIFO same priority. (Check)
4. `get_next_job` returns tuple or None. (Check)
5. Priority levels 0, 1, 2. (Check - logic handles integers generally, levels are just examples).

The code is solid.

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

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)
```
I'll output this.

One tiny thing: The prompt example `queue.add_job("normal", {"type": "normal"}, priority=0)`.
If I copy paste the code into a python shell:
```python
>>> import heapq
>>> from typing import Optional, Tuple
>>> 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)
...
>>> 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)
>>> queue.get_next_job()
('critical', {'type': 'critical'})
```
Works perfectly.

I will write the final output.

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

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

    def add_job(self, name: str, data: dict, priority: int = 0) -> None:
        # Store (-priority, counter, name, data)
        # Negative priority ensures higher priority values come first in min-heap
        # Counter ensures FIFO order for jobs with the same priority
        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)
```
I'll remove comments to strictly follow "only the Python code" without extra fluff, though comments are part of code. I'll keep it minimal.

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

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)
```
This is the one.

Wait, `data` parameter name in `add_job`.
Example: `queue.add_job("normal", {"type": "normal"}, priority=0)`
My code: `def add_job(self, name: str, data: dict, priority: int = 0)`
Matches.

If the example was `queue.add_job("normal", priority=0, data={"type": "normal"})` it would fail, but it's positional for data.
Wait, `add_job` signature: `self, name, data, priority=0`.
Call: `add_job("normal", {"type": "normal"}, priority=0)`.
Args: name="normal", data={"type": "normal"}, priority=0.
Matches.

If I swapped `data` and `priority` in signature? No, prompt says `add_job` to accept *optional* priority parameter. Usually optional params go at the end. And example passes priority as keyword. So `priority` must be after positional `data` or keyword only.
My signature `name, data, priority=0` works.

I am confident.

One edge case: `get_next_job` return type hint.
Prompt: `tuple[str, dict] | None`.
My code: `Optional[Tuple[str, dict]]`.
These are equivalent.

I'll provide the code now.

</reasoning_content>

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

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 to simulate max-heap behavior with min-heap
        # Use counter to maintain FIFO order for jobs with the same priority
        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)
```
</content>