redhound 1.0.1 → 2.0.0.rc2

data/sig/generated/redhound/filter/codegen.rbs

@@ -0,0 +1,101 @@
+# Generated from lib/redhound/filter/codegen.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    class CodeGen
+      LINKTYPES: untyped
+
+      LAYOUTS: untyped
+
+      ALU: untyped
+
+      # @rbs (Integer linktype, Integer snaplen, bool live, String expression) -> void
+      def initialize: (Integer linktype, Integer snaplen, bool live, String expression) -> void
+
+      # @rbs (untyped ast) -> Program
+      def compile: (untyped ast) -> Program
+
+      private
+
+      # @rbs (untyped ast) -> bool
+      def includes_vlan?: (untyped ast) -> bool
+
+      # @rbs (untyped node, Symbol yes, Symbol no) -> void
+      def emit: (untyped node, Symbol yes, Symbol no) -> void
+
+      # @rbs (untyped node) -> untyped
+      def primitive: (untyped node) -> untyped
+
+      # @rbs (String name) -> untyped
+      def family: (String name) -> untyped
+
+      # @rbs (Integer number, Array[Integer] versions) -> untyped
+      def protocol: (Integer number, Array[Integer] versions) -> untyped
+
+      # @rbs (Integer version, Integer number) -> untyped
+      def next_protocol: (Integer version, Integer number) -> untyped
+
+      # @rbs () -> untyped
+      def fragment_guard: () -> untyped
+
+      # @rbs () -> Integer
+      def network: () -> Integer
+
+      # @rbs (Integer offset, Integer size, Symbol operation, Integer value, ?Symbol? mode) -> untyped
+      def test: (Integer offset, Integer size, Symbol operation, Integer value, ?Symbol? mode) -> untyped
+
+      # @rbs (*untyped nodes) -> untyped
+      def conjunction: (*untyped nodes) -> untyped
+
+      # @rbs (*untyped nodes) -> untyped
+      def disjunction: (*untyped nodes) -> untyped
+
+      # @rbs (Symbol direction, untyped src, untyped dst) -> untyped
+      def directional: (Symbol direction, untyped src, untyped dst) -> untyped
+
+      # @rbs (untyped values, String? proto, Symbol direction) -> untyped
+      def addresses: (untyped values, String? proto, Symbol direction) -> untyped
+
+      # @rbs (Integer offset, Integer version, Integer address, Integer mask) -> untyped
+      def address_test: (Integer offset, Integer version, Integer address, Integer mask) -> untyped
+
+      # @rbs (String mac, Symbol direction, Integer position) -> untyped
+      def ethernet_host: (String mac, Symbol direction, Integer position) -> untyped
+
+      # @rbs (untyped ranges, Symbol direction) -> untyped
+      def ports: (untyped ranges, Symbol direction) -> untyped
+
+      # @rbs (Integer version, Integer offset, [Integer, Integer] limits) -> untyped
+      def port_test: (Integer version, Integer offset, [ Integer, Integer ] limits) -> untyped
+
+      # @rbs (String? proto, Symbol type, Integer position) -> untyped
+      def broadcast: (String? proto, Symbol type, Integer position) -> untyped
+
+      # @rbs (Integer? id, Symbol yes, Symbol no) -> void
+      def vlan: (Integer? id, Symbol yes, Symbol no) -> void
+
+      # @rbs (Integer offset, Integer size, Symbol? mode) -> void
+      def load: (Integer offset, Integer size, Symbol? mode) -> void
+
+      # @rbs () -> void
+      def transport_index: () -> void
+
+      # @rbs (untyped operation, Integer value, Symbol yes, Symbol no, ?bool from_x) -> void
+      def compare: (untyped operation, Integer value, Symbol yes, Symbol no, ?bool from_x) -> void
+
+      # @rbs (untyped node) -> Array[String]
+      def access_protocols: (untyped node) -> Array[String]
+
+      # @rbs (untyped node, Integer depth) -> void
+      def arithmetic: (untyped node, Integer depth) -> void
+
+      # @rbs (untyped node, Integer depth) -> void
+      def accessor: (untyped node, Integer depth) -> void
+
+      # @rbs (String message, Integer position) -> bot
+      def error: (String message, Integer position) -> bot
+    end
+  end
+end

data/sig/generated/redhound/filter/lexer.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/redhound/filter/lexer.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    class Lexer
+      # @rbs (String expression) -> void
+      def initialize: (String expression) -> void
+
+      # @rbs () -> Array[[String, Integer]]
+      def tokens: () -> Array[[ String, Integer ]]
+    end
+  end
+end

