puremvc 1.0.0 → 1.0.1

data/lib/patterns/proxy/proxy.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# proxy.rb
+# PureMVC Ruby Multicore
+#
+# Copyright(c) 2025 Saad Shams <saad.shams@puremvc.org>
+# Your reuse is governed by the BSD 3-Clause License
+
+module PureMVC
+  # A base <code>IProxy</code> implementation.
+  #
+  # In PureMVC, <code>Proxy</code> classes are used to manage parts of the application's data model.
+  #
+  # A <code>Proxy</code> might simply manage a reference to a local data object, in which case
+  # interacting with it might involve setting and getting of its data in a synchronous fashion.
+  #
+  # <code>Proxy</code> classes are also used to encapsulate the application's interaction with
+  # remote services to save or retrieve data. In this case, we adopt an asynchronous idiom:
+  # setting data (or calling a method) on the <code>Proxy</code> and listening for a <code>Notification</code>
+  # to be sent when the <code>Proxy</code> has retrieved the data from the service.
+  #
+  # @see Model
+  class Proxy < Notifier
+    # The name of the <code>Proxy</code>.
+    NAME = 'Proxy'
+    public_constant :NAME
+
+    # @return [String] The proxy name
+    attr_reader :name
+
+    # @return [Object, nil] The data managed by the proxy
+    attr_accessor :data
+
+    # Initializes a new Proxy instance.
+    #
+    # @param [String, nil] name the name of the proxy
+    # @param [Object, nil] data optional data to be managed by the proxy
+    def initialize(name = nil, data = nil)
+      super()
+      @name = name || NAME
+      @data = data
+    end
+
+    # Called by the Model when the Proxy is registered
+    def on_register; end
+
+    # Called by the Model when the Proxy is removed
+    def on_remove; end
+  end
+end

data/lib/puremvc.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# puremvc.rb
+# PureMVC Ruby Multicore
+#
+# Copyright(c) 2025 Saad Shams <saad.shams@puremvc.org>
+# Your reuse is governed by the BSD 3-Clause License
+
+require_relative 'core/controller'
+require_relative 'core/model'
+require_relative 'core/view'
+require_relative 'patterns/observer/notifier'
+require_relative 'patterns/command/simple_command'
+require_relative 'patterns/command/macro_command'
+require_relative 'patterns/facade/facade'
+require_relative 'patterns/mediator/mediator'
+require_relative 'patterns/observer/notification'
+require_relative 'patterns/observer/observer'
+require_relative 'patterns/proxy/proxy'

data/sig/lib/core/controller.rbs

@@ -0,0 +1,40 @@
+module PureMVC
+
+  class Controller
+
+    include _IController
+
+    MULTITON_MSG: String
+
+    self.@instance_map: Hash[String, _IController]
+
+    self.@mutex: Mutex
+
+    @multiton_key: String
+
+    @view: _IView?
+
+    @command_map: Hash[String, ^() -> _ICommand]
+
+    @command_mutex: Mutex
+
+    def self.instance_map: () -> Hash[String, _IController]
+
+    private
+
+    def self.mutex: () -> Mutex
+
+    public
+
+    def self.get_instance: (String key) { (String k) -> _IController } -> _IController
+
+    def self.remove_controller: (String key) -> void
+
+    def initialize: (String key) -> void
+
+    def initialize_controller: () -> void
+  end
+
+  # Type-level assertion that Controller conforms to _IController
+  type controller_validation = validate_controller[Controller]
+end

data/sig/lib/core/model.rbs

@@ -0,0 +1,38 @@
+module PureMVC
+
+  class Model
+
+    include _IModel
+
+    MULTITON_MSG: String
+
+    self.@instance_map: Hash[String, _IModel]
+
+    self.@mutex: Mutex
+
+    @multiton_key: String
+
+    @proxy_map: Hash[String, _IProxy]
+
+    @proxy_mutex: Mutex
+
+    def self.instance_map: () -> Hash[String, _IModel]
+
+    private
+
+    def self.mutex: () -> Mutex
+
+    public
+
+    def self.get_instance: (String key) { (String k) -> _IModel } -> _IModel
+
+    def self.remove_model: (String key) -> void
+
+    def initialize: (String key) -> void
+
+    def initialize_model: () -> void
+  end
+
+  # Type-level assertion that Model conforms to _IModel
+  type model_validation = validate_model[Model]
+end

