class Restricted ()
{

public int Property1{get; }
public int Property2{get; }

}

public int Property1{ get; private set;}

public interface IPublicProperties
{
  int Property1 { get; }
  int Property2 { get; }
}

internal class Restricted : IPublicProperties
{
  public int Property1 { get; set; }
  public int Property2 { get; set; }
}

#include <iostream>

  struct unlocked {
      int a;
      int b;
      //virtual ~unlocked(); // don't call delete on a unlocked
  };

  class locked : private unlocked {

     public:
     locked() {
        a = 0 ;  // accessible within locked
        b = 1 ;
    }

     unlocked& unlock( ) {
        return *this ;
     }

     void print( std::ostream& o ) {
        o << " a = " << a << ", b = " << b << std::endl ;
     }

  } ;

int main() {

     locked foo ;
     foo.print( std::cout );
     // foo.a = 1 ; illegal
     foo.unlock().a = 1 ;
     foo.print( std::cout ) ;
     std::cout << &foo << " " << &(foo.unlock()) << std::endl;
  }

#include <iostream>

  class locked ;

  class keyed ;

  class keyed {
     protected:
      struct key{};

     public:
     void mutateLocked( locked& );
  };


  struct unlocked {
      int a;
      int b;
      void print( std::ostream& o ) {
        o << this << " a = " << a << ", b = " << b << std::endl ;
      }
  };

  class locked : private unlocked, private keyed {

     public:
     locked() {
        a = 0 ;
        b = 1 ;
    }

     unlocked& unlock( keyed::key& k) {
        return *this ;
     }

     using unlocked::print;
  } ;

  void keyed::mutateLocked(locked& m ) {
     key k ;
     m.print(std::cout) ;
     unlocked& n = m.unlock( k ) ;
     n.a = 55;
     n.b = 77;
     n.print(std::cout);
  }

int main() {

     keyed k ;
     //keyed::key kk; // not accessible

     locked foo ;
     //unlocked& bar = (unlocked) foo; // not accessible
     foo.print( std::cout );
     //foo.a = 1 ;  // not accessible
     //foo.unlock(kk).a = 1 ;
     k.mutateLocked(foo);
     foo.print( std::cout ) ;
 }