data/sig/generated/redhound/filter/parser.rbs

@@ -0,0 +1,65 @@
+# Generated from lib/redhound/filter/parser.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # ASTs stay private; primitive operands are resolved before code generation.
+    # @api private
+    class Parser
+      PROTOCOLS: untyped
+
+      TYPES: untyped
+
+      COMPARISONS: untyped
+
+      PRECEDENCE: untyped
+
+      CONSTANTS: untyped
+
+      # @rbs (String expression) -> void
+      def initialize: (String expression) -> void
+
+      # @rbs () -> untyped
+      def parse: () -> untyped
+
+      private
+
+      # libpcap gives AND and OR the same precedence, left associative.
+      # @rbs () -> untyped
+      def expression: () -> untyped
+
+      # @rbs () -> untyped
+      def unary: () -> untyped
+
+      # @rbs () -> untyped
+      def primitive: () -> untyped
+
+      # @rbs () -> untyped
+      def relation: () -> untyped
+
+      # @rbs (?Integer minimum) -> untyped
+      def arithmetic: (?Integer minimum) -> untyped
+
+      # @rbs (String value) -> bool
+      def numeric?: (String value) -> bool
+
+      # @rbs (String value) -> Integer
+      def integer: (String value) -> Integer
+
+      # @rbs () -> Integer
+      def number: () -> Integer
+
+      # @rbs () -> String
+      def peek: () -> String
+
+      # @rbs () -> String
+      def take: () -> String
+
+      # @rbs (String value) -> void
+      def expect: (String value) -> void
+
+      # @rbs (String message, ?Integer? position) -> bot
+      def error: (String message, ?Integer? position) -> bot
+    end
+  end
+end

data/sig/generated/redhound/filter/program.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/redhound/filter/program.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    class Program
+      class KernelPacket < Struct[untyped]
+        attr_accessor data(): untyped
+
+        attr_accessor original_length(): untyped
+
+        attr_accessor meta(): untyped
+
+        def self.new: (?untyped data, ?untyped original_length, ?untyped meta) -> instance
+                    | (?data: untyped, ?original_length: untyped, ?meta: untyped) -> instance
+      end
+
+      attr_reader instructions: untyped
+
+      attr_reader linktype: untyped
+
+      # @rbs (Array[[Integer, Integer, Integer, Integer]] instructions, ?linktype: Integer?, ?cooked_live: bool) -> void
+      def initialize: (Array[[ Integer, Integer, Integer, Integer ]] instructions, ?linktype: Integer?, ?cooked_live: bool) -> void
+
+      # @rbs (untyped packet) -> Integer
+      def evaluate: (untyped packet) -> Integer
+
+      # @rbs (untyped packet) -> bool
+      def match?: (untyped packet) -> bool
+
+      # Native struct sock_filter / struct bpf_insn bytes.
+      # @rbs () -> String
+      def packed: () -> String
+
+      alias serialize packed
+
+      alias to_binary packed
+
+      # @rbs (?format: Symbol) -> String
+      def disassemble: (?format: Symbol) -> String
+
+      # Includes a String reference retained by pack('P') until setsockopt/ioctl finishes.
+      # @rbs () -> String
+      def sock_fprog: () -> String
+    end
+  end
+end

data/sig/generated/redhound/filter.rbs

@@ -0,0 +1,10 @@
+# Generated from lib/redhound/filter.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # Compiles a pcap-filter subset without libpcap or external commands.
+    # @rbs (String expression, ?linktype: Symbol | Integer, ?snaplen: Integer, ?live: bool) -> Program
+    def self.compile: (String expression, ?linktype: Symbol | Integer, ?snaplen: Integer, ?live: bool) -> Program
+  end
+end

data/sig/generated/redhound/layer.rbs