data/sig/lib/core/view.rbs

@@ -0,0 +1,42 @@
+module PureMVC
+
+  class View
+
+    include _IView
+
+    MULTITON_MSG: String
+
+    self.@instance_map: Hash[String, _IView]
+
+    self.@mutex: Mutex
+
+    @multiton_key: String
+
+    @observer_map: Hash[String, Array[_IObserver]]
+
+    @observer_mutex: Mutex
+
+    @mediator_map: Hash[String, _IMediator]
+
+    @mediator_mutex: Mutex
+
+    def self.instance_map: () -> Hash[String, _IView]
+
+    private
+
+    def self.mutex: () -> Mutex
+
+    public
+
+    def self.get_instance: (String key) { (String k) -> _IView } -> _IView
+
+    def self.remove_view: (String key) -> void
+
+    def initialize: (String key) -> void
+
+    def initialize_view: () -> void
+  end
+
+  # Type-level assertion that View conforms to _IView
+  type view_validation = validate_view[View]
+end

data/sig/lib/interfaces/i_command.rbs

@@ -0,0 +1,18 @@
+module PureMVC
+  # The interface definition for a PureMVC Command.
+  #
+  # @see INotification
+  interface _ICommand
+
+    include _INotifier
+
+    # Execute the <code>_ICommand</code>'s logic to handle a given <code>_INotification</code>.
+    #
+    # @abstract This method must be implemented by the concrete command.
+    # @param notification [_INotification] an _INotification to handle.
+    def execute: (_INotification notification) -> void
+  end
+
+  # Assert that the given `Command` type parameter is a subtype of `_ICommand`
+  type validate_command[Command < _ICommand] = top
+end

data/sig/lib/interfaces/i_controller.rbs

@@ -0,0 +1,52 @@
+module PureMVC
+  # The interface definition for a PureMVC Controller.
+  #
+  # In PureMVC, an <code>_IController</code> implementor
+  # follows the 'Command and Controller' strategy, and
+  # assumes these responsibilities:
+  #
+  # - Remembering which <code>_ICommand</code>s
+  #   are intended to handle which <code>_INotifications</code>.
+  # - Registering itself as an <code>_IObserver</code> with
+  #   the <code>View</code> for each <code>_INotification</code>
+  #   that it has an <code>_ICommand</code> mapping for.
+  # - Creating a new instance of the proper <code>_ICommand</code>
+  #   to handle a given <code>_INotification</code> when notified by the <code>View</code>.
+  # - Calling the <code>_ICommand</code>'s <code>execute</code>
+  #   method, passing in the <code>_INotification</code>.
+  #
+  # @see INotification
+  # @see ICommand
+  interface _IController
+    # Register a particular <code>_ICommand</code> class as the handler
+    # for a particular <code>_INotification</code>.
+    #
+    # @abstract This method must be implemented by the concrete command.
+    # @param notification_name [String] the name of the <code>_INotification</code>
+    # @param factory [^() -> _ICommand] the class of the _ICommand
+    def register_command: (String notification_name) { () -> _ICommand  } -> void
+
+    # Execute the <code>ICommand</code> previously registered as the
+    # handler for <code>INotification</code>s with the given notification name.
+    #
+    # @abstract This method must be implemented by the concrete command.
+    # @param notification [_INotification] the <code>_INotification</code> to execute the associated <code>_ICommand</code> for
+    def execute_command: (_INotification notification) -> void
+
+    # Check if a Command is registered for a given Notification.
+    #
+    # @abstract This method must be implemented by the concrete command.
+    # @param notification_name [String]
+    # @return [Boolean] whether a Command is currently registered for the given <code>notificationName</code>.
+    def has_command?: (String notification_name) -> bool
+
+    # Remove a previously registered <code>_ICommand</code> to <code>_INotification</code> mapping.
+    #
+    # @abstract This method must be implemented by the concrete command.
+    # @param notification_name [String] the name of the <code>_INotification</code> to remove the <code>_ICommand</code> mapping for
+    def remove_command: (String notification_name) -> void
+  end
+
+  # Assert that the given `Controller` type parameter is a subtype of `_IController`
+  type validate_controller[Controller < _IController] = top
+end

data/sig/lib/interfaces/i_facade.rbs

