To solve this problem, we need to implement a FastAPI endpoint that processes image data to generate a thumbnail without blocking the event loop. Since the provided `resize_image` function is CPU-bound, we should offload the processing to a separate thread to maintain non-blocking behavior.

### Approach
1. **Non-blocking Event Loop**: Use FastAPI's `run_in_threadpool` utility to run the CPU-bound `resize_image` function in a thread pool, preventing the event loop from being blocked.
2. **Async Endpoint**: Define the endpoint as `async` to ensure compatibility with FastAPI's asynchronous capabilities.
3. **Request Handling**: Accept the raw image bytes directly from the request body.
4. **Response**: Return the size of the thumbnail bytes in a JSON response with a status code of 200.

### Solution Code

```python
from fastapi import FastAPI
from fastapi.concurrency import run_in_threadpool

import helpers  # noqa: F401  (the provided API)

app = FastAPI()


@app.post("/thumbnail")
async def thumbnail(data: bytes) -> dict:
    thumbnail_data = await run_in_threadpool(helpers.resize_image, data)
    return {"size": len(thumbnail_data)}
```

### Explanation
- **Importing Utilities**: We import `run_in_threadpool` from `fastapi.concurrency` to handle the CPU-bound task asynchronously.
- **Endpoint Definition**: The `thumbnail` function is defined as `async` to avoid blocking the event loop.
- **Processing Data**: We pass the `resize_image` function and the incoming image data to `run_in_threadpool`, which runs the function in a separate thread.
- **Response**: After obtaining the thumbnail bytes, we return their length in a JSON object with a 200 status code.

This approach ensures that the event loop remains unblocked while the CPU-intensive image resizing operation is handled efficiently in a separate thread.