```python
def region_totals(grid: list, queries: list) -> list:
    """
    Calculate the totals of regions in a grid based on given queries.

    :param grid: A non-empty list of rows, each row is a list of integers.
    :param queries: A list of four-element lists [top, left, bottom, right].
    :return: A list of region totals corresponding to each query.
    """
    
    # Validate the grid
    if not grid or not grid[0] or any(len(row) != len(grid[0]) for row in grid):
        raise ValueError("Grid must be non-empty and all rows must have the same length.")
    for row in grid:
        for cell in row:
            if not isinstance(cell, int):
                raise ValueError("All cells must be integers.")
    
    # Validate queries
    for query in queries:
        if len(query) != 4 or not all(isinstance(i, int) for i in query):
            raise ValueError("Queries must be four-element lists of integers.")
        top, left, bottom, right = query
        if top >= bottom or left >= right:
            raise ValueError("Top and left bounds must be strictly less than bottom and right bounds respectively.")
        if top < 0 or left < 0:
            raise ValueError("Query boundaries cannot be negative.")
    
    # Precompute prefix sums for efficient querying
    m, n = len(grid), len(grid[0])
    prefix_sum = [[0] * (n + 1) for _ in range(m + 1)]
    for i in range(1, m + 1):
        for j in range(1, n + 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]
    
    # Calculate region totals using precomputed prefix sums
    results = []
    for top, left, bottom, right in queries:
        total = prefix_sum[bottom][right] - prefix_sum[bottom][left] - prefix_sum[top][right] + prefix_sum[top][left]
        results.append(total)
    
    return results
```