@@ -0,0 +1,116 @@
+module PureMVC
+  # The interface definition for a PureMVC Facade.
+  #
+  # The Facade Pattern suggests providing a single
+  # class to act as a central point of communication
+  # for a subsystem.
+  #
+  # In PureMVC, the Facade acts as an interface between
+  # the core MVC actors (<code>Model</code>, <code>View</code>, <code>Controller</code>) and
+  # the rest of your application.
+  #
+  # @see IModel
+  # @see IView
+  # @see IController
+  # @see ICommand
+  # @see INotification
+  interface _IFacade
+
+    # Register an <code>_ICommand</code> with the <code>Controller</code>.
+    #
+    # @param notification_name [String] the name of the <code>_INotification</code> to associate the <code>_ICommand</code> with.
+    # @param factory [^() -> _ICommand] the factory to produce an instance of the _ICommand
+    def register_command: (String notification_name) { () -> _ICommand } -> void
+
+    # Check if a Command is registered for a given Notification
+    #
+    # @param notification_name [String]
+    # @return [Boolean] whether a Command is currently registered for the given <code>notification_name</code>.
+    def has_command?: (String notification_name) -> bool
+
+    # Remove a previously registered <code>_ICommand</code> to <code>_INotification</code> mapping from the Controller.
+    #
+    # @param notification_name [String] the name of the <code>_INotification</code> to remove the <code>_ICommand</code> mapping for
+    def remove_command: (String notification_name) -> void
+
+    # Register an <code>_IProxy</code> with the <code>Model</code> by name.
+    #
+    # @param proxy [_IProxy] the <code>_IProxy</code> to be registered with the <code>Model</code>.
+    def register_proxy: (_IProxy proxy) -> void
+
+    # Retrieve a <code>IProxy</code> from the <code>Model</code> by name.
+    #
+    # @param proxy_name [String] the name of the <code>_IProxy</code> instance to be retrieved.
+    # @return [_IProxy | nil] the <code>IProxy</code> previously registered by <code>proxy_name</code> with the <code>Model</code>.
+    def retrieve_proxy: (String proxy_name) -> _IProxy?
+
+    # Check if a Proxy is registered
+    #
+    # @param proxy_name [String]
+    # @return [Boolean] whether a Proxy is currently registered with the given <code>proxy_name</code>.
+    def has_proxy?: (String proxy_name) -> bool
+
+    # Remove an <code>_IProxy</code> instance from the <code>Model</code> by name.
+    #
+    # @param proxy_name [String] the <code>_IProxy</code> to remove from the <code>Model</code>.
+    # @return [_IProxy | nil] the <code>_IProxy</code> that was removed from the <code>Model</code>
+    def remove_proxy: (String proxy_name) -> _IProxy?
+
+    # Register an <code>_IMediator</code> instance with the <code>View</code>.
+    #
+    # @param mediator [_IMediator] a reference to the <code>_IMediator</code> instance
+    def register_mediator: (_IMediator mediator) -> void
+
+    # Retrieve an <code>_IMediator</code> instance from the <code>View</code>.
+    #
+    # @param mediator_name [String] the name of the <code>_IMediator</code> instance to retrieve
+    # @return [_IMediator | nil] the <code>_IMediator</code> previously registered with the given <code>mediator_name</code>.
+    def retrieve_mediator: (String mediator_name) -> _IMediator?
+
+    # Check if a Mediator is registered or not
+    #
+    # @param mediator_name [String]
+    # @return [Boolean] whether a Mediator is registered with the given <code>mediator_name</code>.
+    def has_mediator?: (String mediator_name) -> bool
+
+    # Remove an <code>_IMediator</code> instance from the <code>View</code>.
+    #
+    # @param mediator_name [String] name of the <code>IMediator</code> instance to be removed.
+    # @return [_IMediator | nil] the <code>_IMediator</code> instance previously registered with the given <code>mediator_name</code>.
+    def remove_mediator: (String mediator_name) -> _IMediator?
+
+    # Initialize this _INotifier instance.
+    #
+    # This is how a </code>Notifier</code> gets its multitonKey.
+    # Calls to <code>send_notification</code> or to access the
+    # facade will fail until after this method has been called.
+    #
+    # @param key [String] The multitonKey for this INotifier to use.
+    def initialize_notifier: (String key) -> void
+
+    # Notify <code>Observer</code>s.
+    #
+    # This method is left public mostly for backward
+    # compatibility and to allow you to send custom
+    # notification classes using the facade.
+    #
+    # Usually you should call sendNotification
+    # and pass the parameters, never having to
+    # construct the notification yourself.
+    #
+    # @param notification [_INotification] the <code>_INotification</code> to have the <code>View</code> notify <code>Observers</code> of.
+    def notify_observers: (_INotification notification) -> void
+
+    # Send a <code>_INotification</code>.
+    #
+    # Convenience method to prevent having to construct new
+    # notification instances in our implementation code.
+    #
+    # @param name [String] The name of the notification to send.
+    # @param body [Object, nil] The body of the notification (optional).
+    # @param type [String, nil] The type of the notification (optional).
+    def send_notification: (String name, ?Object? body, ?String? type) -> void
+  end
+
+  type validate_facade[Facade < _IFacade] = top
+end