@@ -0,0 +1,81 @@
+# Generated from lib/redhound/layer.rb with RBS::Inline
+
+module Redhound
+  # One decoded protocol header and its payload bounds, fields and diagnostics.
+  class Layer
+    # Protocol identity, captured offset, decoded values and diagnostics.
+    attr_reader protocol: untyped
+
+    # Protocol identity, captured offset, decoded values and diagnostics.
+    attr_reader offset: untyped
+
+    # Protocol identity, captured offset, decoded values and diagnostics.
+    attr_reader diagnostics: untyped
+
+    # Protocol identity, captured offset, decoded values and diagnostics.
+    attr_reader definitions: untyped
+
+    # Protocol identity, captured offset, decoded values and diagnostics.
+    attr_reader values: untyped
+
+    # Protocol identity, captured offset, decoded values and diagnostics.
+    attr_reader embedded: untyped
+
+    # Header size and absolute payload bounds used by child dissectors.
+    attr_accessor header_length: untyped
+
+    # Header size and absolute payload bounds used by child dissectors.
+    attr_accessor payload_offset: untyped
+
+    # Header size and absolute payload bounds used by child dissectors.
+    attr_accessor payload_end: untyped
+
+    # @rbs (Symbol protocol, Integer offset, Integer length, Integer limit, ?definitions: Array[untyped], ?values: Hash[Symbol, untyped], ?embedded: bool) -> void
+    # Create a bounded header with optional fixed field definitions and values.
+    def initialize: (Symbol protocol, Integer offset, Integer length, Integer limit, ?definitions: Array[untyped], ?values: Hash[Symbol, untyped], ?embedded: bool) -> void
+
+    # @rbs (Symbol key) -> untyped
+    # Read the raw value identified by a symbolic field key.
+    def []: (Symbol key) -> untyped
+
+    # @rbs () -> Integer
+    # Decoded header length in bytes.
+    def length: () -> Integer
+
+    # @rbs () -> bool
+    # Whether no bytes remain for a child protocol.
+    def payload_empty?: () -> bool
+
+    # @rbs () -> bool
+    # Whether an error or truncation stops the protocol chain.
+    def error?: () -> bool
+
+    # @rbs (Symbol severity, Symbol code, ?String message, ?String? field) -> Layer
+    # Append a structured diagnostic and return this layer.
+    def diagnose: (Symbol severity, Symbol code, ?String message, ?String? field) -> Layer
+
+    # @rbs (Symbol key, String name, untyped value, ?type: Symbol, ?offset: Integer, ?length: Integer, ?format: Symbol?, ?enum: untyped) -> Layer
+    # Append a dynamic field with its value, representation and location.
+    def add: (Symbol key, String name, untyped value, ?type: Symbol, ?offset: Integer, ?length: Integer, ?format: Symbol?, ?enum: untyped) -> Layer
+
+    # @rbs () -> Array[Field]
+    # Return Field objects for all fixed and dynamic definitions.
+    def fields: () -> Array[Field]
+
+    # @rbs (Symbol key) -> String
+    # Return escaped text for a single symbolic field.
+    def display: (Symbol key) -> String
+
+    # @rbs (String name) -> untyped
+    # Read the first decoded value with this dotted field name.
+    def field_value: (String name) -> untyped
+
+    # @rbs (String name) -> Array[untyped]
+    # Read the first decoded value with this dotted field name.
+    def field_values: (String name) -> Array[untyped]
+
+    # @rbs () -> Hash[Symbol, untyped]
+    # Return JSON fields, grouping repeated names into arrays.
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/generated/redhound/output/fields.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/redhound/output/fields.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Output
+    # @api private
+    class Fields
+      # @rbs (Array[String] names) -> void
+      def initialize: (Array[String] names) -> void
+
+      # @rbs (Packet packet, untyped io) -> void
+      def format: (Packet packet, untyped io) -> void
+    end
+  end
+end

data/sig/generated/redhound/output/follow.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/redhound/output/follow.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Output
+    # @api private
+    class Follow
+      # @rbs (String specification) -> void
+      def initialize: (String specification) -> void
+
+      # @rbs (Analysis::Flow flow, Integer direction, String data) -> void
+      def write: (Analysis::Flow flow, Integer direction, String data) -> void
+
+      # @rbs (untyped io) -> void
+      def format: (untyped io) -> void
+
+      # @rbs () -> void
+      def close: () -> void
+    end
+  end
+end

data/sig/generated/redhound/output/hexdump.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/redhound/output/hexdump.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Output
+    # @api private
+    class Hexdump
+      # @rbs (?ascii: bool, ?link_layer: bool) -> void
+      def initialize: (?ascii: bool, ?link_layer: bool) -> void
+
+      # @rbs (Packet packet, untyped io) -> void
+      def format: (Packet packet, untyped io) -> void
+    end
+  end
+end

data/sig/generated/redhound/output/json.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/redhound/output/json.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Output
+    # @api private
+    class Json
+      # @rbs (?ndjson: bool) -> void
+      def initialize: (?ndjson: bool) -> void
+
+      # @rbs (Packet packet, untyped io) -> void
+      def format: (Packet packet, untyped io) -> void
+
+      # @rbs (untyped io) -> void
+      def finish: (untyped io) -> void
+    end
+  end
+end

