nl 0.3.0 → 0.4.1

data/sig/generated/nl/exchange.rbs

@@ -0,0 +1,75 @@
+# Generated from lib/nl/exchange.rb with RBS::Inline
+
+module Nl
+  # State machine for one Netlink request/reply exchange.
+  #
+  # Dump exchanges are known to be multipart from the request and remain open
+  # through NLMSG_DONE. Some Linux Generic Netlink dump handlers construct
+  # replies with genlmsg_iput(), which leaves NLM_F_MULTI unset despite that
+  # multipart lifetime. Dump mode therefore accepts data with or without the
+  # flag; reply mode still uses it to detect a multipart do response.
+  #
+  # Some operations also return multipart data for a do request, although YNL
+  # cannot declare such a reply. Reply mode handles this kernel behavior by
+  # retaining the first data message, draining the remainder, and completing
+  # on NLMSG_DONE instead of ACK.
+  class Exchange
+    class Item < Data
+      attr_reader value(): untyped
+
+      def self.new: (untyped value) -> instance
+                  | (value: untyped) -> instance
+
+      def self.members: () -> [ :value ]
+
+      def members: () -> [ :value ]
+    end
+
+    class Complete < Data
+      def self.new: () -> instance
+                  | () -> instance
+
+      def self.members: () -> [ ]
+
+      def members: () -> [ ]
+    end
+
+    COMPLETE: untyped
+
+    class Failure < Data
+      attr_reader exception(): untyped
+
+      def self.new: (untyped exception) -> instance
+                  | (exception: untyped) -> instance
+
+      def self.members: () -> [ :exception ]
+
+      def members: () -> [ :exception ]
+    end
+
+    MODES: untyped
+
+    attr_reader mode: untyped
+
+    # @rbs (mode: :dump | :no_reply | :reply) -> void
+    def initialize: (mode: :dump | :no_reply | :reply) -> void
+
+    def accept: (untyped frame) -> untyped
+
+    def cancel: () -> untyped
+
+    def cancelled?: () -> untyped
+
+    def complete?: () -> untyped
+
+    def result: () -> untyped
+
+    private def accept_ack: () -> untyped
+
+    private def accept_reply: (untyped frame) -> untyped
+
+    private def complete: (untyped value) -> untyped
+
+    private def fail_with: (untyped exception) -> untyped
+  end
+end

data/sig/generated/nl/family.rbs

@@ -0,0 +1,71 @@
+# Generated from lib/nl/family.rb with RBS::Inline
+
+module Nl
+  type executor = :thread | :fiber
+
+  interface _Connection
+    def exchange: (Raw::Endpoint endpoint, Symbol kind, Class request_class, Class reply_class, Hash[Symbol, untyped] args) ?{ (untyped) -> void } -> untyped
+
+    def exchange_async: (Raw::Endpoint endpoint, Symbol kind, Class request_class, Class reply_class, Hash[Symbol, untyped] args, ?stream_capacity: Integer?) -> (Async::Future[untyped] | Async::Stream[untyped])
+
+    def async_capable?: () -> bool
+
+    def register_notifications: (Raw::Endpoint, Hash[Integer, Class]) -> NotificationChannel
+
+    def add_memberships: (Array[Integer]) -> nil
+
+    def drop_memberships: (Array[Integer]) -> nil
+
+    def receive_notification: (Raw::Endpoint, ?timeout: Numeric?) -> untyped
+
+    def close: () -> nil
+  end
+
+  interface _FamilyClass[out F]
+    def new: (_Connection, endpoint: Raw::Endpoint) -> F
+  end
+
+  class Family
+    DEFAULT_NOTIFICATION_CAPACITY: untyped
+
+    module Session
+      def close: () -> nil
+    end
+
+    # --
+    #  @rbs connection: _Connection
+    #  @rbs endpoint: Raw::Endpoint
+    #  @rbs return: instance
+    def initialize: (_Connection connection, endpoint: Raw::Endpoint) -> instance
+
+    private def exchange_message: (untyped kind, untyped request_class, untyped reply_class, untyped args) ?{ (?) -> untyped } -> untyped
+
+    def async_capable?: () -> bool
+
+    # Adds multicast memberships to the existing family socket. Membership is
+    # additive and remains active until explicitly removed or the owner closes.
+    def subscribe: (*untyped groups) -> untyped
+
+    def unsubscribe: (*untyped groups) -> untyped
+
+    def receive_notification: (?timeout: untyped) -> untyped
+
+    def each_notification: () ?{ (?) -> untyped } -> untyped
+
+    # Builds a generated asynchronous-operation facade with a narrowly scoped
+    # callback, so the facade does not need access to Family's private API.
+    # --
+    # @rbs operations_class: Class
+    # @rbs stream_capacity: Integer?
+    # @rbs return: untyped
+    private def build_async_facade: (Class operations_class, ?stream_capacity: Integer?) -> untyped
+
+    private def exchange_message_async: (untyped kind, untyped request_class, untyped reply_class, untyped args, ?stream_capacity: untyped) -> untyped
+
+    private def notification_classes: () -> untyped
+
+    private def multicast_groups: () -> untyped
+
+    private def multicast_group_ids: (untyped names) -> untyped
+  end
+end