data/sig/lib/interfaces/i_mediator.rbs

@@ -0,0 +1,60 @@
+module PureMVC
+  #
+  # The interface definition for a PureMVC <code>_IMediator</code>.
+  #
+  # In PureMVC, <code>_IMediator</code> implementors assume these responsibilities:
+  #
+  # * Implement a common method that returns a list of all <code>_INotification</code>s
+  #   the <code>_IMediator</code> has interest in.
+  # * Implement a notification callback method.
+  # * Implement methods that are called when the <code>_IMediator</code> is registered or removed from the <code>View</code>.
+  #
+  # Additionally, <code>_IMediator</code>s typically:
+  #
+  # * Act as an intermediary between one or more view components such as text boxes or list controls,
+  #   maintaining references and coordinating their behavior.
+  # * In Flash-based apps, this is often the place where event listeners are
+  #   added to view components, and their handlers implemented.
+  # * Respond to and generate <code>_INotifications</code>, interacting with the rest of the PureMVC app.
+  #
+  # When an <code>_IMediator</code> is registered with the <code>_IView</code>,
+  # the <code>_IView</code> will call the <code>_IMediator</code>'s <code>list_notification_interests</code> method.
+  # The <code>_IMediator</code> will return an <code>Array</code> of <code>_INotification</code> names
+  # which it wishes to be notified about.
+  #
+  # The <code>_IView</code> will then create an <code>Observer</code> object
+  # encapsulating that <code>IMediator</code>'s <code>handle_notification</code> method
+  # and register it as an Observer for each <code>_INotification</code> name returned by <code>list_notification_interests</code>.
+  #
+  # @see INotification
+  interface _IMediator
+
+    include _INotifier
+
+    # @return [String] The name of the Mediator.
+    def name: () -> String
+
+    # @return [Object, nil] The view component associated with this Mediator.
+    def view: () -> Object?
+    def view=: (Object?) -> void
+
+    # List <code>_INotification</code> interests.
+    #
+    # @return [Array] an <code>Array</code> of the <code>_INotification</code> names this <code>_IMediator</code> has an interest in.
+    def list_notification_interests: () -> Array[String]
+
+    # Handle an <code>INotification</code>.
+    #
+    # @param notification [_INotification] the <code>_INotification</code> to be handled
+    def handle_notification: (_INotification notification) -> void
+
+    # Called by the View when the Mediator is registered.
+    def on_register: () -> void
+
+    # Called by the View when the Mediator is registered.
+    def on_remove: () -> void
+  end
+
+  # Assert that the given `Mediator` type parameter is a subtype of `_IMediator`
+  type validate_mediator[Mediator < _IMediator] = top
+end

data/sig/lib/interfaces/i_model.rbs

