Yeah... right now there's no way to do that with `node-restify-validation`. It might not be worth the effort, but if we do want to support nested keys or validating elements of an array (as we'd need to do for `screenshots`, for example), I think we'd need to implement some kind of pattern-matching system that implicitly asserts the type of each value in the path. 

So for example, a key of `screenshots[]` would first assert that `screenshots` exists and is an array, then validate each element of `screenshots` using the specified validation block. These patterns could be combined, so `screenshots[].height` would search for a `height` key in every element of `screenshots`, and validate each result. So to validate `screenshots`, we would do something like this:

```js
validation: {
    'screenshots[].height': { isRequired: true, isInt: true },
    'screenshots[].width': { isRequired: true, isInt: true },
    'screenshots[].src': { isRequired: true, isUrl: true }
}
```

This would probably start getting messy for complex sub-hashes, so maybe some alternative syntax that uses logical grouping of sub-patterns would work better. For example, `screenshots[]` could contain an object that validates keys of each element in the `screenshots` array. Unfortunately we'd need to wrap those in a distinct object that `node-restify-validation` could notice and treat specially, or at least have some kind of special key that marks it as such. Something like this:

```js
validation: {
    'screenshots[]': { 
        _compound: true,
        height: { isRequired: true, isInt: true },
        width: { isRequired: true, isInt: true },
        src: { isRequired: true, isUrl: true }
     }
}
```

I think either of these solutions would be sufficiently flexible to cover most any nested validation that we would need to do. But again, it might not be worth the effort to implement — we could always just validate nested keys and such manually.

What do you think?