import ceylon.language.meta.model {
    Interface,
    MemberInterface,
    AppliedType = Type,
    IncompatibleTypeException,
    TypeApplicationException​
}
​
"""An interface declaration.
   
   <a name="toplevel-sample">a>
   ### Usage sample for toplevel interfaces​
   
   Because some interfaces have type parameters, getting a model requires applying type arguments to the​
   interface declaration with [[interfaceApply]] in order to be able to get a closed type. For example, here is how you would​
   obtain an interface model from a toplevel interface declaration:
   
       interface Foo<T> satisfies List<T> {
       }
       
       void test(){
           // We need to apply the Integer closed type to the Foo declaration in order to get the Foo<Integer> closed type​
           Interface<Foo<Integer>> interfaceModel = `interface Foo`.interfaceApply<Foo<Integer>>(`Integer`);
           // This will print: ceylon.language::List<ceylon.language::Integer>​
           for(satisfiedType in interfaceModel.satisfiedTypes){
               print(satisfiedType);
           }
       }
   
   <a name="member-sample">a>
   ### Usage sample for member interfaces​
	
   For member interfaces it is a bit longer, because member interfaces need to be applied not only their type arguments but also​
   the containing type, so you should use [[memberInterfaceApply]] and start by giving the containing closed type:
   
       class Outer(){
           shared interface Inner<T> satisfies List<T> {
           }
       }
	
       void test(){
           // apply the containing closed type `Outer` to the member class declaration `Outer.Inner`​
           MemberInterface<Outer,Outer.Inner<Integer>> memberInterfaceModel = `interface Outer.Inner`.memberInterfaceApply<Outer,Outer.Inner<Integer>>(`Outer`, `Integer`);
           // This will print: ceylon.language::List<ceylon.language::Integer>​
           for(satisfiedType in memberInterfaceModel.satisfiedTypes){
               print(satisfiedType);
           }
       }
   """
​
​shared sealed interface InterfaceDeclaration​
        satisfies ClassOrInterfaceDeclaration {
    
    "Applies the given closed type arguments to this toplevel interface 
     declaration in order to obtain an interface model. 
     See [this code sample](#toplevel-sample) for an example on how to use this."​
    throws(`class IncompatibleTypeException`, 
        "If the specified `Type` type argument is not compatible with the 
         actual result.")
    throws(`class TypeApplicationException`, 
            "If the specified closed type argument values are not compatible 
             with the actual result's type parameters.")
    shared formal Interface<Type> interfaceApply<Type=Anything>(AppliedType<>* typeArguments);
​
    "Applies the given closed container type and type arguments to this member 
     interface declaration in order to obtain a member interface model. 
     See [this code sample](#member-sample) for an example on how to use this."​
    throws(`class IncompatibleTypeException`, 
        "If the specified `Container` or `Type` type arguments are not 
         compatible with the actual result.")
    throws(`class TypeApplicationException`, 
            "If the specified closed container type or type argument values 
             are not compatible with the actual result's container type or 
             type parameters.")
    shared formal MemberInterface<Container, Type> memberInterfaceApply<Container=Nothing, Type=Anything>(AppliedType<Object> containerType, AppliedType<>* typeArguments);
}
​