```python
def region_totals(grid: list, queries: list) -> list:
    """
    Calculate the sum of elements in specified blocks of a grid.

    :param grid: A non-empty list of rows, each row is a non-empty list of integers,
                 and every row has the same length.
    :param queries: A list of queries, each a four-integer list [top, left, bottom, right].
    :return: A list of block totals in query order.

    Raises:
        ValueError: If grid is invalid or contains non-integer values.
        ValueError: If any query is invalid.
    """
    if not grid or not all(grid):
        raise ValueError("Grid must have at least one row with at least one cell.")
    
    rows, cols = len(grid), len(grid[0])
    for row in grid:
        if len(row) != cols:
            raise ValueError("All rows must have the same length.")
        if not all(isinstance(cell, int) for cell in row):
            raise ValueError("All cells must be integers.")

    prefix_sum = [[0] * (cols + 1) for _ in range(rows + 1)]
    for i in range(1, rows + 1):
        for j in range(1, cols + 1):
            prefix_sum[i][j] = grid[i - 1][j - 1] + prefix_sum[i - 1][j] + prefix_sum[i][j - 1] - prefix_sum[i - 1][j - 1]

    results = []
    for query in queries:
        if not isinstance(query, list) or len(query) != 4:
            raise ValueError("Query must be a list of exactly four integers.")
        top, left, bottom, right = query
        if not (0 <= top < rows and 0 <= left < cols and top < bottom and left < right):
            raise ValueError("Query coordinates are out of bounds or invalid.")
        
        total = (prefix_sum[bottom][right] - prefix_sum[top][right] -
                 prefix_sum[bottom][left] + prefix_sum[top][left])
        results.append(total)

    return results
```