@@ -0,0 +1,38 @@
+module PureMVC
+  # The interface definition for a PureMVC Model.
+  #
+  # In PureMVC, <code>_IModel</code> implementors provide
+  # access to <code>_IProxy</code> objects by named lookup.
+  #
+  # An <code>_IModel</code> assumes these responsibilities:
+  #
+  # - Maintain a cache of <code>_IProxy</code> instances
+  # - Provide methods for registering, retrieving, and removing <code>_IProxy</code> instances
+  interface _IModel
+    # Register an <code>_IProxy</code> instance with the <code>Model</code>.
+    #
+    # @param proxy [_IProxy] an object reference to be held by the <code>Model</code>.
+    def register_proxy: (_IProxy proxy) -> void
+
+    # Retrieve an <code>_IProxy</code> instance from the <code>Model</code>.
+    #
+    # @param proxy_name [String]
+    # @return [_IProxy] the <code>_IProxy</code> instance previously registered with the given <code>proxyName</code>.
+    def retrieve_proxy: (String proxy_name) -> _IProxy?
+
+    # Check if a <code>Proxy</code> is registered.
+    #
+    # @param proxy_name [String]
+    # @return [Boolean] whether a <code>Proxy</code> is currently registered with the given <code>proxyName</code>.
+    def has_proxy?: (String proxy_name) -> bool
+
+    # Remove an <code>_IProxy</code> instance from the <code>Model</code>.
+    #
+    # @param proxy_name [String] name of the <code>_IProxy</code> instance to be removed.
+    # @return [_IProxy | nil] the <code>_IProxy</code> that was removed from the <code>Model</code>.
+    def remove_proxy: (String proxy_name) -> _IProxy?
+  end
+
+  # Assert that the given `Model` type parameter is a subtype of `_IModel`
+  type validate_model[Model < _IModel] = top
+end

data/sig/lib/interfaces/i_notification.rbs

@@ -0,0 +1,52 @@
+module PureMVC
+  # The interface definition for a PureMVC Notification.
+  #
+  # PureMVC does not rely upon underlying event models such
+  # as the one provided with Flash, and ActionScript 3 does
+  # not have an inherent event model.
+  #
+  # The Observer Pattern as implemented within PureMVC exists
+  # to support event-driven communication between the
+  # application and the actors of the MVC triad.
+  #
+  # Notifications are not meant to be a replacement for Events
+  # in Flex/Flash/AIR. Generally, <code>_IMediator</code> implementors
+  # place event listeners on their view components, which they
+  # then handle in the usual way. This may lead to the broadcast of <code>Notification</code>s to
+  # trigger <code>_ICommand</code>s or to communicate with other <code>_IMediators</code>.
+  # <code>_IProxy</code> and <code>_ICommand</code>
+  # instances communicate with each other and <code>_IMediator</code>s
+  # by broadcasting <code>_INotification</code>s.
+  #
+  # A key difference between Flash <code>Event</code>s and PureMVC
+  # <code>Notification</code>s is that <code>Event</code>s follow the
+  # 'Chain of Responsibility' pattern, 'bubbling' up the display hierarchy
+  # until some parent component handles the <code>Event</code>, while
+  # PureMVC <code>Notification</code>s follow a 'Publish/Subscribe'
+  # pattern. PureMVC classes need not be related to each other in a
+  # parent/child relationship to communicate with one another
+  # using <code>Notification</code>s.
+  #
+  # @see IView
+  # @see IObserver
+  interface _INotification
+    # @return [String] the name of the notification
+    def name: () -> String
+
+    # @return [Object, nil] the body of the notification
+    def body: () -> Object?
+    def body=: (Object?) -> void
+
+    # @return [String, nil] the type of the notification
+    def type: () -> String?
+    def type=: (String?) -> void
+
+    # Get the string representation of the <code>_INotification</code> instance
+    #
+    # @return [String]
+    def to_s: () -> String
+  end
+
+  # Assert that the given `Notification` type parameter is a subtype of `_INotification`
+  type validate_notification[Notification < _INotification] = top
+end

data/sig/lib/interfaces/i_notifier.rbs

@@ -0,0 +1,48 @@
+module PureMVC
+  # The interface definition for a PureMVC Notifier.
+  #
+  # <code>MacroCommand, Command, Mediator</code> and <code>Proxy</code>
+  # all have a need to send <code>Notifications</code>.
+  #
+  # The <code>_INotifier</code> interface provides a common method called
+  # <code>sendNotification</code> that relieves implementation code of
+  # the necessity to actually construct <code>Notifications</code>.
+  #
+  # The <code>Notifier</code> class, which all the above-mentioned classes
+  # extend, also provides an initialized reference to the <code>Facade</code>
+  # Singleton, which is required for the convenience method
+  # for sending <code>Notifications</code>, but also eases implementation as these
+  # classes have frequent <code>Facade</code> interactions and usually require
+  # access to the facade anyway.
+  #
+  # @see IFacade
+  # @see INotification
+  interface _INotifier
+    # Initialize this _INotifier instance.
+    #
+    # This is how a </code>Notifier</code> gets its multitonKey.
+    # Calls to <code>send_notification</code> or to access the
+    # facade will fail until after this method has been called.
+    #
+    # @param key [String] The multitonKey for this INotifier to use.
+    def initialize_notifier: (String key) -> void
+
+    # Send a <code>_INotification</code>.
+    #
+    # Convenience method to prevent having to construct new
+    # notification instances in our implementation code.
+    #
+    # @param name [String] The name of the notification to send.
+    # @param body [Object, nil] The body of the notification (optional).
+    # @param type [String, nil] The type of the notification (optional).
+    def send_notification: (String name, ?Object? body, ?String? type) -> void
+
+    # Return the Multiton Facade instance
+    #
+    # @raise [RuntimeError] if the <code>multiton_key</code> is not set
+    # @return [_IFacade] the facade instance for the notifier's key
+    def facade: () -> _IFacade
+  end
+
+  type validate_notifier[Notifier < _INotifier] = top
+end