data/sig/generated/redhound/output/summary.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/redhound/output/summary.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Output
+    # @api private
+    class Summary
+      # @rbs (?timestamp: Symbol, ?precision: Symbol, ?link_layer: bool, ?quick: bool, ?verbosity: Integer, ?resolve_names: bool) -> void
+      def initialize: (?timestamp: Symbol, ?precision: Symbol, ?link_layer: bool, ?quick: bool, ?verbosity: Integer, ?resolve_names: bool) -> void
+
+      # @rbs (Packet packet) -> String
+      def line: (Packet packet) -> String
+
+      # @rbs (Packet packet, untyped io) -> void
+      def format: (Packet packet, untyped io) -> void
+
+      # @rbs (String ip) -> String
+      def address: (String ip) -> String
+    end
+  end
+end

data/sig/generated/redhound/output/timestamp.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/redhound/output/timestamp.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Output
+    # @api private
+    class Timestamp
+      # @rbs (?style: Symbol, ?precision: Symbol) -> void
+      def initialize: (?style: Symbol, ?precision: Symbol) -> void
+
+      # @rbs (Packet packet) -> String
+      def format: (Packet packet) -> String
+
+      # @rbs (Integer ns) -> String
+      def fraction: (Integer ns) -> String
+
+      # @rbs (Integer ns) -> String
+      def seconds: (Integer ns) -> String
+    end
+  end
+end

data/sig/generated/redhound/output/tree.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/redhound/output/tree.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Output
+    # @api private
+    class Tree
+      # @rbs (Packet packet, untyped io) -> void
+      def format: (Packet packet, untyped io) -> void
+
+      # @rbs (String text) -> String
+      def safe: (String text) -> String
+    end
+  end
+end

data/sig/generated/redhound/packet.rbs

@@ -0,0 +1,82 @@
+# Generated from lib/redhound/packet.rb with RBS::Inline
+
+module Redhound
+  # Captured immutable bytes, metadata, and lazily decoded protocol layers.
+  class Packet
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader data: untyped
+
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader timestamp_ns: untyped
+
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader original_length: untyped
+
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader linktype: untyped
+
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader interface: untyped
+
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader direction: untyped
+
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader number: untyped
+
+    # Capture bytes and metadata; timestamp_ns and lengths preserve kernel/file values.
+    attr_reader meta: untyped
+
+    # Override the dissection engine before accessing layers.
+    attr_accessor engine: untyped
+
+    # @rbs (String data, ?timestamp_ns: Integer, ?original_length: Integer?, ?linktype: (Integer | Symbol), ?interface: untyped, ?direction: Symbol?, ?number: Integer, ?meta: Hash[Symbol, untyped]) -> void
+    # Copy binary data and preserve capture metadata; reject impossible original lengths.
+    def initialize: (String data, ?timestamp_ns: Integer, ?original_length: Integer?, ?linktype: Integer | Symbol, ?interface: untyped, ?direction: Symbol?, ?number: Integer, ?meta: Hash[Symbol, untyped]) -> void
+
+    # @rbs () -> Integer
+    # Number of captured bytes.
+    def caplen: () -> Integer
+
+    # @rbs () -> bool
+    # Whether capture omitted bytes from the original packet.
+    def truncated?: () -> bool
+
+    # @rbs () -> Time
+    # Capture timestamp as a nanosecond-precision Time.
+    def time: () -> Time
+
+    # @rbs () -> Array[Layer]
+    # Decode the protocol chain once and return its Layers.
+    def layers: () -> Array[Layer]
+
+    # @rbs ((Symbol | String) key) -> untyped
+    # Select the first layer by symbol or decoded field by dotted name.
+    def []: (Symbol | String key) -> untyped
+
+    # @rbs (Symbol protocol) -> Array[Layer]
+    # Decode the protocol chain once and return its Layers.
+    def layers_of: (Symbol protocol) -> Array[Layer]
+
+    # @rbs (Symbol protocol) -> Layer?
+    # Return the last matching layer in the protocol chain.
+    def innermost: (Symbol protocol) -> Layer?
+
+    # @rbs (String name) -> Array[untyped]
+    # Return every decoded value of a repeated field.
+    def field_values: (String name) -> Array[untyped]
+
+    # @rbs () -> String
+    # Format a numeric one-line packet summary.
+    def summary: () -> String
+
+    # @rbs () -> Hash[Symbol, untyped]
+    # Return a JSON-compatible packet matching docs/json-schema.json.
+    def to_h: () -> Hash[Symbol, untyped]
+
+    private
+
+    # @rbs (String? text) -> String?
+    def json_text: (String? text) -> String?
+  end
+end

