wamp_client 0.0.9 → 0.1.0

data/lib/{wamp_client → wamp/client}/defer.rb

@@ -1,6 +1,6 @@
 =begin
 
-Copyright (c) 2016 Eric Chapman
+Copyright (c) 2018 Eric Chapman
 
 MIT License
 
@@ -25,44 +25,46 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 =end
 
-module WampClient
-  module Defer
+module Wamp
+  module Client
+    module Defer
 
-    class CallDefer
-      attr_accessor :request, :registration
+      class CallDefer
+        attr_accessor :request, :registration
 
-      @on_complete
-      def on_complete(&on_complete)
-        @on_complete = on_complete
-      end
+        @on_complete
+        def on_complete(&on_complete)
+          @on_complete = on_complete
+        end
 
-      @on_error
-      def on_error(&on_error)
-        @on_error = on_error
-      end
+        @on_error
+        def on_error(&on_error)
+          @on_error = on_error
+        end
 
-      def succeed(result)
-        @on_complete.call(self, result) if @on_complete
-      end
+        def succeed(result)
+          @on_complete.call(self, result) if @on_complete
+        end
+
+        def fail(error)
+          @on_error.call(self, error) if @on_error
+        end
 
-      def fail(error)
-        @on_error.call(self, error) if @on_error
       end
 
-    end
+      class ProgressiveCallDefer < CallDefer
 
-    class ProgressiveCallDefer < CallDefer
+        @on_progress
+        def on_progress(&on_progress)
+          @on_progress = on_progress
+        end
 
-      @on_progress
-      def on_progress(&on_progress)
-        @on_progress = on_progress
-      end
+        def progress(result)
+          @on_progress.call(self, result) if @on_progress
+        end
 
-      def progress(result)
-        @on_progress.call(self, result) if @on_progress
       end
 
     end
-
   end
 end

data/lib/wamp/client/message.rb

