As you can see the set of rights that user can perform are getting filtered as the hierarchy goes down.
Do not fall into the trap of thinking that anything you observe is therefore an immovable truth.
It is indeed currently the case that when you order the list in that way, that the roles sequentially only "lose" access, never gain anything. But that does not mean that:
- this is a hard and fast rule you can rely on
- this is always going to be the case
- you should hinge your role definitions on this phenomenon
To make it easier to understand, let's use a different context. My car has four wheels. It also has one steering wheel. It also has four cup holders.
Should I now design cars with the philosophy that a car must have as many cup holders in a car as it has wheels or vice versa? Should exactly 20% of the wheels on a car be a steering wheel, and the other 80% a road wheel? All of these observations are true for my car, after all...
The simple answer here is "no". Just because it's true of my car today doesn't mean that it's true for every car, or that it's a rule I should define or start relying on.
Back to your example, rather than trying to define your roles as some contrived dependent hierarchy that relies on this "sequential access filtering" observation, it's significantly better to define user roles independently.
That is to say that you define a bunch of roles, and a bunch of access rights. And then you list which access rights a particular role has.
This is essentially the list you already have in your question, but without the implication that there is some order between the definition of each role.
By defining them independently, that will make it easier for you to change one use role without needing to consider the impact that this change will have on other roles (which would depend on this role if you defined your use cases hierarchically).
If, for example, your attendants suddenly get access to something that the sellers don't get access to, then your entire system collapses, because your arbitrary rule is now invalidated. Think of how much work that would be to correct, if your use cases were used as a guiding measure for code implementations, documentation and support staff training.
Comparatively, if roles had always been defined independently, this would amount to a simple "hey role X now also has access to Y", which is significantly easier to code/explain/document.