data/sig/lib/interfaces/i_observer.rbs

@@ -0,0 +1,56 @@
+module PureMVC
+  # The interface definition for a PureMVC Observer.
+  #
+  # In PureMVC, <code>_IObserver</code> implementors assume these responsibilities:
+  # - Encapsulate the notification (callback) method of the interested object.
+  # - Encapsulate the notification context (this) of the interested object.
+  # - Provide methods for setting the interested object's notification method and context.
+  # - Provide a method for notifying the interested object.
+  #
+  # PureMVC does not rely upon underlying event
+  # models such as the one provided with Flash,
+  # and ActionScript 3 does not have an inherent
+  # event model.
+  #
+  # The Observer Pattern as implemented within
+  # PureMVC exists to support event-driven communication
+  # between the application and the actors of the
+  # MVC triad.
+  #
+  # An Observer is an object that encapsulates information
+  # about an interested object with a notification method that
+  # should be called when an <code>_INotification</code> is broadcast. The Observer then
+  # acts as a proxy for notifying the interested object.
+  #
+  # Observers can receive <code>Notification</code>s by having their
+  # <code>notifyObserver</code> method invoked, passing
+  # in an object implementing the <code>_INotification</code> interface, such
+  # as a subclass of <code>Notification</code>.
+  #
+  # @see IView
+  # @see INotification
+  interface _IObserver
+
+    # @return [Method, nil] The callback method to be called on notification.
+    def notify: () -> Method?
+    def notify=: (Method?) -> void
+
+    # @return [Object, nil] The object context for the callback.
+    def context: () -> Object?
+    def context=: (Object?) -> void
+
+    # Notify the interested object.
+    #
+    # @param notification [_INotification] the <code>_INotification</code> to pass to the interested object's notification method
+    def notify_observer: (_INotification notification) -> void
+
+    # Compare the given object to the notification context object.
+    #
+    # @param object [Object] the object to compare.
+    # @return [Boolean] indicating if the notification context and the object are the same.
+    def compare_notify_context?: (Object object) -> bool
+  end
+
+  # Assert that the given `Observer` type parameter is a subtype of `_IObserver`
+  type validate_observer[Observer < _IObserver] = top
+end

data/sig/lib/interfaces/i_proxy.rbs

@@ -0,0 +1,36 @@
+module PureMVC
+  # The interface definition for a PureMVC Proxy.
+  #
+  # In PureMVC, <code>_IProxy</code> implementors assume these responsibilities:
+  # - Implement a common method which returns the name of the Proxy.
+  # - Provide methods for setting and getting the data object.
+  #
+  # Additionally, <code>_IProxy</code>s typically:
+  # - Maintain references to one or more pieces of model data.
+  # - Provide methods for manipulating that data.
+  # - Generate <code>_INotifications</code> when their model data changes.
+  # - Expose their name called <code>NAME</code>, if they are not instantiated multiple times.
+  # - Encapsulate interaction with local or remote services used to fetch and persist model data.
+  #
+  # @see INotifier
+  interface _IProxy
+
+    include _INotifier
+
+    # @return [String] The proxy name
+    def name: () -> String
+
+    # @return [Object | nil] The data managed by the proxy
+    def data: () -> Object?
+    def data=: (Object?) -> void
+
+    # Called by the Model when the Proxy is registered
+    def on_register: () -> void
+
+    # Called by the Model when the Proxy is removed
+    def on_remove: () -> void
+  end
+
+  # Assert that the given `Proxy` type parameter is a subtype of `_IProxy`
+  type validate_proxy[Proxy < _IProxy] = top
+end