Short answer

Assuming that each set of columns identified by its type will not have blank cells, a double QUERY and TRANSPOSE could be used to filter them:

=Transpose(
     QUERY(
         Transpose(
              QUERY(
                  E1:M13,
                  "Select * where M = '"&F15&"'",
                  1
              )
         ),
         "Select * Where Col2 <>''"
     )
 )

Explanation

Google Sheets doesn't include functions able to "filter columns" as was called by the OP, but there are several ways to achieve the desired result. In this answer, one of this ways is presented.

From the deepest function in the formula to de shallowest:

QUERY(E1:M13,"Select * where M = '"&F15&"'",1)

Returns all the columns where the type set in column M match the value set in the cell F15.

First TRANSPOSE() occurrence

Change columns to rows.

The result until this point will be referred as X.

QUERY( X , "Select * Where Col2 <>''")

Filters the original columns and returns those without any value. Col1 correspond to the table headers, Col2 correspond to the first row of rows that match the filtering criteria of the first QUERY().

Second TRANSPOSE() occurrence Chang columns to rows so the result shape correspond to the shape of the original data.

Remarks

In Google Sheets,

• An array is a two dimensional sets of values that could be denoted by enclosing them between braces { , }.
• A range is also two dimensional set of cells that could be denoted by cell references, i.e. A1, A1:E5.
• A result of a function or formula could be a single or multiple values. Technically it could be said that a result is a two dimensional array from 1 X 1 to n X m

References

• Using arrays in Google Sheets - Google Editors Help

To sort a query you simply have to wrap it in SORT.

=SORT(
    QUERY(
        {SheetOne!C3:F;SheetTwo!C3:F;SheetThree!F4:G;SheetFour!F4:G}
    )
    , 1, TRUE)

For example, the above formula takes the data from the sheets inside the query, and then sorts by ascending order from column 1.

This also works well to solve the problem of row splitting, where some rows get split up if you use different queries to pull from rows you intend to keep uniform.