data/sig/generated/nl/genl/client.rbs

@@ -0,0 +1,74 @@
+# Generated from lib/nl/genl/client.rb with RBS::Inline
+
+module Nl
+  module Genl
+    # Dynamically resolved information for a generic Netlink family.
+    #
+    # @!attribute [r] id
+    #   @return [Integer] the assigned family ID
+    # @!attribute [r] multicast_groups
+    #   @return [Hash<String, Integer>] multicast group names mapped to their IDs
+    class FamilyInfo < Data
+      attr_reader id(): Integer
+
+      attr_reader multicast_groups(): Hash[String, Integer]
+
+      def self.new: (Integer id, Hash[String, Integer] multicast_groups) -> instance
+                  | (id: Integer, multicast_groups: Hash[String, Integer]) -> instance
+
+      def self.members: () -> [ :id, :multicast_groups ]
+
+      def members: () -> [ :id, :multicast_groups ]
+    end
+
+    # Owns one generic Netlink connection shared by compatible families.
+    class Client
+      # Opens a generic Netlink client.
+      #
+      # @overload open(resolver:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY)
+      #   The caller is responsible for closing the client.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @return [Client] the opened client
+      # @overload open(resolver:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY, &block)
+      #   The client is automatically closed after the block returns.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @yieldparam [Client] client the opened client
+      #   @return [Object] the value returned from the block
+      # @rbs (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+      #    | [R] (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+      def self.open: (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+                   | [R] (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+
+      # @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      # @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      # @param [Integer] notification_capacity the maximum number of queued notifications
+      # @rbs (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> void
+      def initialize: (resolver: ^(instance, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> void
+
+      # Builds a family backed by this client's connection.
+      #
+      # @param [Class<Family>] family_class a generic Netlink family class
+      # @return [Family] an instance of `family_class`
+      # @raise [TypeError] if +family_class+ does not inherit from {Family}
+      # @rbs [F < Family] (_FamilyClass[F] family_class) -> F
+      def family: [F < Family] (_FamilyClass[F] family_class) -> F
+
+      # Closes the underlying Netlink connection.
+      #
+      # @return [void]
+      # @rbs () -> void
+      def close: () -> void
+
+      # Resolves and caches information for a family by name.
+      #
+      # @param [String] name the generic Netlink family name
+      # @return [FamilyInfo] the resolved family information
+      # @rbs (String name) -> FamilyInfo
+      private def family_info: (String name) -> FamilyInfo
+    end
+  end
+end

data/sig/generated/nl/genl/protocol.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/nl/genl/protocol.rb with RBS::Inline
+
+module Nl
+  module Genl
+    # A generated Generic Netlink family bound to nlctrl-provided information.
+    class Endpoint < Raw::Endpoint
+      attr_reader info: untyped
+
+      def initialize: (untyped definition, untyped info) -> untyped
+
+      def family_id: () -> untyped
+
+      def version: () -> untyped
+
+      def frame_type: (untyped _message_class) -> untyped
+
+      def multicast_group_id: (untyped name, untyped _value) -> untyped
+    end
+
+    # Socket-wide Generic Netlink wire behavior.
+    class Protocol < Raw::Protocol
+      def initialize: () -> untyped
+
+      def encode_message: (untyped encoder, untyped endpoint, untyped request, seq: untyped, pid: untyped) -> untyped
+
+      def notification_channel_key: (untyped endpoint) -> untyped
+
+      def notification_route_keys: (untyped endpoint, untyped _classes) -> untyped
+
+      def notification_frame_key: (untyped header) -> untyped
+
+      def notification_frame?: (untyped endpoint, untyped header, untyped _payload) -> untyped
+
+      def notification_class: (untyped endpoint, untyped header, untyped payload, untyped classes) -> untyped
+    end
+  end
+end

data/sig/generated/nl/genl/wire.rbs

@@ -0,0 +1,113 @@
+# Generated from lib/nl/genl/wire.rb with RBS::Inline
+
+module Nl
+  module Genl
+    # Constants from <linux/genetlink.h>
+    module Constants
+      GENL_NAMSIZ: ::Integer
+
+      GENL_MIN_ID: untyped
+
+      GENL_MAX_ID: ::Integer
+
+      GENL_HDRLEN: ::Integer
+
+      GENL_ID_GENERATE: ::Integer
+
+      GENL_ID_CTRL: untyped
+
+      GENL_ID_VFS_DQUOT: untyped
+
+      GENL_ID_PMCRAID: untyped
+
+      CTRL_CMD_UNSPEC: ::Integer
+
+      CTRL_CMD_NEWFAMILY: ::Integer
+
+      CTRL_CMD_DELFAMILY: ::Integer
+
+      CTRL_CMD_GETFAMILY: ::Integer
+
+      CTRL_CMD_NEWOPS: ::Integer
+
+      CTRL_CMD_DELOPS: ::Integer
+
+      CTRL_CMD_GETOPS: ::Integer
+
+      CTRL_CMD_NEWMCAST_GRP: ::Integer
+
+      CTRL_CMD_DELMCAST_GRP: ::Integer
+
+      CTRL_CMD_GETMCAST_GRP: ::Integer
+
+      CTRL_ATTR_UNSPEC: ::Integer
+
+      CTRL_ATTR_FAMILY_ID: ::Integer
+
+      CTRL_ATTR_FAMILY_NAME: ::Integer
+
+      CTRL_ATTR_VERSION: ::Integer
+
+      CTRL_ATTR_HDRSIZE: ::Integer
+
+      CTRL_ATTR_MAXATTR: ::Integer
+
+      CTRL_ATTR_OPS: ::Integer
+
+      CTRL_ATTR_MCAST_GROUPS: ::Integer
+
+      CTRL_ATTR_OP_UNSPEC: ::Integer
+
+      CTRL_ATTR_OP_ID: ::Integer
+
+      CTRL_ATTR_OP_FLAGS: ::Integer
+
+      CTRL_ATTR_MCAST_GRP_UNSPEC: ::Integer
+
+      CTRL_ATTR_MCAST_GRP_NAME: ::Integer
+
+      CTRL_ATTR_MCAST_GRP_ID: ::Integer
+    end
+
+    include Constants
+
+    # Header prepended to a Generic Netlink payload after the Netlink header.
+    #
+    # This corresponds to Linux's +struct genlmsghdr+.
+    #
+    # @!attribute [rw] cmd
+    #   @return [Integer] family-specific command identifier
+    # @!attribute [rw] version
+    #   @return [Integer] family-specific protocol version
+    # @!attribute [rw] reserved
+    #   @return [Integer] reserved field, which must be zero
+    class GenlMsgHdr < Struct[Integer]
+      attr_accessor cmd(): Integer
+
+      attr_accessor version(): Integer
+
+      attr_accessor reserved(): Integer
+
+      def self.new: (?Integer cmd, ?Integer version, ?Integer reserved) -> instance
+                  | (?cmd: Integer, ?version: Integer, ?reserved: Integer) -> instance
+    end
+
+    class GenlMsgHdr
+      FORMAT: untyped
+
+      # Decodes a header from the decoder's current position.
+      #
+      # @param [Decoder] decoder the source decoder
+      # @return [GenlMsgHdr] the decoded header
+      # @rbs (Decoder decoder) -> instance
+      def self.decode: (Decoder decoder) -> instance
+
+      # Encodes this header at the encoder's current position.
+      #
+      # @param [Encoder] encoder the destination encoder
+      # @return [void]
+      # @rbs (Encoder encoder) -> void
+      def encode: (Encoder encoder) -> void
+    end
+  end
+end

data/sig/generated/nl/genl.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/nl/genl.rb with RBS::Inline
+
+module Nl
+  # Generic Netlink families.
+  module Genl
+    # Base class for Generic Netlink families.
+    class Family < Nl::Family
+      # Returns the family-specific protocol version.
+      #
+      # @return [Integer] the protocol version
+      # @rbs () -> Integer
+      def self.version: () -> Integer
+
+      # Opens a session for this Generic Netlink family.
+      #
+      # @overload open(resolver:, executor: nil, notification_capacity: DEFAULT_NOTIFICATION_CAPACITY)
+      #   The caller is responsible for closing the session.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @return [Family] the opened family session
+      # @overload open(resolver:, executor: nil, notification_capacity: DEFAULT_NOTIFICATION_CAPACITY, &block)
+      #   The session is automatically closed after the block returns.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @yieldparam [Family] session the opened family session
+      #   @return [Object] the value returned from the block
+      # @rbs (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> (Nl::Family::Session & instance)
+      #    | [R] (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+      def self.open: (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> (Nl::Family::Session & instance)
+                   | [R] (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+    end
+
+    # Base class for Generic Netlink messages.
+    #
+    # A Generic Netlink message payload begins with a {GenlMsgHdr}, followed by
+    # the optional fixed header and attributes handled by {Raw::Message}.
+    class Message < Raw::Message
+      # Decodes a Generic Netlink message payload.
+      #
+      # @param [Decoder] decoder the source decoder
+      # @param [Integer] type the family ID from the Netlink message header
+      # @return [Message] the decoded message
+      # @raise [RuntimeError] if the command does not match the message class's type
+      # @rbs (Decoder decoder, type: Integer) -> instance
+      def self.decode: (Decoder decoder, type: Integer) -> instance
+    end
+  end
+end

data/sig/generated/nl/notification.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/nl/notification.rb with RBS::Inline
+
+module Nl
+  # A multicast group. `name` is the kernel-facing name.
+  # `id` is the fixed ID when the specification provides one.
+  class McastGroup < Data
+    attr_reader name(): untyped
+
+    attr_reader id(): untyped
+
+    def self.new: (untyped name, untyped id) -> instance
+                | (name: untyped, id: untyped) -> instance
+
+    def self.members: () -> [ :name, :id ]
+
+    def members: () -> [ :name, :id ]
+  end
+
+  # Thread-safe queue shared by a family's blocking and asynchronous facades.
+  class NotificationChannel
+    def initialize: (capacity: untyped) -> untyped
+
+    # Adds a notification without ever blocking the socket receive loop.
+    # Returns false after the channel has been closed.
+    def push: (untyped notification) -> untyped
+
+    # Records a broken notification boundary while allowing later delivery to
+    # resume after the consumer observes the error and resynchronizes state.
+    def fail: (untyped error) -> untyped
+
+    def pop: (?timeout: untyped) -> untyped
+
+    def empty?: () -> untyped
+
+    def close: () -> untyped
+
+    private def lose!: (untyped error) -> untyped
+  end
+
+  # An unbounded-in-time, single-family view of unsolicited messages.
+  class NotificationStream
+    include Enumerable[untyped]
+
+    def initialize: () ?{ (?) -> untyped } -> untyped
+
+    def next: (?timeout: untyped) -> untyped
+
+    # @rbs () -> Enumerator[untyped, void]
+    #  | () { (untyped) -> void } -> void
+    def each: () -> Enumerator[untyped, void]
+            | () { (untyped) -> void } -> void
+  end
+end

data/sig/generated/nl/notification_router.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/nl/notification_router.rb with RBS::Inline
+
+module Nl
+  # Routes unsolicited frames to per-family notification channels.
+  class NotificationRouter
+    class Entry < Struct[untyped]
+      attr_accessor endpoint(): untyped
+
+      attr_accessor classes(): untyped
+
+      attr_accessor channel(): untyped
+
+      def self.new: (?untyped endpoint, ?untyped classes, ?untyped channel) -> instance
+                  | (?endpoint: untyped, ?classes: untyped, ?channel: untyped) -> instance
+    end
+
+    def initialize: (protocol: untyped, capacity: untyped) -> untyped
+
+    def register: (untyped endpoint, untyped classes) -> untyped
+
+    def channel: (untyped endpoint) -> untyped
+
+    # Returns true if the frame belongs to a registered notification family.
+    def route: (untyped header, untyped payload) -> untyped
+
+    def close: () -> untyped
+
+    def lose_all: (untyped error) -> untyped
+  end
+end

data/sig/generated/nl/raw/client.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/nl/raw/client.rb with RBS::Inline
+
+module Nl
+  module Raw
+    # Owns one raw Netlink connection shared by compatible families.
+    class Client
+      # Opens a client for a raw Netlink protocol.
+      #
+      # @overload open(protonum:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY)
+      #   The caller is responsible for closing the client.
+      #   @param [Integer] protonum the Netlink protocol number
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @return [Client] the opened client
+      # @overload open(protonum:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY, &block)
+      #   The client is automatically closed after the block returns.
+      #   @param [Integer] protonum the Netlink protocol number
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @yieldparam [Client] client the opened client
+      #   @return [Object] the value returned from the block
+      # @rbs (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+      #    | [R] (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+      def self.open: (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+                   | [R] (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+
+      # @param [Integer] protonum the Netlink protocol number
+      # @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      # @param [Integer] notification_capacity the maximum number of queued notifications
+      # @rbs (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> void
+      def initialize: (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> void
+
+      # Builds a family backed by this client's connection.
+      #
+      # @param [Class<Family>] family_class a raw Netlink family class
+      # @return [Family] an instance of `family_class`
+      # @raise [TypeError] if +family_class+ does not inherit from {Family}
+      # @raise [ArgumentError] if the family's protocol number differs from the client's protocol number
+      # @rbs [F < Family] (_FamilyClass[F] family_class) -> F
+      def family: [F < Family] (_FamilyClass[F] family_class) -> F
+
+      # Closes the underlying Netlink connection.
+      #
+      # @return [void]
+      # --
+      # @rbs () -> void
+      def close: () -> void
+    end
+  end
+end

data/sig/generated/nl/raw/protocol.rbs

@@ -0,0 +1,122 @@
+# Generated from lib/nl/raw/protocol.rb with RBS::Inline
+
+module Nl
+  module Raw
+    class AckFrame < Data
+      attr_reader header(): untyped
+
+      def self.new: (untyped header) -> instance
+                  | (header: untyped) -> instance
+
+      def self.members: () -> [ :header ]
+
+      def members: () -> [ :header ]
+    end
+
+    class ErrorFrame < Data
+      attr_reader header(): untyped
+
+      attr_reader errno(): untyped
+
+      def self.new: (untyped header, untyped errno) -> instance
+                  | (header: untyped, errno: untyped) -> instance
+
+      def self.members: () -> [ :header, :errno ]
+
+      def members: () -> [ :header, :errno ]
+    end
+
+    class DoneFrame < Data
+      attr_reader header(): untyped
+
+      attr_reader errno(): untyped
+
+      def self.new: (untyped header, untyped errno) -> instance
+                  | (header: untyped, errno: untyped) -> instance
+
+      def self.members: () -> [ :header, :errno ]
+
+      def members: () -> [ :header, :errno ]
+    end
+
+    class UnknownFrame < Data
+      attr_reader header(): untyped
+
+      def self.new: (untyped header) -> instance
+                  | (header: untyped) -> instance
+
+      def self.members: () -> [ :header ]
+
+      def members: () -> [ :header ]
+    end
+
+    class DataFrame < Data
+      attr_reader header(): untyped
+
+      attr_reader message(): untyped
+
+      def self.new: (untyped header, untyped message) -> instance
+                  | (header: untyped, message: untyped) -> instance
+
+      def self.members: () -> [ :header, :message ]
+
+      def members: () -> [ :header, :message ]
+    end
+
+    class Request < Data
+      attr_reader type(): untyped
+
+      attr_reader flags(): untyped
+
+      attr_reader message(): untyped
+
+      def self.new: (untyped type, untyped flags, untyped message) -> instance
+                  | (type: untyped, flags: untyped, message: untyped) -> instance
+
+      def self.members: () -> [ :type, :flags, :message ]
+
+      def members: () -> [ :type, :flags, :message ]
+    end
+
+    # A generated raw Netlink family bound to its fixed wire identity.
+    class Endpoint
+      attr_reader definition: untyped
+
+      def initialize: (untyped definition) -> untyped
+
+      def name: () -> untyped
+
+      def frame_type: (untyped message_class) -> untyped
+
+      def multicast_group_id: (untyped name, untyped value) -> untyped
+    end
+
+    # Socket-wide wire behavior for a classic (netlink-raw) protocol.
+    class Protocol
+      attr_reader protonum: untyped
+
+      def initialize: (untyped protonum) -> untyped
+
+      def encode_message: (untyped encoder, untyped _endpoint, untyped request, seq: untyped, pid: untyped) -> untyped
+
+      # Decodes one frame using the reply class associated with its sequence.
+      def decode_frame: (untyped _endpoint, untyped header, untyped payload, untyped message_class) -> untyped
+
+      def send_message: (untyped socket, untyped endpoint, untyped request, seq: untyped, pid: untyped) -> untyped
+
+      def build_request: (untyped endpoint, untyped kind, untyped request_class, untyped args) -> untyped
+
+      def notification_channel_key: (untyped endpoint) -> untyped
+
+      def notification_route_keys: (untyped _endpoint, untyped classes) -> untyped
+
+      def notification_frame_key: (untyped header) -> untyped
+
+      def notification_frame?: (untyped _endpoint, untyped header, untyped _payload) -> untyped
+
+      def notification_class: (untyped _endpoint, untyped header, untyped _payload, untyped classes) -> untyped
+
+      def decode_notification: (untyped endpoint, untyped header, untyped payload, untyped message_class) -> untyped
+    end
+  end
+end