@@ -0,0 +1,1322 @@
+require 'wamp/client/check'
+
+# !!!!THIS FILE IS AUTOGENERATED.  DO NOT HAND EDIT!!!!
+
+module Wamp
+  module Client
+    module Message
+
+      module Types
+        HELLO = 1
+        WELCOME = 2
+        ABORT = 3
+        CHALLENGE = 4
+        AUTHENTICATE = 5
+        GOODBYE = 6
+        ERROR = 8
+        PUBLISH = 16
+        PUBLISHED = 17
+        SUBSCRIBE = 32
+        SUBSCRIBED = 33
+        UNSUBSCRIBE = 34
+        UNSUBSCRIBED = 35
+        EVENT = 36
+        CALL = 48
+        CANCEL = 49
+        RESULT = 50
+        REGISTER = 64
+        REGISTERED = 65
+        UNREGISTER = 66
+        UNREGISTERED = 67
+        INVOCATION = 68
+        INTERRUPT = 69
+        YIELD = 70
+      end
+
+      class Base
+        include Wamp::Client::Check
+
+        def payload
+          []
+        end
+
+        # @param params [Array]
+        def self.parse(params)
+          object = nil
+          if params[0] == Types::HELLO
+            object = Wamp::Client::Message::Hello.parse(params)
+          elsif params[0] == Types::WELCOME
+            object = Wamp::Client::Message::Welcome.parse(params)
+          elsif params[0] == Types::ABORT
+            object = Wamp::Client::Message::Abort.parse(params)
+          elsif params[0] == Types::CHALLENGE
+            object = Wamp::Client::Message::Challenge.parse(params)
+          elsif params[0] == Types::AUTHENTICATE
+            object = Wamp::Client::Message::Authenticate.parse(params)
+          elsif params[0] == Types::GOODBYE
+            object = Wamp::Client::Message::Goodbye.parse(params)
+          elsif params[0] == Types::ERROR
+            object = Wamp::Client::Message::Error.parse(params)
+          elsif params[0] == Types::PUBLISH
+            object = Wamp::Client::Message::Publish.parse(params)
+          elsif params[0] == Types::PUBLISHED
+            object = Wamp::Client::Message::Published.parse(params)
+          elsif params[0] == Types::SUBSCRIBE
+            object = Wamp::Client::Message::Subscribe.parse(params)
+          elsif params[0] == Types::SUBSCRIBED
+            object = Wamp::Client::Message::Subscribed.parse(params)
+          elsif params[0] == Types::UNSUBSCRIBE
+            object = Wamp::Client::Message::Unsubscribe.parse(params)
+          elsif params[0] == Types::UNSUBSCRIBED
+            object = Wamp::Client::Message::Unsubscribed.parse(params)
+          elsif params[0] == Types::EVENT
+            object = Wamp::Client::Message::Event.parse(params)
+          elsif params[0] == Types::CALL
+            object = Wamp::Client::Message::Call.parse(params)
+          elsif params[0] == Types::CANCEL
+            object = Wamp::Client::Message::Cancel.parse(params)
+          elsif params[0] == Types::RESULT
+            object = Wamp::Client::Message::Result.parse(params)
+          elsif params[0] == Types::REGISTER
+            object = Wamp::Client::Message::Register.parse(params)
+          elsif params[0] == Types::REGISTERED
+            object = Wamp::Client::Message::Registered.parse(params)
+          elsif params[0] == Types::UNREGISTER
+            object = Wamp::Client::Message::Unregister.parse(params)
+          elsif params[0] == Types::UNREGISTERED
+            object = Wamp::Client::Message::Unregistered.parse(params)
+          elsif params[0] == Types::INVOCATION
+            object = Wamp::Client::Message::Invocation.parse(params)
+          elsif params[0] == Types::INTERRUPT
+            object = Wamp::Client::Message::Interrupt.parse(params)
+          elsif params[0] == Types::YIELD
+            object = Wamp::Client::Message::Yield.parse(params)
+          end
+
+          object
+        end
+      end
+
+      # Hello
+      # Sent by a Client to initiate opening of a WAMP session to a Router attaching to a Realm.
+      # Formats:
+      #   [HELLO, Realm|uri, Details|dict]
+      class Hello < Base
+        attr_accessor :realm, :details
+
+        def initialize(realm, details)
+
+          self.class.check_uri('realm', realm)
+          self.class.check_dict('details', details)
+
+          self.realm = realm
+          self.details = details
+
+        end
+
+        def self.type
+          Types::HELLO
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.realm)
+          payload.push(self.details)
+
+          payload
+        end
+
+        def to_s
+          'HELLO > ' + self.payload.to_s
+        end
+
+      end
+
+      # Welcome
+      # Sent by a Router to accept a Client.  The WAMP session is now open.
+      # Formats:
+      #   [WELCOME, Session|id, Details|dict]
+      class Welcome < Base
+        attr_accessor :session, :details
+
+        def initialize(session, details)
+
+          self.class.check_id('session', session)
+          self.class.check_dict('details', details)
+
+          self.session = session
+          self.details = details
+
+        end
+
+        def self.type
+          Types::WELCOME
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.session)
+          payload.push(self.details)
+
+          payload
+        end
+
+        def to_s
+          'WELCOME > ' + self.payload.to_s
+        end
+
+      end
+
+      # Abort
+      # Sent by a Peer*to abort the opening of a WAMP session.  No response is expected.
+      # Formats:
+      #   [ABORT, Details|dict, Reason|uri]
+      class Abort < Base
+        attr_accessor :details, :reason
+
+        def initialize(details, reason)
+
+          self.class.check_dict('details', details)
+          self.class.check_uri('reason', reason)
+
+          self.details = details
+          self.reason = reason
+
+        end
+
+        def self.type
+          Types::ABORT
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.details)
+          payload.push(self.reason)
+
+          payload
+        end
+
+        def to_s
+          'ABORT > ' + self.payload.to_s
+        end
+
+      end
+
+      # Goodbye
+      # Sent by a Peer to close a previously opened WAMP session.  Must be echo'ed by the receiving Peer.
+      # Formats:
+      #   [GOODBYE, Details|dict, Reason|uri]
+      class Goodbye < Base
+        attr_accessor :details, :reason
+
+        def initialize(details, reason)
+
+          self.class.check_dict('details', details)
+          self.class.check_uri('reason', reason)
+
+          self.details = details
+          self.reason = reason
+
+        end
+
+        def self.type
+          Types::GOODBYE
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.details)
+          payload.push(self.reason)
+
+          payload
+        end
+
+        def to_s
+          'GOODBYE > ' + self.payload.to_s
+        end
+
+      end
+
+      # Error
+      # Error reply sent by a Peer as an error response to different kinds of requests.
+      # Formats:
+      #   [ERROR, REQUEST.Type|int, REQUEST.Request|id, Details|dict, Error|uri]
+      #   [ERROR, REQUEST.Type|int, REQUEST.Request|id, Details|dict, Error|uri, Arguments|list]
+      #   [ERROR, REQUEST.Type|int, REQUEST.Request|id, Details|dict, Error|uri, Arguments|list, ArgumentsKw|dict]
+      class Error < Base
+        attr_accessor :request_type, :request_request, :details, :error, :arguments, :argumentskw
+
+        def initialize(request_type, request_request, details, error, arguments=nil, argumentskw=nil)
+
+          self.class.check_int('request_type', request_type)
+          self.class.check_id('request_request', request_request)
+          self.class.check_dict('details', details)
+          self.class.check_uri('error', error)
+          self.class.check_list('arguments', arguments, true)
+          self.class.check_dict('argumentskw', argumentskw, true)
+
+          self.request_type = request_type
+          self.request_request = request_request
+          self.details = details
+          self.error = error
+          self.arguments = arguments
+          self.argumentskw = argumentskw
+
+        end
+
+        def self.type
+          Types::ERROR
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 5, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+          self.arguments ||= []
+          self.argumentskw ||= {}
+
+          payload = [self.class.type]
+          payload.push(self.request_type)
+          payload.push(self.request_request)
+          payload.push(self.details)
+          payload.push(self.error)
+
+          return payload if (self.arguments.empty? and self.argumentskw.empty?)
+          payload.push(self.arguments)
+
+          return payload if (self.argumentskw.empty?)
+          payload.push(self.argumentskw)
+
+          payload
+        end
+
+        def to_s
+          'ERROR > ' + self.payload.to_s
+        end
+
+      end
+
+      # Publish
+      # Sent by a Publisher to a Broker to publish an event.
+      # Formats:
+      #   [PUBLISH, Request|id, Options|dict, Topic|uri]
+      #   [PUBLISH, Request|id, Options|dict, Topic|uri, Arguments|list]
+      #   [PUBLISH, Request|id, Options|dict, Topic|uri, Arguments|list, ArgumentsKw|dict]
+      class Publish < Base
+        attr_accessor :request, :options, :topic, :arguments, :argumentskw
+
+        def initialize(request, options, topic, arguments=nil, argumentskw=nil)
+
+          self.class.check_id('request', request)
+          self.class.check_dict('options', options)
+          self.class.check_uri('topic', topic)
+          self.class.check_list('arguments', arguments, true)
+          self.class.check_dict('argumentskw', argumentskw, true)
+
+          self.request = request
+          self.options = options
+          self.topic = topic
+          self.arguments = arguments
+          self.argumentskw = argumentskw
+
+        end
+
+        def self.type
+          Types::PUBLISH
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 4, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+          self.arguments ||= []
+          self.argumentskw ||= {}
+
+          payload = [self.class.type]
+          payload.push(self.request)
+          payload.push(self.options)
+          payload.push(self.topic)
+
+          return payload if (self.arguments.empty? and self.argumentskw.empty?)
+          payload.push(self.arguments)
+
+          return payload if (self.argumentskw.empty?)
+          payload.push(self.argumentskw)
+
+          payload
+        end
+
+        def to_s
+          'PUBLISH > ' + self.payload.to_s
+        end
+
+      end
+
+      # Published
+      # Acknowledge sent by a Broker to a Publisher for acknowledged publications.
+      # Formats:
+      #   [PUBLISHED, PUBLISH.Request|id, Publication|id]
+      class Published < Base
+        attr_accessor :publish_request, :publication
+
+        def initialize(publish_request, publication)
+
+          self.class.check_id('publish_request', publish_request)
+          self.class.check_id('publication', publication)
+
+          self.publish_request = publish_request
+          self.publication = publication
+
+        end
+
+        def self.type
+          Types::PUBLISHED
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.publish_request)
+          payload.push(self.publication)
+
+          payload
+        end
+
+        def to_s
+          'PUBLISHED > ' + self.payload.to_s
+        end
+
+      end
+
+      # Subscribe
+      # Subscribe request sent by a Subscriber to a Broker to subscribe to a topic.
+      # Formats:
+      #   [SUBSCRIBE, Request|id, Options|dict, Topic|uri]
+      class Subscribe < Base
+        attr_accessor :request, :options, :topic
+
+        def initialize(request, options, topic)
+
+          self.class.check_id('request', request)
+          self.class.check_dict('options', options)
+          self.class.check_uri('topic', topic)
+
+          self.request = request
+          self.options = options
+          self.topic = topic
+
+        end
+
+        def self.type
+          Types::SUBSCRIBE
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 4, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.request)
+          payload.push(self.options)
+          payload.push(self.topic)
+
+          payload
+        end
+
+        def to_s
+          'SUBSCRIBE > ' + self.payload.to_s
+        end
+
+      end
+
+      # Subscribed
+      # Acknowledge sent by a Broker to a Subscriber to acknowledge a subscription.
+      # Formats:
+      #   [SUBSCRIBED, SUBSCRIBE.Request|id, Subscription|id]
+      class Subscribed < Base
+        attr_accessor :subscribe_request, :subscription
+
+        def initialize(subscribe_request, subscription)
+
+          self.class.check_id('subscribe_request', subscribe_request)
+          self.class.check_id('subscription', subscription)
+
+          self.subscribe_request = subscribe_request
+          self.subscription = subscription
+
+        end
+
+        def self.type
+          Types::SUBSCRIBED
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.subscribe_request)
+          payload.push(self.subscription)
+
+          payload
+        end
+
+        def to_s
+          'SUBSCRIBED > ' + self.payload.to_s
+        end
+
+      end
+
+      # Unsubscribe
+      # Unsubscribe request sent by a Subscriber to a Broker to unsubscribe a subscription.
+      # Formats:
+      #   [UNSUBSCRIBE, Request|id, SUBSCRIBED.Subscription|id]
+      class Unsubscribe < Base
+        attr_accessor :request, :subscribed_subscription
+
+        def initialize(request, subscribed_subscription)
+
+          self.class.check_id('request', request)
+          self.class.check_id('subscribed_subscription', subscribed_subscription)
+
+          self.request = request
+          self.subscribed_subscription = subscribed_subscription
+
+        end
+
+        def self.type
+          Types::UNSUBSCRIBE
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.request)
+          payload.push(self.subscribed_subscription)
+
+          payload
+        end
+
+        def to_s
+          'UNSUBSCRIBE > ' + self.payload.to_s
+        end
+
+      end
+
+      # Unsubscribed
+      # Acknowledge sent by a Broker to a Subscriber to acknowledge unsubscription.
+      # Formats:
+      #   [UNSUBSCRIBED, UNSUBSCRIBE.Request|id]
+      class Unsubscribed < Base
+        attr_accessor :unsubscribe_request
+
+        def initialize(unsubscribe_request)
+
+          self.class.check_id('unsubscribe_request', unsubscribe_request)
+
+          self.unsubscribe_request = unsubscribe_request
+
+        end
+
+        def self.type
+          Types::UNSUBSCRIBED
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 2, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.unsubscribe_request)
+
+          payload
+        end
+
+        def to_s
+          'UNSUBSCRIBED > ' + self.payload.to_s
+        end
+
+      end
+
+      # Event
+      # Event dispatched by Broker to Subscribers for subscriptions the event was matching.
+      # Formats:
+      #   [EVENT, SUBSCRIBED.Subscription|id, PUBLISHED.Publication|id, Details|dict]
+      #   [EVENT, SUBSCRIBED.Subscription|id, PUBLISHED.Publication|id, Details|dict, PUBLISH.Arguments|list]
+      #   [EVENT, SUBSCRIBED.Subscription|id, PUBLISHED.Publication|id, Details|dict, PUBLISH.Arguments|list, PUBLISH.ArgumentsKw|dict]
+      class Event < Base
+        attr_accessor :subscribed_subscription, :published_publication, :details, :publish_arguments, :publish_argumentskw
+
+        def initialize(subscribed_subscription, published_publication, details, publish_arguments=nil, publish_argumentskw=nil)
+
+          self.class.check_id('subscribed_subscription', subscribed_subscription)
+          self.class.check_id('published_publication', published_publication)
+          self.class.check_dict('details', details)
+          self.class.check_list('publish_arguments', publish_arguments, true)
+          self.class.check_dict('publish_argumentskw', publish_argumentskw, true)
+
+          self.subscribed_subscription = subscribed_subscription
+          self.published_publication = published_publication
+          self.details = details
+          self.publish_arguments = publish_arguments
+          self.publish_argumentskw = publish_argumentskw
+
+        end
+
+        def self.type
+          Types::EVENT
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 4, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+          self.publish_arguments ||= []
+          self.publish_argumentskw ||= {}
+
+          payload = [self.class.type]
+          payload.push(self.subscribed_subscription)
+          payload.push(self.published_publication)
+          payload.push(self.details)
+
+          return payload if (self.publish_arguments.empty? and self.publish_argumentskw.empty?)
+          payload.push(self.publish_arguments)
+
+          return payload if (self.publish_argumentskw.empty?)
+          payload.push(self.publish_argumentskw)
+
+          payload
+        end
+
+        def to_s
+          'EVENT > ' + self.payload.to_s
+        end
+
+      end
+
+      # Call
+      # Call as originally issued by the _Caller_ to the _Dealer_.
+      # Formats:
+      #   [CALL, Request|id, Options|dict, Procedure|uri]
+      #   [CALL, Request|id, Options|dict, Procedure|uri, Arguments|list]
+      #   [CALL, Request|id, Options|dict, Procedure|uri, Arguments|list, ArgumentsKw|dict]
+      class Call < Base
+        attr_accessor :request, :options, :procedure, :arguments, :argumentskw
+
+        def initialize(request, options, procedure, arguments=nil, argumentskw=nil)
+
+          self.class.check_id('request', request)
+          self.class.check_dict('options', options)
+          self.class.check_uri('procedure', procedure)
+          self.class.check_list('arguments', arguments, true)
+          self.class.check_dict('argumentskw', argumentskw, true)
+
+          self.request = request
+          self.options = options
+          self.procedure = procedure
+          self.arguments = arguments
+          self.argumentskw = argumentskw
+
+        end
+
+        def self.type
+          Types::CALL
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 4, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+          self.arguments ||= []
+          self.argumentskw ||= {}
+
+          payload = [self.class.type]
+          payload.push(self.request)
+          payload.push(self.options)
+          payload.push(self.procedure)
+
+          return payload if (self.arguments.empty? and self.argumentskw.empty?)
+          payload.push(self.arguments)
+
+          return payload if (self.argumentskw.empty?)
+          payload.push(self.argumentskw)
+
+          payload
+        end
+
+        def to_s
+          'CALL > ' + self.payload.to_s
+        end
+
+      end
+
+      # Result
+      # Result of a call as returned by _Dealer_ to _Caller_.
+      # Formats:
+      #   [RESULT, CALL.Request|id, Details|dict]
+      #   [RESULT, CALL.Request|id, Details|dict, YIELD.Arguments|list]
+      #   [RESULT, CALL.Request|id, Details|dict, YIELD.Arguments|list, YIELD.ArgumentsKw|dict]
+      class Result < Base
+        attr_accessor :call_request, :details, :yield_arguments, :yield_argumentskw
+
+        def initialize(call_request, details, yield_arguments=nil, yield_argumentskw=nil)
+
+          self.class.check_id('call_request', call_request)
+          self.class.check_dict('details', details)
+          self.class.check_list('yield_arguments', yield_arguments, true)
+          self.class.check_dict('yield_argumentskw', yield_argumentskw, true)
+
+          self.call_request = call_request
+          self.details = details
+          self.yield_arguments = yield_arguments
+          self.yield_argumentskw = yield_argumentskw
+
+        end
+
+        def self.type
+          Types::RESULT
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+          self.yield_arguments ||= []
+          self.yield_argumentskw ||= {}
+
+          payload = [self.class.type]
+          payload.push(self.call_request)
+          payload.push(self.details)
+
+          return payload if (self.yield_arguments.empty? and self.yield_argumentskw.empty?)
+          payload.push(self.yield_arguments)
+
+          return payload if (self.yield_argumentskw.empty?)
+          payload.push(self.yield_argumentskw)
+
+          payload
+        end
+
+        def to_s
+          'RESULT > ' + self.payload.to_s
+        end
+
+      end
+
+      # Register
+      # A _Callees_ request to register an endpoint at a _Dealer_.
+      # Formats:
+      #   [REGISTER, Request|id, Options|dict, Procedure|uri]
+      class Register < Base
+        attr_accessor :request, :options, :procedure
+
+        def initialize(request, options, procedure)
+
+          self.class.check_id('request', request)
+          self.class.check_dict('options', options)
+          self.class.check_uri('procedure', procedure)
+
+          self.request = request
+          self.options = options
+          self.procedure = procedure
+
+        end
+
+        def self.type
+          Types::REGISTER
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 4, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.request)
+          payload.push(self.options)
+          payload.push(self.procedure)
+
+          payload
+        end
+
+        def to_s
+          'REGISTER > ' + self.payload.to_s
+        end
+
+      end
+
+      # Registered
+      # Acknowledge sent by a _Dealer_ to a _Callee_ for successful registration.
+      # Formats:
+      #   [REGISTERED, REGISTER.Request|id, Registration|id]
+      class Registered < Base
+        attr_accessor :register_request, :registration
+
+        def initialize(register_request, registration)
+
+          self.class.check_id('register_request', register_request)
+          self.class.check_id('registration', registration)
+
+          self.register_request = register_request
+          self.registration = registration
+
+        end
+
+        def self.type
+          Types::REGISTERED
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.register_request)
+          payload.push(self.registration)
+
+          payload
+        end
+
+        def to_s
+          'REGISTERED > ' + self.payload.to_s
+        end
+
+      end
+
+      # Unregister
+      # A _Callees_ request to unregister a previously established registration.
+      # Formats:
+      #   [UNREGISTER, Request|id, REGISTERED.Registration|id]
+      class Unregister < Base
+        attr_accessor :request, :registered_registration
+
+        def initialize(request, registered_registration)
+
+          self.class.check_id('request', request)
+          self.class.check_id('registered_registration', registered_registration)
+
+          self.request = request
+          self.registered_registration = registered_registration
+
+        end
+
+        def self.type
+          Types::UNREGISTER
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.request)
+          payload.push(self.registered_registration)
+
+          payload
+        end
+
+        def to_s
+          'UNREGISTER > ' + self.payload.to_s
+        end
+
+      end
+
+      # Unregistered
+      # Acknowledge sent by a _Dealer_ to a _Callee_ for successful unregistration.
+      # Formats:
+      #   [UNREGISTERED, UNREGISTER.Request|id]
+      class Unregistered < Base
+        attr_accessor :unregister_request
+
+        def initialize(unregister_request)
+
+          self.class.check_id('unregister_request', unregister_request)
+
+          self.unregister_request = unregister_request
+
+        end
+
+        def self.type
+          Types::UNREGISTERED
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 2, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.unregister_request)
+
+          payload
+        end
+
+        def to_s
+          'UNREGISTERED > ' + self.payload.to_s
+        end
+
+      end
+
+      # Invocation
+      # Actual invocation of an endpoint sent by _Dealer_ to a _Callee_.
+      # Formats:
+      #   [INVOCATION, Request|id, REGISTERED.Registration|id, Details|dict]
+      #   [INVOCATION, Request|id, REGISTERED.Registration|id, Details|dict, CALL.Arguments|list]
+      #   [INVOCATION, Request|id, REGISTERED.Registration|id, Details|dict, CALL.Arguments|list, CALL.ArgumentsKw|dict]
+      class Invocation < Base
+        attr_accessor :request, :registered_registration, :details, :call_arguments, :call_argumentskw
+
+        def initialize(request, registered_registration, details, call_arguments=nil, call_argumentskw=nil)
+
+          self.class.check_id('request', request)
+          self.class.check_id('registered_registration', registered_registration)
+          self.class.check_dict('details', details)
+          self.class.check_list('call_arguments', call_arguments, true)
+          self.class.check_dict('call_argumentskw', call_argumentskw, true)
+
+          self.request = request
+          self.registered_registration = registered_registration
+          self.details = details
+          self.call_arguments = call_arguments
+          self.call_argumentskw = call_argumentskw
+
+        end
+
+        def self.type
+          Types::INVOCATION
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 4, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+          self.call_arguments ||= []
+          self.call_argumentskw ||= {}
+
+          payload = [self.class.type]
+          payload.push(self.request)
+          payload.push(self.registered_registration)
+          payload.push(self.details)
+
+          return payload if (self.call_arguments.empty? and self.call_argumentskw.empty?)
+          payload.push(self.call_arguments)
+
+          return payload if (self.call_argumentskw.empty?)
+          payload.push(self.call_argumentskw)
+
+          payload
+        end
+
+        def to_s
+          'INVOCATION > ' + self.payload.to_s
+        end
+
+      end
+
+      # Yield
+      # Actual yield from an endpoint sent by a _Callee_ to _Dealer_.
+      # Formats:
+      #   [YIELD, INVOCATION.Request|id, Options|dict]
+      #   [YIELD, INVOCATION.Request|id, Options|dict, Arguments|list]
+      #   [YIELD, INVOCATION.Request|id, Options|dict, Arguments|list, ArgumentsKw|dict]
+      class Yield < Base
+        attr_accessor :invocation_request, :options, :arguments, :argumentskw
+
+        def initialize(invocation_request, options, arguments=nil, argumentskw=nil)
+
+          self.class.check_id('invocation_request', invocation_request)
+          self.class.check_dict('options', options)
+          self.class.check_list('arguments', arguments, true)
+          self.class.check_dict('argumentskw', argumentskw, true)
+
+          self.invocation_request = invocation_request
+          self.options = options
+          self.arguments = arguments
+          self.argumentskw = argumentskw
+
+        end
+
+        def self.type
+          Types::YIELD
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+          self.arguments ||= []
+          self.argumentskw ||= {}
+
+          payload = [self.class.type]
+          payload.push(self.invocation_request)
+          payload.push(self.options)
+
+          return payload if (self.arguments.empty? and self.argumentskw.empty?)
+          payload.push(self.arguments)
+
+          return payload if (self.argumentskw.empty?)
+          payload.push(self.argumentskw)
+
+          payload
+        end
+
+        def to_s
+          'YIELD > ' + self.payload.to_s
+        end
+
+      end
+
+      # Challenge
+      # The "CHALLENGE" message is used with certain Authentication Methods. During authenticated session establishment, a *Router* sends a challenge message.
+      # Formats:
+      #   [CHALLENGE, AuthMethod|string, Extra|dict]
+      class Challenge < Base
+        attr_accessor :authmethod, :extra
+
+        def initialize(authmethod, extra)
+
+          self.class.check_string('authmethod', authmethod)
+          self.class.check_dict('extra', extra)
+
+          self.authmethod = authmethod
+          self.extra = extra
+
+        end
+
+        def self.type
+          Types::CHALLENGE
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.authmethod)
+          payload.push(self.extra)
+
+          payload
+        end
+
+        def to_s
+          'CHALLENGE > ' + self.payload.to_s
+        end
+
+      end
+
+      # Authenticate
+      # The "AUTHENTICATE" message is used with certain Authentication Methods.  A *Client* having received a challenge is expected to respond by sending a signature or token.
+      # Formats:
+      #   [AUTHENTICATE, Signature|string, Extra|dict]
+      class Authenticate < Base
+        attr_accessor :signature, :extra
+
+        def initialize(signature, extra)
+
+          self.class.check_string('signature', signature)
+          self.class.check_dict('extra', extra)
+
+          self.signature = signature
+          self.extra = extra
+
+        end
+
+        def self.type
+          Types::AUTHENTICATE
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.signature)
+          payload.push(self.extra)
+
+          payload
+        end
+
+        def to_s
+          'AUTHENTICATE > ' + self.payload.to_s
+        end
+
+      end
+
+      # Cancel
+      # The "CANCEL" message is used with the Call Canceling advanced feature.  A _Caller_ can cancel and issued call actively by sending a cancel message to the _Dealer_.
+      # Formats:
+      #   [CANCEL, CALL.Request|id, Options|dict]
+      class Cancel < Base
+        attr_accessor :call_request, :options
+
+        def initialize(call_request, options)
+
+          self.class.check_id('call_request', call_request)
+          self.class.check_dict('options', options)
+
+          self.call_request = call_request
+          self.options = options
+
+        end
+
+        def self.type
+          Types::CANCEL
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.call_request)
+          payload.push(self.options)
+
+          payload
+        end
+
+        def to_s
+          'CANCEL > ' + self.payload.to_s
+        end
+
+      end
+
+      # Interrupt
+      # The "INTERRUPT" message is used with the Call Canceling advanced feature.  Upon receiving a cancel for a pending call, a _Dealer_ will issue an interrupt to the _Callee_.
+      # Formats:
+      #   [INTERRUPT, INVOCATION.Request|id, Options|dict]
+      class Interrupt < Base
+        attr_accessor :invocation_request, :options
+
+        def initialize(invocation_request, options)
+
+          self.class.check_id('invocation_request', invocation_request)
+          self.class.check_dict('options', options)
+
+          self.invocation_request = invocation_request
+          self.options = options
+
+        end
+
+        def self.type
+          Types::INTERRUPT
+        end
+
+        def self.parse(params)
+
+          self.check_gte('params list', 3, params.count)
+          self.check_equal('message type', self.type, params[0])
+
+          params.shift
+          self.new(*params)
+
+        end
+
+        def payload
+
+          payload = [self.class.type]
+          payload.push(self.invocation_request)
+          payload.push(self.options)
+
+          payload
+        end
+
+        def to_s
+          'INTERRUPT > ' + self.payload.to_s
+        end
+
+      end
+
+    end
+  end
+end