1class FrontMiddleBackQueue {
2    private Deque<Integer> frontQueue = new ArrayDeque<>();
3    private Deque<Integer> backQueue = new ArrayDeque<>();
4
5    // Constructor for the queue.
6    public FrontMiddleBackQueue() {
7        // No initialization is required as the Deques are initialized already.
8    }
9
10    // Adds an element to the front of the queue.
11    public void pushFront(int val) {
12        frontQueue.offerFirst(val);
13        rebalanceQueues();
14    }
15
16    // Adds an element to the middle of the queue.
17    public void pushMiddle(int val) {
18        if(frontQueue.size() <= backQueue.size()) {
19            frontQueue.offerLast(val);
20        } else {
21            backQueue.offerFirst(val);
22        }
23        rebalanceQueues();
24    }
25
26    // Adds an element to the back of the queue.
27    public void pushBack(int val) {
28        backQueue.offerLast(val);
29        rebalanceQueues();
30    }
31
32    // Removes and returns the front element of the queue.
33    public int popFront() {
34        if (isEmpty()) {
35            return -1; // Return -1 if the queue is empty.
36        }
37        int val = frontQueue.isEmpty() ? backQueue.pollFirst() : frontQueue.pollFirst();
38        rebalanceQueues();
39        return val;
40    }
41
42    // Removes and returns the middle element of the queue.
43    public int popMiddle() {
44        if (isEmpty()) {
45            return -1; // Return -1 if the queue is empty.
46        }
47        int val = frontQueue.size() >= backQueue.size() ? frontQueue.pollLast() : backQueue.pollFirst();
48        rebalanceQueues();
49        return val;
50    }
51
52    // Removes and returns the back element of the queue.
53    public int popBack() {
54        if (backQueue.isEmpty()) {
55            return -1; // Return -1 if the queue is empty.
56        }
57        int val = backQueue.pollLast();
58        rebalanceQueues();
59        return val;
60    }
61  
62    // Helper method to check if the queue is empty.
63    private boolean isEmpty() {
64        return frontQueue.isEmpty() && backQueue.isEmpty();
65    }
66
67    // Maintains the balance between the two deques so that they represent the proper ordering of elements.
68    private void rebalanceQueues() {
69        // Rebalance if frontQueue has more elements than backQueue.
70        if (frontQueue.size() > backQueue.size() + 1) {
71            backQueue.offerFirst(frontQueue.pollLast());
72        }
73        // Rebalance if backQueue has more elements than frontQueue.
74        if (backQueue.size() > frontQueue.size()) {
75            frontQueue.offerLast(backQueue.pollFirst());
76        }
77    }
78}
79/**
80 * The above FrontMiddleBackQueue class is structured to provide ease of maintaining and rebalancing 
81 * the elements in frontQueue and backQueue for all the front, middle, and back operations.
82 */
83

