design a strange data structure, is it possible?
Let us denote four data structure: $Q$, $PQ$, $R_Q$, and $R_{PQ}$. $Q$ is a FIFO queue. $PQ$ is a priority queue implemented using a Fibonacci heap. $R_Q$ and $R_{PQ}$ are hash-sets. $R_Q$ stores elements that have been removed from the queue but not removed from the priority-queue yet; $R_{PQ}$ stores elements that have been removed from the priority-queue but not the queue yet.
Our operations are insert, delete, and extract-min. For insert, we insert the element into $Q$ and $PQ$.
We implement delete and extract-min lazily. For delete, let x=Q.front().  If $x$ exists within $R_{PQ}$, that means it has been removed from the priority-queue already. We pop $x$ and remove $x$ from $R_{PQ}$. Then, we set x=Q.front() and try again. If $x$ is not within $R_{PQ}$, then this is the element we should remove. We pop $x$ and insert it into $R_Q$.
For extract-min, we essentially do the reverse. We take x=PQ.top() until $x$ does not exist within $R_Q$, and when it does we pop $x$ and insert it into $R_{PQ}$.
Time complexity for insert: $O(1)$ (since we are using Fibonacci heap)
Time complexity for delete: amortized $O(1)$ (hash-sets work in amortized constant, and all our operations are either the deletion or lazy extract-min deletions.)
Time complexity for extract-min: amortized $O(logn)$ (hash-sets work in amortized constant, all our operations are either the deletion or lazy extract-min deletions, but logn factor due to PQ)
Update Code (C++):
struct strange_ds{
    queue&lt;int&gt; q;
    priority_queue&lt;int&gt; pq;
    unordered_set&lt;int&gt; rq, rpq;
    
    void insert(int x){
        pq.push(x); q.push(x);
    }
    
    void delete_ele(){
        while(true){
            int t = q.front();
            if(rpq.count(t)){ //already removed from pq
                q.pop();
                rpq.erase(t);
                continue;
            }
            q.pop();
            rq.insert(t);
            return;
        }
    }
    
    int extract_min(){
        while(true){
            int t = pq.top();
            if(rq.count(t)){ //already remove from q
                pq.pop();
                rq.erase(t);
                continue;
            }
            pq.pop();
            rpq.insert(t);
            return t;
        }
    }
};

Note that the code uses a standard C++ priority queue, which is not a Fibonacci heap, but this can be straight-swapped in. Also, the code assumes that element values are unique, but this can be accounted for in the case that they are not (by associating elements with unique IDs).