data/sig/generated/redhound/protocols/arp.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/redhound/protocols/arp.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Protocols
+    # @api private
+    class Arp < Dissector
+      # @rbs (Context ctx, Layer layer) -> void
+      def dissect: (Context ctx, Layer layer) -> void
+
+      # @rbs (Layer layer) -> String
+      def summary: (Layer layer) -> String
+    end
+  end
+end

data/sig/generated/redhound/protocols/checksum.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/redhound/protocols/checksum.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Protocols
+    # @api private
+    module Checksum
+      # @rbs (String bytes) -> Integer
+      def self.value: (String bytes) -> Integer
+
+      # @rbs (Context ctx, Layer layer, String bytes, ?Integer? proto) -> void
+      def self.verify: (Context ctx, Layer layer, String bytes, ?Integer? proto) -> void
+    end
+  end
+end

data/sig/generated/redhound/protocols/data.rbs

@@ -0,0 +1,17 @@
+# Generated from lib/redhound/protocols/data.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Protocols
+    # @api private
+    class Data < Dissector
+      LENGTH_FIELD: untyped
+
+      # @rbs (Context ctx, Layer layer) -> void
+      def dissect: (Context ctx, Layer layer) -> void
+
+      # @rbs (Layer layer) -> String
+      def summary: (Layer layer) -> String
+    end
+  end
+end

data/sig/generated/redhound/protocols/dhcp.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/redhound/protocols/dhcp.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Protocols
+    # @api private
+    class Dhcp < Dissector
+      MESSAGE_TYPES: untyped
+
+      ADDRESS_OPTIONS: untyped
+
+      # @rbs (Context ctx, Layer layer) -> void
+      def dissect: (Context ctx, Layer layer) -> void
+
+      # @rbs (Cursor cursor, Layer layer, Integer pos, Integer ending, untyped options) -> void
+      def read_options: (Cursor cursor, Layer layer, Integer pos, Integer ending, untyped options) -> void
+
+      # @rbs (Layer layer, Integer code, String value, untyped entries) -> void
+      def decode_option: (Layer layer, Integer code, String value, untyped entries) -> void
+
+      # @rbs (untyped entries, Integer logical) -> Integer
+      def wire_offset: (untyped entries, Integer logical) -> Integer
+
+      # @rbs (Layer layer, String name, untyped value, Symbol type, Integer offset, Integer length, ?untyped entries) -> void
+      def put: (Layer layer, String name, untyped value, Symbol type, Integer offset, Integer length, ?untyped entries) -> void
+
+      # @rbs (Layer layer) -> String
+      def summary: (Layer layer) -> String
+    end
+  end
+end

data/sig/generated/redhound/protocols/dns.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/redhound/protocols/dns.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Protocols
+    # @api private
+    class Dns < StreamDissector
+      # @api private
+      class Malformed < StandardError
+      end
+
+      TYPES: untyped
+
+      # @rbs (Context ctx, Layer layer) -> void
+      def dissect: (Context ctx, Layer layer) -> void
+
+      # @rbs (Cursor cursor, Layer layer, Symbol variant) -> void
+      def message: (Cursor cursor, Layer layer, Symbol variant) -> void
+
+      # @rbs (Cursor cursor, Integer pos, ?Integer? limit, ?bool compression) -> [String, Integer]
+      def read_name: (Cursor cursor, Integer pos, ?Integer? limit, ?bool compression) -> [ String, Integer ]
+
+      # @rbs (Cursor cursor, Layer layer, Integer pos, Integer base, Symbol variant) -> Integer
+      def record: (Cursor cursor, Layer layer, Integer pos, Integer base, Symbol variant) -> Integer
+
+      # @rbs (Cursor cursor, Layer layer, Integer type, Integer pos, Integer ending, Integer base) -> void
+      def rdata: (Cursor cursor, Layer layer, Integer type, Integer pos, Integer ending, Integer base) -> void
+
+      # @rbs (Cursor cursor, Layer layer, Integer pos, Integer ending, Integer base) -> void
+      def service_binding: (Cursor cursor, Layer layer, Integer pos, Integer ending, Integer base) -> void
+
+      # @rbs (Cursor cursor, Layer layer, Integer pos, Integer ending, Integer base) -> void
+      def edns: (Cursor cursor, Layer layer, Integer pos, Integer ending, Integer base) -> void
+
+      # @rbs (Layer layer, String name, untyped value, Symbol type, Integer offset, Integer length) -> void
+      def put: (Layer layer, String name, untyped value, Symbol type, Integer offset, Integer length) -> void
+
+      # @rbs (Layer layer) -> String
+      def summary: (Layer layer) -> String
+    end
+  end
+end