Module signature to guarantee type expands to a polymorphic variant

Is there a way to write down a module signature such that we can guarantee a contained type t expands to a polymorphic variant?

As an example, we can write the following:

module Base = struct 
  type t = [ `One | `Two]

module Extended = struct
  type t = [ `More | Base.t ]

and we have

module Extended : sig 
  type t = [ `More | `One | `Two ] 

However, I don’t know what signature I should provide to write this general case as functor i.e.

module Extend (Base: sig type t = ??? end) = struct
  type t = [`More |  Base.t]

Is there any way to do this, perhaps using constraints?

That would not work even if it was possible.
When you write

type t = [ `A | ` B ]
type u = [ `C | t ]

it is the definition of t which is expanded in the definition of u and not really the constructor, as you can check with

type u = [ `C | 'x  ] constraint 'x = [ `A | ` B] 

Error: The type 'x does not expand to a polymorphic variant type

The error message should probably be reworded to avoid this confusion.