1#include <deque>
2
3// Class for a custom queue that supports inserting and deleting from front, middle, and back.
4class FrontMiddleBackQueue {
5public:
6    // Constructor for the queue.
7    FrontMiddleBackQueue() {}
8
9    // Inserts an element at the front of the queue.
10    void pushFront(int val) {
11        frontQueue.push_front(val);
12        balanceQueues();
13    }
14
15    // Inserts an element in the middle of the queue.
16    void pushMiddle(int val) {
17        frontQueue.push_back(val); // Temporarily insert at the end of the front queue
18        balanceQueues(); // Balance the queues so that the new element is in the middle
19    }
20
21    // Inserts an element at the back of the queue.
22    void pushBack(int val) {
23        backQueue.push_back(val);
24        balanceQueues();
25    }
26
27    // Deletes and returns the front element of the queue. Returns -1 if the queue is empty.
28    int popFront() {
29        if (frontQueue.empty() && backQueue.empty()) return -1;
30        int val = 0;
31        if (!frontQueue.empty()) {
32            val = frontQueue.front();
33            frontQueue.pop_front();
34        } else {
35            val = backQueue.front();
36            backQueue.pop_front();
37        }
38        balanceQueues();
39        return val;
40    }
41
42    // Deletes and returns the middle element of the queue. Returns -1 if the queue is empty.
43    int popMiddle() {
44        if (frontQueue.empty() && backQueue.empty()) return -1;
45        int val = 0;
46        if (frontQueue.size() == backQueue.size()) {
47            val = frontQueue.back();
48            frontQueue.pop_back();
49        } else {
50            val = backQueue.front();
51            backQueue.pop_front();
52        }
53        balanceQueues();
54        return val;
55    }
56
57    // Deletes and returns the back element of the queue. Returns -1 if the queue is empty.
58    int popBack() {
59        if (backQueue.empty()) return -1;
60        int val = backQueue.back();
61        backQueue.pop_back();
62        balanceQueques();
63        return val;
64    }
65
66private:
67    std::deque<int> frontQueue; // Front half of the queue
68    std::deque<int> backQueue; // Back half of the queue
69
70    // Balances the elements between the front and back queues.
71    void balanceQueues() {
72        // If the front queue has more elements than the back queue, move the last element
73        // of the front queue to the front of the back queue.
74        if (frontQueue.size() > backQueue.size()) {
75            backQueue.push_front(frontQueue.back());
76            frontQueue.pop_back();
77        }
78        // If the back queue has more than one extra element compared to the front queue,
79        // move the front element of the back queue to the back of the front queue.
80        if (backQueue.size() > frontQueue.size() + 1) {
81            frontQueue.push_back(backQueue.front());
82            backQueue.pop_front();
83        }
84    }
85};
86
87/**
88 * You may use the FrontMiddleBackQueue class as follows:
89 * FrontMiddleBackQueue* queue = new FrontMiddleBackQueue();
90 * queue->pushFront(value);
91 * queue->pushMiddle(value);
92 * queue->pushBack(value);
93 * int front = queue->popFront();
94 * int middle = queue->popMiddle();
95 * int back = queue->popBack();
96 * delete queue;
97 */
98

1// Queue class which supports operations on both ends and the middle.
2class FrontMiddleBackQueue {
3    private left: number[];
4    private right: number[];
5
6    constructor() {
7        this.left = [];
8        this.right = [];
9    }
10
11    // Adds an element to the front of the queue.
12    public pushFront(val: number): void {
13        this.left.unshift(val);
14        this.rebalance();
15    }
16
17    // Adds an element to the middle of the queue.
18    public pushMiddle(val: number): void {
19        this.left.push(val);
20        this.rebalance();
21    }
22
23    // Adds an element to the back of the queue.
24    public pushBack(val: number): void {
25        this.right.push(val);
26        this.rebalance();
27    }
28
29    // Removes and returns the element from the front of the queue.
30    public popFront(): number {
31        if (this.isEmpty()) return -1;
32        const num: number = this.left.length === 0 ? this.right.shift()! : this.left.shift()!;
33        this.rebalance();
34        return num;
35    }
36
37    // Removes and returns the middle element from the queue.
38    public popMiddle(): number {
39        if (this.isEmpty()) return -1;
40        const num: number = (this.left.length === this.right.length) ? this.left.pop()! : this.right.shift()!;
41        this.rebalance();
42        return num;
43    }
44
45    // Removes and returns the element from the back of the queue.
46    public popBack(): number {
47        if (this.isEmpty()) return -1;
48        const num: number = this.right.pop()!;
49        this.rebalance();
50        return num;
51    }
52
53    // Helper function to keep the queue balanced between left and right sections.
54    private rebalance(): void {
55        while (this.left.length > this.right.length) {
56            this.right.unshift(this.left.pop()!);
57        }
58        while (this.right.length > this.left.length + 1) {
59            this.left.push(this.right.shift()!);
60        }
61    }
62
63    // Checks if the queue is empty.
64    private isEmpty(): boolean {
65        return this.left.length === 0 && this.right.length === 0;
66    }
67}
68```
69
70In this TypeScript rewrite:
71
72- `number[]` is the type annotation specifying the array with elements of type `number`.
73- `void` is the return type annotation for methods that do not return a value.
74- Methods and variables are given access modifiers such as `private` and `public` to indicate their visibility outside the class.
75- The non-null assertion operator (`!`) is used to assert that the value won't be `null` or `undefined`. This is necessary because TypeScript's strict null checking would otherwise object to popping and shifting elements from possibly empty arrays.
76
77Creating an instance of this class and using its methods would be done in the same way as the JavaScript version:
78
79```typescript
80const queue = new FrontMiddleBackQueue();
81queue.pushFront(1);
82queue.pushMiddle(2);
83queue.pushBack(3);
84const front = queue.popFront(); // Should return 1
85const middle = queue.popMiddle(); // Should return 2
86const back = queue.popBack(); // Should return 3
87