stem-mqtt-client 0.6.1-x86_64-linux

data/lib/stem_mqtt_client/mqtt_client.rb

@@ -0,0 +1,2659 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .rb file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Ruby
+# helpers directly inline like we're doing here.
+
+require 'ffi'
+require 'set'
+require 'monitor'
+
+module MqttClient
+  def self.uniffi_in_range(i, type_name, min, max)
+  raise TypeError, "no implicit conversion of #{i} into Integer" unless i.respond_to?(:to_int)
+  i = i.to_int
+  raise RangeError, "#{type_name} requires #{min} <= value < #{max}" unless (min <= i && i < max)
+  i
+end
+
+def self.uniffi_utf8(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v = v.to_str.encode(Encoding::UTF_8)
+  raise Encoding::InvalidByteSequenceError, "not a valid UTF-8 encoded string" unless v.valid_encoding?
+  v
+end
+
+def self.uniffi_bytes(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v.to_str
+end
+
+# Callback return codes
+UNIFFI_CALLBACK_SUCCESS = 0
+UNIFFI_CALLBACK_ERROR = 1
+UNIFFI_CALLBACK_UNEXPECTED_ERROR = 2
+
+# Call a method on a callback interface object, catching and reporting errors
+# to Rust via the call_status.
+# If error_type is provided, known errors of that type are reported as UNIFFI_CALLBACK_ERROR;
+# all other errors are reported as UNIFFI_CALLBACK_UNEXPECTED_ERROR.
+def self.uniffi_trait_interface_call(call_status, make_call, write_return_value, error_type = nil, lower_error = nil)
+  begin
+    write_return_value.call make_call.call
+  rescue StandardError => e
+    buf = if !error_type.nil? && uniffi_is_error_type?(e, error_type)
+      call_status[:code] = UNIFFI_CALLBACK_ERROR
+      lower_error.call e
+    else
+      call_status[:code] = UNIFFI_CALLBACK_UNEXPECTED_ERROR
+      RustBuffer.alloc_from_string(e.inspect)
+    end
+
+    error_buf = call_status[:error_buf]
+    error_buf[:capacity] = buf[:capacity]
+    error_buf[:len] = buf[:len]
+    error_buf[:data] = buf[:data]
+  end
+end
+
+# Check if an exception is a variant of the given error type.
+# Error types in Ruby are either modules (non-flat enums) or classes (flat enums),
+# with variant classes as constant within them.
+def self.uniffi_is_error_type?(e, error_type)
+  # Object-as-error: error_type is a class itself (e.g. MyError < StandardError)
+  if error_type.is_a?(Class) && e.is_a?(error_type)
+    return true
+  end
+
+  # Enum error: error_type is a module with class constants for each variant
+  error_type.constants.any? do |c|
+    klass = error_type.const_get c
+    klass.is_a?(Class) && e.is_a?(klass)
+  end
+end
+  # A handle map for converting Ruby objects to/from integer handles.
+#
+# When passing callback interface or trait interface objects to Ruby, we store
+# the Ruby object in this map and pass the integer handle to Rust. When Rust
+# calls back, we look up the Ruby object by its handle.
+#
+# Ruby-created handles are always odd (staring at 1, incrementing by 2).
+# Rust-created handles are always even. This convention lets us distinguish
+# the source in lift/lower without extra metadata.
+
+
+class UniffiHandleMap
+  def initialize
+    @lock = Monitor.new
+    @map = {}
+    @counter = 1 # Start at 1 (odd), increment by 2
+  end
+
+  def insert(obj)
+    @lock.synchronize do
+      handle = @counter
+      @counter += 2
+      @map[handle] = obj
+      handle
+    end
+  end
+
+  def get(handle)
+    @lock.synchronize do
+      obj = @map[handle]
+      raise InternalError, "UniffiHandleMap.get: invalid handle #{handle}" if obj.nil?
+      obj
+    end
+  end
+
+  def clone_handle(handle)
+    @lock.synchronize do
+      obj = @map[handle]
+      raise InternalError, "UniffiHandleMap.clone_handle: invalid handle #{handle}" if obj.nil?
+      new_handle = @counter
+      @counter += 2
+      @map[new_handle] = obj
+      new_handle
+    end
+  end
+
+  def remove(handle)
+    @lock.synchronize do
+      obj = @map.delete(handle)
+      raise InternalError, "UniffiHandleMap.remove: invalid handle #{handle}" if obj.nil?
+      obj
+    end
+  end
+
+  # Used for testing/debugging purposes
+  def size
+    @lock.synchronize { @map.size }
+  end
+end
+
+private_constant :UniffiHandleMap
+  class RustBuffer < FFI::Struct
+  layout :capacity, :uint64,
+         :len,      :uint64,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return ::MqttClient.rust_call(:ffi_mqtt_client_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return ::MqttClient.rust_call(:ffi_mqtt_client_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    ::MqttClient.rust_call(:ffi_mqtt_client_rustbuffer_free, self)
+  end
+
+  def capacity
+    self[:capacity]
+  end
+
+  def len
+    self[:len]
+  end
+
+  def len=(value)
+    self[:len] = value
+  end
+
+  def data
+    self[:data]
+  end
+
+  def to_s
+    "RustBuffer(capacity=#{capacity}, len=#{len}, data=#{data.read_bytes len})"
+  end
+
+  # The allocated buffer will be automatically freed if an error occurs, ensuring that
+  # we don't accidentally leak it.
+  def self.allocWithBuilder
+    builder = RustBufferBuilder.new
+
+    begin
+      yield builder
+    rescue => e
+      builder.discard
+      raise e
+    end
+  end
+
+  # The RustBuffer will be freed once the context-manager exits, ensuring that we don't
+  # leak it even if an error occurs.
+  def consumeWithStream
+    stream = RustBufferStream.new self
+
+    yield stream
+
+    raise RuntimeError, 'junk data left in buffer after consuming' if stream.remaining != 0
+  ensure
+    free
+  end# The primitive String type.
+
+  def self.alloc_from_string(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consume_into_string
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  # The primitive Bytes type.
+
+  def self.alloc_from_bytes(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_bytes(value)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_bytes
+    consumeWithStream do |stream|
+      return stream.read_bytes
+    end
+  end
+
+  # The Record type ConnectOptions.
+
+  def self.check_lower_TypeConnectOptions(v)
+    
+    
+    
+    RustBuffer.check_lower_TypeMqttVersion(v.version)
+    
+    
+    RustBuffer.check_lower_Optionalstring(v.username)
+    RustBuffer.check_lower_Optionalbytes(v.password)
+    RustBuffer.check_lower_OptionalTypeWillOptions(v.will)
+    
+    
+    
+    
+    
+    RustBuffer.check_lower_OptionalTypeTlsOptions(v.tls)
+    
+    RustBuffer.check_lower_Optionalstring(v.auth_method)
+    RustBuffer.check_lower_Optionalbytes(v.auth_data)
+  end
+
+  def self.alloc_from_TypeConnectOptions(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeConnectOptions(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeConnectOptions
+    consumeWithStream do |stream|
+      return stream.read_TypeConnectOptions
+    end
+  end
+
+  # The Record type ConnectResult.
+
+  def self.check_lower_TypeConnectResult(v)
+    
+    
+  end
+
+  def self.alloc_from_TypeConnectResult(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeConnectResult(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeConnectResult
+    consumeWithStream do |stream|
+      return stream.read_TypeConnectResult
+    end
+  end
+
+  # The Record type MqttMessage.
+
+  def self.check_lower_TypeMqttMessage(v)
+    
+    
+    RustBuffer.check_lower_TypeQoS(v.qos)
+    
+  end
+
+  def self.alloc_from_TypeMqttMessage(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeMqttMessage(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeMqttMessage
+    consumeWithStream do |stream|
+      return stream.read_TypeMqttMessage
+    end
+  end
+
+  # The Record type SubscribeResult.
+
+  def self.check_lower_TypeSubscribeResult(v)
+    
+  end
+
+  def self.alloc_from_TypeSubscribeResult(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeSubscribeResult(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeSubscribeResult
+    consumeWithStream do |stream|
+      return stream.read_TypeSubscribeResult
+    end
+  end
+
+  # The Record type TlsOptions.
+
+  def self.check_lower_TypeTlsOptions(v)
+    RustBuffer.check_lower_Optionalbytes(v.ca_cert_pem)
+    RustBuffer.check_lower_Optionalbytes(v.client_cert_pem)
+    RustBuffer.check_lower_Optionalbytes(v.client_key_pem)
+    
+  end
+
+  def self.alloc_from_TypeTlsOptions(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeTlsOptions(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeTlsOptions
+    consumeWithStream do |stream|
+      return stream.read_TypeTlsOptions
+    end
+  end
+
+  # The Record type WillOptions.
+
+  def self.check_lower_TypeWillOptions(v)
+    
+    
+    RustBuffer.check_lower_TypeQoS(v.qos)
+    
+  end
+
+  def self.alloc_from_TypeWillOptions(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeWillOptions(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeWillOptions
+    consumeWithStream do |stream|
+      return stream.read_TypeWillOptions
+    end
+  end
+
+  # Error enum - generate alloc_from for callback error serialization
+  def self.alloc_from_TypeMqttError(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeMqttError(v)
+      return builder.finalize
+    end
+  end
+
+  # Enum used as error - generate consume_into_ for use as a return value
+  def consume_into_TypeMqttError
+    consumeWithStream do |stream|
+      return stream.read_TypeMqttError
+    end
+  end
+  
+
+  # The Enum type MqttVersion.
+
+  def self.check_lower_TypeMqttVersion(v)
+  end
+
+  def self.alloc_from_TypeMqttVersion(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeMqttVersion(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeMqttVersion
+    consumeWithStream do |stream|
+      return stream.read_TypeMqttVersion
+    end
+  end
+  
+
+  # The Enum type QoS.
+
+  def self.check_lower_TypeQoS(v)
+  end
+
+  def self.alloc_from_TypeQoS(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeQoS(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeQoS
+    consumeWithStream do |stream|
+      return stream.read_TypeQoS
+    end
+  end
+  
+
+  # The Optional<T> type for string.
+
+  def self.check_lower_Optionalstring(v)
+    if !v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalstring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalstring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_Optionalstring
+    consumeWithStream do |stream|
+      return stream.read_Optionalstring
+    end
+  end
+
+  # The Optional<T> type for bytes.
+
+  def self.check_lower_Optionalbytes(v)
+    if !v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalbytes(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalbytes(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_Optionalbytes
+    consumeWithStream do |stream|
+      return stream.read_Optionalbytes
+    end
+  end
+
+  # The Optional<T> type for TypeMqttMessage.
+
+  def self.check_lower_OptionalTypeMqttMessage(v)
+    if !v.nil?
+      RustBuffer.check_lower_TypeMqttMessage(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeMqttMessage(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeMqttMessage(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_OptionalTypeMqttMessage
+    consumeWithStream do |stream|
+      return stream.read_OptionalTypeMqttMessage
+    end
+  end
+
+  # The Optional<T> type for TypeTlsOptions.
+
+  def self.check_lower_OptionalTypeTlsOptions(v)
+    if !v.nil?
+      RustBuffer.check_lower_TypeTlsOptions(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeTlsOptions(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeTlsOptions(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_OptionalTypeTlsOptions
+    consumeWithStream do |stream|
+      return stream.read_OptionalTypeTlsOptions
+    end
+  end
+
+  # The Optional<T> type for TypeWillOptions.
+
+  def self.check_lower_OptionalTypeWillOptions(v)
+    if !v.nil?
+      RustBuffer.check_lower_TypeWillOptions(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeWillOptions(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeWillOptions(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_OptionalTypeWillOptions
+    consumeWithStream do |stream|
+      return stream.read_OptionalTypeWillOptions
+    end
+  end
+
+  
+end
+
+module UniFFILib
+  class ForeignBytes < FFI::Struct
+    layout :len,      :int32,
+           :data,     :pointer
+
+    def len
+      self[:len]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def to_s
+      "ForeignBytes(len=#{len}, data=#{data.read_bytes(len)})"
+    end
+  end
+end
+
+private_constant :UniFFILib
+  
+# Helper for structured reading of values from a RustBuffer.
+class RustBufferStream
+
+  def initialize(rbuf)
+    @rbuf = rbuf
+    @offset = 0
+  end
+
+  def remaining
+    @rbuf.len - @offset
+  end
+
+  def read(size)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    data = @rbuf.data.get_bytes @offset, size
+
+    @offset += size
+
+    data
+  end
+
+  def read_u8
+    unpack_from 1, 'c'
+  end
+
+  def read_u16
+    unpack_from 2, 'S>'
+  end
+
+  def read_u32
+    unpack_from 4, 'L>'
+  end
+
+  def read_bool
+    v = unpack_from 1, 'c'
+
+    return false if v == 0
+    return true if v == 1
+
+    raise InternalError, 'Unexpected byte for Boolean type'
+  end
+
+  def read_string
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  def read_bytes
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative byte string length' if size.negative?
+
+    read(size).force_encoding(Encoding::BINARY)
+  end
+
+  # The Object type MqttAuthHandler.
+
+  def read_TypeMqttAuthHandler
+    handle = unpack_from 8, 'Q>'
+    return MqttAuthHandler.uniffi_lift(handle)
+  end
+
+  # The Object type MqttClient.
+
+  def read_TypeMqttClient
+    handle = unpack_from 8, 'Q>'
+    return MqttClient.uniffi_lift(handle)
+  end
+
+  # The Object type MqttMessageListener.
+
+  def read_TypeMqttMessageListener
+    handle = unpack_from 8, 'Q>'
+    return MqttMessageListener.uniffi_lift(handle)
+  end
+
+  # The Record type ConnectOptions.
+
+  def read_TypeConnectOptions
+    ConnectOptions.new(
+      host: read_string,
+      port: read_u16,
+      client_id: read_string,
+      version: read_TypeMqttVersion,
+      clean_start: read_bool,
+      keep_alive_secs: read_u16,
+      username: read_Optionalstring,
+      password: read_Optionalbytes,
+      will: read_OptionalTypeWillOptions,
+      connect_timeout_secs: read_u32,
+      operation_timeout_secs: read_u32,
+      auto_reconnect: read_bool,
+      reconnect_backoff_secs: read_u32,
+      reconnect_max_backoff_secs: read_u32,
+      tls: read_OptionalTypeTlsOptions,
+      max_packet_size: read_u32,
+      auth_method: read_Optionalstring,
+      auth_data: read_Optionalbytes
+    )
+  end
+
+  # The Record type ConnectResult.
+
+  def read_TypeConnectResult
+    ConnectResult.new(
+      session_present: read_bool,
+      reason_code: read_u8
+    )
+  end
+
+  # The Record type MqttMessage.
+
+  def read_TypeMqttMessage
+    MqttMessage.new(
+      topic: read_string,
+      payload: read_bytes,
+      qos: read_TypeQoS,
+      retain: read_bool
+    )
+  end
+
+  # The Record type SubscribeResult.
+
+  def read_TypeSubscribeResult
+    SubscribeResult.new(
+      reason_code: read_u8
+    )
+  end
+
+  # The Record type TlsOptions.
+
+  def read_TypeTlsOptions
+    TlsOptions.new(
+      ca_cert_pem: read_Optionalbytes,
+      client_cert_pem: read_Optionalbytes,
+      client_key_pem: read_Optionalbytes,
+      insecure_skip_certificate_verification: read_bool
+    )
+  end
+
+  # The Record type WillOptions.
+
+  def read_TypeWillOptions
+    WillOptions.new(
+      topic: read_string,
+      payload: read_bytes,
+      qos: read_TypeQoS,
+      retain: read_bool
+    )
+  end
+
+  
+
+  
+
+  # The Error type MqttError
+
+  def read_TypeMqttError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return MqttError::MalformedPacket.new(
+        read_string()
+      )
+    end
+    if variant == 2
+      return MqttError::Protocol.new(
+        read_string()
+      )
+    end
+    if variant == 3
+      return MqttError::Io.new(
+        read_string()
+      )
+    end
+    if variant == 4
+      return MqttError::ConnectionRefused.new(
+        read_string()
+      )
+    end
+    if variant == 5
+      return MqttError::NotConnected.new(
+        read_string()
+      )
+    end
+    if variant == 6
+      return MqttError::PacketTooLarge.new(
+        read_string()
+      )
+    end
+    if variant == 7
+      return MqttError::AlreadyConnected.new(
+        read_string()
+      )
+    end
+    if variant == 8
+      return MqttError::Timeout.new(
+        read_string()
+      )
+    end
+    if variant == 9
+      return MqttError::Session.new(
+        read_string()
+      )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeMqttError'
+  end
+  
+
+  
+  
+  # The Enum type MqttVersion.
+
+  def read_TypeMqttVersion
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return MqttVersion::V311
+    end
+    if variant == 2
+      return MqttVersion::V5
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeMqttVersion'
+  end
+
+  
+
+  
+  
+  # The Enum type QoS.
+
+  def read_TypeQoS
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return QoS::AT_MOST_ONCE
+    end
+    if variant == 2
+      return QoS::AT_LEAST_ONCE
+    end
+    if variant == 3
+      return QoS::EXACTLY_ONCE
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeQoS'
+  end
+
+  
+
+  
+  # The Optional<T> type for string.
+
+  def read_Optionalstring
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_string
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalstring'
+    end
+  end
+
+  
+  # The Optional<T> type for bytes.
+
+  def read_Optionalbytes
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_bytes
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalbytes'
+    end
+  end
+
+  
+  # The Optional<T> type for TypeMqttMessage.
+
+  def read_OptionalTypeMqttMessage
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_TypeMqttMessage
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeMqttMessage'
+    end
+  end
+
+  
+  # The Optional<T> type for TypeTlsOptions.
+
+  def read_OptionalTypeTlsOptions
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_TypeTlsOptions
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeTlsOptions'
+    end
+  end
+
+  
+  # The Optional<T> type for TypeWillOptions.
+
+  def read_OptionalTypeWillOptions
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_TypeWillOptions
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeWillOptions'
+    end
+  end
+
+  
+
+  def unpack_from(size, format)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    value = @rbuf.data.get_bytes(@offset, size).unpack format
+
+    @offset += size
+
+    # TODO: verify this
+    raise 'more than one element!!!' if value.size > 1
+
+    value[0]
+  end
+end
+
+private_constant :RustBufferStream
+  
+# Helper for structured writing of values into a RustBuffer.
+class RustBufferBuilder
+  def initialize
+    @rust_buf = RustBuffer.alloc 16
+    @rust_buf.len = 0
+  end
+
+  def finalize
+    rbuf = @rust_buf
+
+    @rust_buf = nil
+
+    rbuf
+  end
+
+  def discard
+    return if @rust_buf.nil?
+
+    rbuf = finalize
+    rbuf.free
+  end
+
+  def write(value)
+    reserve(value.bytes.size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, value.bytes
+    end
+  end
+
+  def write_u8(v)
+    v = ::MqttClient::uniffi_in_range(v, "u8", 0, 2**8)
+    pack_into(1, 'c', v)
+  end
+
+  def write_u16(v)
+    v = ::MqttClient::uniffi_in_range(v, "u16", 0, 2**16)
+    pack_into(2, 'S>', v)
+  end
+
+  def write_u32(v)
+    v = ::MqttClient::uniffi_in_range(v, "u32", 0, 2**32)
+    pack_into(4, 'L>', v)
+  end
+
+  def write_bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  def write_string(v)
+    v = ::MqttClient::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  def write_bytes(v)
+    v = ::MqttClient::uniffi_bytes(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Object type MqttAuthHandler.
+
+  def write_TypeMqttAuthHandler(obj)
+    handle = MqttAuthHandler.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type MqttClient.
+
+  def write_TypeMqttClient(obj)
+    handle = MqttClient.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type MqttMessageListener.
+
+  def write_TypeMqttMessageListener(obj)
+    handle = MqttMessageListener.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Record type ConnectOptions.
+
+  def write_TypeConnectOptions(v)
+    self.write_string(v.host)
+    self.write_u16(v.port)
+    self.write_string(v.client_id)
+    self.write_TypeMqttVersion(v.version)
+    self.write_bool(v.clean_start)
+    self.write_u16(v.keep_alive_secs)
+    self.write_Optionalstring(v.username)
+    self.write_Optionalbytes(v.password)
+    self.write_OptionalTypeWillOptions(v.will)
+    self.write_u32(v.connect_timeout_secs)
+    self.write_u32(v.operation_timeout_secs)
+    self.write_bool(v.auto_reconnect)
+    self.write_u32(v.reconnect_backoff_secs)
+    self.write_u32(v.reconnect_max_backoff_secs)
+    self.write_OptionalTypeTlsOptions(v.tls)
+    self.write_u32(v.max_packet_size)
+    self.write_Optionalstring(v.auth_method)
+    self.write_Optionalbytes(v.auth_data)
+  end
+
+  # The Record type ConnectResult.
+
+  def write_TypeConnectResult(v)
+    self.write_bool(v.session_present)
+    self.write_u8(v.reason_code)
+  end
+
+  # The Record type MqttMessage.
+
+  def write_TypeMqttMessage(v)
+    self.write_string(v.topic)
+    self.write_bytes(v.payload)
+    self.write_TypeQoS(v.qos)
+    self.write_bool(v.retain)
+  end
+
+  # The Record type SubscribeResult.
+
+  def write_TypeSubscribeResult(v)
+    self.write_u8(v.reason_code)
+  end
+
+  # The Record type TlsOptions.
+
+  def write_TypeTlsOptions(v)
+    self.write_Optionalbytes(v.ca_cert_pem)
+    self.write_Optionalbytes(v.client_cert_pem)
+    self.write_Optionalbytes(v.client_key_pem)
+    self.write_bool(v.insecure_skip_certificate_verification)
+  end
+
+  # The Record type WillOptions.
+
+  def write_TypeWillOptions(v)
+    self.write_string(v.topic)
+    self.write_bytes(v.payload)
+    self.write_TypeQoS(v.qos)
+    self.write_bool(v.retain)
+  end
+
+  # The Error type MqttError - write for callback error returns.
+
+  def write_TypeMqttError(v)
+    if v.is_a?(MqttError::MalformedPacket)
+      pack_into 4, 'l>', 1
+      return
+    end
+    if v.is_a?(MqttError::Protocol)
+      pack_into 4, 'l>', 2
+      return
+    end
+    if v.is_a?(MqttError::Io)
+      pack_into 4, 'l>', 3
+      return
+    end
+    if v.is_a?(MqttError::ConnectionRefused)
+      pack_into 4, 'l>', 4
+      return
+    end
+    if v.is_a?(MqttError::NotConnected)
+      pack_into 4, 'l>', 5
+      return
+    end
+    if v.is_a?(MqttError::PacketTooLarge)
+      pack_into 4, 'l>', 6
+      return
+    end
+    if v.is_a?(MqttError::AlreadyConnected)
+      pack_into 4, 'l>', 7
+      return
+    end
+    if v.is_a?(MqttError::Timeout)
+      pack_into 4, 'l>', 8
+      return
+    end
+    if v.is_a?(MqttError::Session)
+      pack_into 4, 'l>', 9
+      return
+    end
+  end
+  
+
+  # The Enum type MqttVersion.
+
+  def write_TypeMqttVersion(v)
+    if v == MqttVersion::V311
+      pack_into(4, 'l>', 1)
+    end
+    if v == MqttVersion::V5
+      pack_into(4, 'l>', 2)
+    end
+ end
+  
+
+  # The Enum type QoS.
+
+  def write_TypeQoS(v)
+    if v == QoS::AT_MOST_ONCE
+      pack_into(4, 'l>', 1)
+    end
+    if v == QoS::AT_LEAST_ONCE
+      pack_into(4, 'l>', 2)
+    end
+    if v == QoS::EXACTLY_ONCE
+      pack_into(4, 'l>', 3)
+    end
+ end
+  
+
+  # The Optional<T> type for string.
+
+  def write_Optionalstring(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_string(v)
+    end
+  end
+
+  # The Optional<T> type for bytes.
+
+  def write_Optionalbytes(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_bytes(v)
+    end
+  end
+
+  # The Optional<T> type for TypeMqttMessage.
+
+  def write_OptionalTypeMqttMessage(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeMqttMessage(v)
+    end
+  end
+
+  # The Optional<T> type for TypeTlsOptions.
+
+  def write_OptionalTypeTlsOptions(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeTlsOptions(v)
+    end
+  end
+
+  # The Optional<T> type for TypeWillOptions.
+
+  def write_OptionalTypeWillOptions(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeWillOptions(v)
+    end
+  end
+
+  
+
+  private
+
+  def reserve(num_bytes)
+    if @rust_buf.len + num_bytes > @rust_buf.capacity
+      @rust_buf = RustBuffer.reserve(@rust_buf, num_bytes)
+    end
+
+    yield
+
+    @rust_buf.len += num_bytes
+  end
+
+  def pack_into(size, format, value)
+    reserve(size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, [value].pack(format).bytes
+    end
+  end
+end
+
+private_constant :RustBufferBuilder
+
+  # Error definitions
+  class RustCallStatus < FFI::Struct
+  layout :code,    :int8,
+         :error_buf, RustBuffer
+
+  def code
+    self[:code]
+  end
+
+  def error_buf
+    self[:error_buf]
+  end
+
+  def to_s
+    "RustCallStatus(code=#{self[:code]})"
+  end
+end
+
+# These match the values from the uniffi::rustcalls module
+CALL_SUCCESS = 0
+CALL_ERROR = 1
+CALL_PANIC = 2
+
+
+class MqttError
+    MalformedPacket = Class.new StandardError
+    Protocol = Class.new StandardError
+    Io = Class.new StandardError
+    ConnectionRefused = Class.new StandardError
+    NotConnected = Class.new StandardError
+    PacketTooLarge = Class.new StandardError
+    AlreadyConnected = Class.new StandardError
+    Timeout = Class.new StandardError
+    Session = Class.new StandardError
+
+end
+
+
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+MqttError => :read_TypeMqttError,
+}
+
+private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
+                 :RustCallStatus
+
+def self.consume_buffer_into_error(error_module, rust_buffer)
+  rust_buffer.consumeWithStream do |stream|
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module] ||
+                    ERROR_MODULE_TO_READER_METHOD[error_module.name&.split('::')&.last]
+    return stream.send(reader_method)
+  end
+end
+
+class InternalError < StandardError
+end
+
+def self.rust_call(fn_name, *args)
+  # Call a rust function
+  rust_call_with_error(nil, fn_name, *args)
+end
+
+def self.rust_call_with_error(error_module, fn_name, *args)
+  # Call a rust function and handle errors
+  #
+  # Use this when the rust function returns a Result<>.  error_module must be the error_module that corresponds to that Result.
+
+
+  # Note: RustCallStatus.new zeroes out the struct, which is exactly what we
+  # want to pass to Rust (code=0, error_buf=RustBuffer(len=0, capacity=0,
+  # data=NULL))
+  status = RustCallStatus.new
+  args << status
+
+  result = UniFFILib.public_send(fn_name, *args)
+
+  case status.code
+  when CALL_SUCCESS
+    result
+  when CALL_ERROR
+    if error_module.nil?
+      status.error_buf.free
+      raise InternalError, "CALL_ERROR with no error_module set"
+    else
+      raise consume_buffer_into_error(error_module, status.error_buf)
+    end
+  when CALL_PANIC
+    # When the rust code sees a panic, it tries to construct a RustBuffer
+    # with the message.  But if that code panics, then it just sends back
+    # an empty buffer.
+    if status.error_buf.len > 0
+      raise InternalError, status.error_buf.consume_into_string
+    else
+      raise InternalError, "Rust panic"
+    end
+  else
+    raise InternalError, "Unknown call status: #{status.code}"
+  end
+end
+
+private_class_method :consume_buffer_into_error
+
+  # This is how we find and load the dynamic library provided by the component.
+# For now we just look it up by name.
+module UniFFILib
+  extend FFI::Library
+
+  
+  ffi_lib File.expand_path("native/#{FFI.map_library_name('mqtt_client')}", __dir__)
+  
+
+  # Define FFI callback types and structs (vtables, etc.)
+  
+  callback :RustFutureContinuationCallback,
+    [:uint64, :int8, ],
+    :void
+  
+  callback :ForeignFutureDroppedCallback,
+    [:uint64, ],
+    :void
+  
+  callback :CallbackInterfaceFree,
+    [:uint64, ],
+    :void
+  
+  callback :CallbackInterfaceClone,
+    [:uint64, ],
+    :uint64
+  
+  class ForeignFutureDroppedCallbackStruct < FFI::Struct
+    layout(
+      :handle, :uint64,
+      :free, :ForeignFutureDroppedCallback
+    )
+  end
+  
+  class ForeignFutureResultU8 < FFI::Struct
+    layout(
+      :return_value, :uint8,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU8,
+    [:uint64, ForeignFutureResultU8.by_value, ],
+    :void
+  
+  class ForeignFutureResultI8 < FFI::Struct
+    layout(
+      :return_value, :int8,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI8,
+    [:uint64, ForeignFutureResultI8.by_value, ],
+    :void
+  
+  class ForeignFutureResultU16 < FFI::Struct
+    layout(
+      :return_value, :uint16,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU16,
+    [:uint64, ForeignFutureResultU16.by_value, ],
+    :void
+  
+  class ForeignFutureResultI16 < FFI::Struct
+    layout(
+      :return_value, :int16,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI16,
+    [:uint64, ForeignFutureResultI16.by_value, ],
+    :void
+  
+  class ForeignFutureResultU32 < FFI::Struct
+    layout(
+      :return_value, :uint32,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU32,
+    [:uint64, ForeignFutureResultU32.by_value, ],
+    :void
+  
+  class ForeignFutureResultI32 < FFI::Struct
+    layout(
+      :return_value, :int32,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI32,
+    [:uint64, ForeignFutureResultI32.by_value, ],
+    :void
+  
+  class ForeignFutureResultU64 < FFI::Struct
+    layout(
+      :return_value, :uint64,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteU64,
+    [:uint64, ForeignFutureResultU64.by_value, ],
+    :void
+  
+  class ForeignFutureResultI64 < FFI::Struct
+    layout(
+      :return_value, :int64,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteI64,
+    [:uint64, ForeignFutureResultI64.by_value, ],
+    :void
+  
+  class ForeignFutureResultF32 < FFI::Struct
+    layout(
+      :return_value, :float,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteF32,
+    [:uint64, ForeignFutureResultF32.by_value, ],
+    :void
+  
+  class ForeignFutureResultF64 < FFI::Struct
+    layout(
+      :return_value, :double,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteF64,
+    [:uint64, ForeignFutureResultF64.by_value, ],
+    :void
+  
+  class ForeignFutureResultRustBuffer < FFI::Struct
+    layout(
+      :return_value, RustBuffer.by_value,
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteRustBuffer,
+    [:uint64, ForeignFutureResultRustBuffer.by_value, ],
+    :void
+  
+  class ForeignFutureResultVoid < FFI::Struct
+    layout(
+      :call_status, RustCallStatus
+    )
+  end
+  
+  callback :ForeignFutureCompleteVoid,
+    [:uint64, ForeignFutureResultVoid.by_value, ],
+    :void
+  
+  callback :CallbackInterfaceMqttAuthHandlerMethod0,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  callback :CallbackInterfaceMqttMessageListenerMethod0,
+    [:uint64, RustBuffer.by_value, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  callback :CallbackInterfaceMqttMessageListenerMethod1,
+    [:uint64, RustBuffer.by_value, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  class VTableCallbackInterfaceMqttAuthHandler < FFI::Struct
+    layout(
+      :uniffi_free, :CallbackInterfaceFree,
+      :uniffi_clone, :CallbackInterfaceClone,
+      :respond, :CallbackInterfaceMqttAuthHandlerMethod0
+    )
+  end
+  
+  class VTableCallbackInterfaceMqttMessageListener < FFI::Struct
+    layout(
+      :uniffi_free, :CallbackInterfaceFree,
+      :uniffi_clone, :CallbackInterfaceClone,
+      :on_message, :CallbackInterfaceMqttMessageListenerMethod0,
+      :on_disconnected, :CallbackInterfaceMqttMessageListenerMethod1
+    )
+  end
+  
+  attach_function :uniffi_mqtt_client_fn_clone_mqttclient,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_free_mqttclient,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_constructor_mqttclient_new,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_connect,
+    [:uint64, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_disconnect,
+    [:uint64, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_enable_message_queue,
+    [:uint64, :uint32, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_is_connected,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_last_disconnect_reason,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_next_message,
+    [:uint64, :uint32, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_publish,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :int8, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_set_auth_handler,
+    [:uint64, :uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_set_message_listener,
+    [:uint64, :uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_subscribe,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttclient_unsubscribe,
+    [:uint64, RustBuffer.by_value, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_clone_mqttauthhandler,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_free_mqttauthhandler,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_init_callback_vtable_mqttauthhandler,
+    [VTableCallbackInterfaceMqttAuthHandler.by_ref, ],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttauthhandler_respond,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_mqtt_client_fn_clone_mqttmessagelistener,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_client_fn_free_mqttmessagelistener,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_init_callback_vtable_mqttmessagelistener,
+    [VTableCallbackInterfaceMqttMessageListener.by_ref, ],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttmessagelistener_on_message,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_fn_method_mqttmessagelistener_on_disconnected,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :ffi_mqtt_client_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_client_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_client_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :ffi_mqtt_client_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_u8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_u8,
+    [:uint64, RustCallStatus.by_ref],
+    :uint8
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_i8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_i8,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_u16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_u16,
+    [:uint64, RustCallStatus.by_ref],
+    :uint16
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_i16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_i16,
+    [:uint64, RustCallStatus.by_ref],
+    :int16
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_u32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_u32,
+    [:uint64, RustCallStatus.by_ref],
+    :uint32
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_i32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_i32,
+    [:uint64, RustCallStatus.by_ref],
+    :int32
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_u64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_u64,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_i64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_i64,
+    [:uint64, RustCallStatus.by_ref],
+    :int64
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_f32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_f32,
+    [:uint64, RustCallStatus.by_ref],
+    :float
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_f64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_f64,
+    [:uint64, RustCallStatus.by_ref],
+    :double
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_rust_buffer,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_rust_buffer,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_client_rust_future_poll_void,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_cancel_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_free_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_client_rust_future_complete_void,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_connect,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_disconnect,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_enable_message_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_is_connected,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_last_disconnect_reason,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_next_message,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_publish,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_set_auth_handler,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_set_message_listener,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_subscribe,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttclient_unsubscribe,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttauthhandler_respond,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttmessagelistener_on_message,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_method_mqttmessagelistener_on_disconnected,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_client_checksum_constructor_mqttclient_new,
+    [],
+    :uint16
+  
+  attach_function :ffi_mqtt_client_uniffi_contract_version,
+    [],
+    :uint32
+  
+end
+  # RustFuture poll codes
+UNIFFI_RUST_FUTURE_POLL_READY = 0
+UNIFFI_RUST_FUTURE_POLL_WAKE = 1
+
+# Handle map for storing write-end IO objects used by the continuation callbacks.
+UNIFFI_ASYNC_HANDLE_MAP = UniffiHandleMap.new
+
+# Continuation callback for async functions.
+# Called by Rust when the future is ready to make progress.
+# Writes the poll code to the pipe so the waiting thread/fiber can continue.
+#
+# Exceptions must never escape this Proc.
+# Rust invokes it directly via FFI, so any unhandled Ruby exception would be caught
+# by Ruby-FFI, which swallows it (prints a warning) and returns a garbage value to Rust.
+# The poll code Rust receives would be invalid, causing the Ruby polling loop to
+# never see POLL_READY and block forever.
+UNIFFI_CONTINUATION_CALLBACK = Proc.new do |data, poll_code|
+  begin
+    wr = UNIFFI_ASYNC_HANDLE_MAP.get data
+
+    # This can only be blocking if pipe if full. Rust will never try to call continuation
+    # callback more than once (so will not fill it up), hence this call should never block.
+    wr.putc poll_code
+  rescue Exception
+    # Swallow exception. A leak or a hang is better than a hard VM segfault.
+  end
+end
+
+# Poll a Rust future to completion.
+#
+# This works both with and without a Fiber::Scheduler:
+# - Without scheduler: wait_readable blocks with a timeout, releasing the GVL
+#   so the callback can fire from foreign threads (works around MRI limitation
+#   where rb_thread_call_with_gvl cannot wake up threads in indefinite sleep).
+# - With scheduler: wait_readable hooks into io_wait, yielding the fiber.
+#
+# cancel_fn is called in the ensure block when exception interrupts an in-flight poll.
+# This guarantees Rust fires the continuation callback so the handle-map entry is released
+# and the pipe is drained before we free the future.
+def self.uniffi_rust_call_async(rust_future, poll_fn, cancel_fn, complete_fn, free_fn, lift_func, error_ffi_converter)
+  rd = wr = nil
+  handle = nil
+  poll_in_flight = false
+
+  begin
+    rd, wr = IO.pipe
+    wr.sync = true # avoid buffering and delayed read for rd.wait_readable
+    handle = UNIFFI_ASYNC_HANDLE_MAP.insert wr
+
+    loop do
+      poll_in_flight = true
+      UniFFILib.public_send(poll_fn, rust_future, UNIFFI_CONTINUATION_CALLBACK, handle)
+
+      # Blocks until the continuation callback writes to the pipe.
+      # Releases the GVL so the callback can fire from foreign threads.
+      # With a Fiber::Scheduler, this hooks into io_wait for non-blocking concurrency.
+      rd.wait_readable
+      poll_code = rd.getbyte
+      poll_in_flight = false
+
+      break if poll_code == UNIFFI_RUST_FUTURE_POLL_READY
+    end
+
+    result = if error_ffi_converter.nil?
+      ::MqttClient.rust_call(complete_fn, rust_future)
+    else
+      ::MqttClient.rust_call_with_error(error_ffi_converter, complete_fn, rust_future)
+    end
+
+    lift_func.call(result)
+  ensure
+    # Defer any further Thread#raise / Timeout during cleanup so all steps execute
+    # automatically. Without this, a second raise during wait_readable(0.5) would skip
+    # handle-map removal, pipe close, and free_fn - leaking FDs and Rust memory.
+    Thread.handle_interrupt(Exception => :never) do
+      if poll_in_flight
+        # An exception interrupted an in-flight poll. Cancel and drain the byte
+        # the continuation callback will write so we don't leak the pipe.
+        UniFFILib.public_send(cancel_fn, rust_future)
+        # rd.wait_readable may time out and return nil if the poll was never actually sent
+        # (raise landed between poll_in_flight=true and the FFI call).
+        if rd.wait_readable(0.5)
+          rd.getbyte
+        end
+      end
+
+      # Remove handle first so any late-firing callback's `get` raises (swallowed by rescue).
+      UNIFFI_ASYNC_HANDLE_MAP.remove(handle) rescue nil if handle
+      rd&.close rescue nil
+      wr&.close rescue nil
+      UniFFILib.public_send(free_fn, rust_future)
+    end
+  end
+end
+  # Base class for callback interface FfiConverters.
+# Stores Ruby callback objects in a handle map, and converts to/from integer handles.
+
+class CallbackInterfaceFfiConverter
+  attr_reader :handle_map
+
+  def initialize
+    @handle_map = UniffiHandleMap.new
+  end
+
+  def lift(handle)
+    @handle_map.get handle
+  end
+
+  def lower(cb)
+    @handle_map.insert cb
+  end
+end
+
+private_constant :CallbackInterfaceFfiConverter
+
+  # Custom type definitions.
+
+  # Public interface members begin here.
+
+  
+  
+  
+  
+
+class MqttVersion
+  V311 = 0
+  V5 = 1
+  
+end
+
+
+  
+  
+  
+
+class QoS
+  AT_MOST_ONCE = 0
+  AT_LEAST_ONCE = 1
+  EXACTLY_ONCE = 2
+  
+end
+
+
+  
+  # Record type ConnectOptions
+class ConnectOptions
+  attr_reader :host, :port, :client_id, :version, :clean_start, :keep_alive_secs, :username, :password, :will, :connect_timeout_secs, :operation_timeout_secs, :auto_reconnect, :reconnect_backoff_secs, :reconnect_max_backoff_secs, :tls, :max_packet_size, :auth_method, :auth_data
+
+  def initialize(host:, port:, client_id:, version:, clean_start:, keep_alive_secs:, username:, password:, will:, connect_timeout_secs:, operation_timeout_secs:, auto_reconnect:, reconnect_backoff_secs:, reconnect_max_backoff_secs:, tls:, max_packet_size: 0, auth_method: nil, auth_data: nil)
+    @host = host
+    @port = port
+    @client_id = client_id
+    @version = version
+    @clean_start = clean_start
+    @keep_alive_secs = keep_alive_secs
+    @username = username
+    @password = password
+    @will = will
+    @connect_timeout_secs = connect_timeout_secs
+    @operation_timeout_secs = operation_timeout_secs
+    @auto_reconnect = auto_reconnect
+    @reconnect_backoff_secs = reconnect_backoff_secs
+    @reconnect_max_backoff_secs = reconnect_max_backoff_secs
+    @tls = tls
+    @max_packet_size = max_packet_size
+    @auth_method = auth_method
+    @auth_data = auth_data
+  end
+
+  def ==(other)
+    if @host != other.host
+      return false
+    end
+    if @port != other.port
+      return false
+    end
+    if @client_id != other.client_id
+      return false
+    end
+    if @version != other.version
+      return false
+    end
+    if @clean_start != other.clean_start
+      return false
+    end
+    if @keep_alive_secs != other.keep_alive_secs
+      return false
+    end
+    if @username != other.username
+      return false
+    end
+    if @password != other.password
+      return false
+    end
+    if @will != other.will
+      return false
+    end
+    if @connect_timeout_secs != other.connect_timeout_secs
+      return false
+    end
+    if @operation_timeout_secs != other.operation_timeout_secs
+      return false
+    end
+    if @auto_reconnect != other.auto_reconnect
+      return false
+    end
+    if @reconnect_backoff_secs != other.reconnect_backoff_secs
+      return false
+    end
+    if @reconnect_max_backoff_secs != other.reconnect_max_backoff_secs
+      return false
+    end
+    if @tls != other.tls
+      return false
+    end
+    if @max_packet_size != other.max_packet_size
+      return false
+    end
+    if @auth_method != other.auth_method
+      return false
+    end
+    if @auth_data != other.auth_data
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type ConnectResult
+class ConnectResult
+  attr_reader :session_present, :reason_code
+
+  def initialize(session_present:, reason_code:)
+    @session_present = session_present
+    @reason_code = reason_code
+  end
+
+  def ==(other)
+    if @session_present != other.session_present
+      return false
+    end
+    if @reason_code != other.reason_code
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type MqttMessage
+class MqttMessage
+  attr_reader :topic, :payload, :qos, :retain
+
+  def initialize(topic:, payload:, qos:, retain:)
+    @topic = topic
+    @payload = payload
+    @qos = qos
+    @retain = retain
+  end
+
+  def ==(other)
+    if @topic != other.topic
+      return false
+    end
+    if @payload != other.payload
+      return false
+    end
+    if @qos != other.qos
+      return false
+    end
+    if @retain != other.retain
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type SubscribeResult
+class SubscribeResult
+  attr_reader :reason_code
+
+  def initialize(reason_code:)
+    @reason_code = reason_code
+  end
+
+  def ==(other)
+    if @reason_code != other.reason_code
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type TlsOptions
+class TlsOptions
+  attr_reader :ca_cert_pem, :client_cert_pem, :client_key_pem, :insecure_skip_certificate_verification
+
+  def initialize(ca_cert_pem:, client_cert_pem:, client_key_pem:, insecure_skip_certificate_verification:)
+    @ca_cert_pem = ca_cert_pem
+    @client_cert_pem = client_cert_pem
+    @client_key_pem = client_key_pem
+    @insecure_skip_certificate_verification = insecure_skip_certificate_verification
+  end
+
+  def ==(other)
+    if @ca_cert_pem != other.ca_cert_pem
+      return false
+    end
+    if @client_cert_pem != other.client_cert_pem
+      return false
+    end
+    if @client_key_pem != other.client_key_pem
+      return false
+    end
+    if @insecure_skip_certificate_verification != other.insecure_skip_certificate_verification
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type WillOptions
+class WillOptions
+  attr_reader :topic, :payload, :qos, :retain
+
+  def initialize(topic:, payload:, qos:, retain:)
+    @topic = topic
+    @payload = payload
+    @qos = qos
+    @retain = retain
+  end
+
+  def ==(other)
+    if @topic != other.topic
+      return false
+    end
+    if @payload != other.payload
+      return false
+    end
+    if @qos != other.qos
+      return false
+    end
+    if @retain != other.retain
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+
+  
+
+  
+  class MqttClient
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      ::MqttClient.rust_call(
+        :uniffi_mqtt_client_fn_free_mqttclient,
+        handle
+      )
+    end
+  end
+  # A private helper for lowering instances into a raw handle.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self.uniffi_check_lower(inst)
+    if !inst.is_a? self
+      raise TypeError.new "Expected a MqttClient instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return ::MqttClient.rust_call(
+      :uniffi_mqtt_client_fn_clone_mqttclient,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+
+  def self.uniffi_lift(handle)
+    uniffi_allocate handle
+  end
+  def initialize(options)
+        options = options
+        RustBuffer.check_lower_TypeConnectOptions(options)
+    handle = ::MqttClient.rust_call(:uniffi_mqtt_client_fn_constructor_mqttclient_new,RustBuffer.alloc_from_TypeConnectOptions(options))
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  
+  def connect()
+    ::MqttClient.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_client_fn_method_mqttclient_connect(uniffi_clone_handle(),),
+      :ffi_mqtt_client_rust_future_poll_rust_buffer,
+      :ffi_mqtt_client_rust_future_cancel_rust_buffer,
+      :ffi_mqtt_client_rust_future_complete_rust_buffer,
+      :ffi_mqtt_client_rust_future_free_rust_buffer,
+      Proc.new { |v| v.consume_into_TypeConnectResult },
+    MqttError
+    )
+  end
+  
+  def disconnect()
+    ::MqttClient.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_client_fn_method_mqttclient_disconnect(uniffi_clone_handle(),),
+      :ffi_mqtt_client_rust_future_poll_void,
+      :ffi_mqtt_client_rust_future_cancel_void,
+      :ffi_mqtt_client_rust_future_complete_void,
+      :ffi_mqtt_client_rust_future_free_void,
+      Proc.new { |v| nil },
+    MqttError
+    )
+  end
+  def enable_message_queue(capacity)
+        capacity = ::MqttClient::uniffi_in_range(capacity, "u32", 0, 2**32)
+        
+      ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttclient_enable_message_queue,uniffi_clone_handle(),capacity)
+  end
+  
+  def is_connected()
+    result = ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttclient_is_connected,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def last_disconnect_reason()
+    result = ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttclient_last_disconnect_reason,uniffi_clone_handle(),)
+    return result.consume_into_Optionalstring
+  end
+  
+  def next_message(timeout_ms)
+        timeout_ms = ::MqttClient::uniffi_in_range(timeout_ms, "u32", 0, 2**32)
+        
+    ::MqttClient.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_client_fn_method_mqttclient_next_message(uniffi_clone_handle(),timeout_ms),
+      :ffi_mqtt_client_rust_future_poll_rust_buffer,
+      :ffi_mqtt_client_rust_future_cancel_rust_buffer,
+      :ffi_mqtt_client_rust_future_complete_rust_buffer,
+      :ffi_mqtt_client_rust_future_free_rust_buffer,
+      Proc.new { |v| v.consume_into_OptionalTypeMqttMessage },
+    nil
+    )
+  end
+  
+  def publish(topic, payload, qos, retain)
+        topic = ::MqttClient::uniffi_utf8(topic)
+        
+        payload = ::MqttClient::uniffi_bytes(payload)
+        
+        qos = qos
+        RustBuffer.check_lower_TypeQoS(qos)
+        retain = retain ? true : false
+        
+    ::MqttClient.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_client_fn_method_mqttclient_publish(uniffi_clone_handle(),RustBuffer.alloc_from_string(topic),RustBuffer.alloc_from_bytes(payload),RustBuffer.alloc_from_TypeQoS(qos),(retain ? 1 : 0)),
+      :ffi_mqtt_client_rust_future_poll_void,
+      :ffi_mqtt_client_rust_future_cancel_void,
+      :ffi_mqtt_client_rust_future_complete_void,
+      :ffi_mqtt_client_rust_future_free_void,
+      Proc.new { |v| nil },
+    MqttError
+    )
+  end
+  def set_auth_handler(handler)
+        handler = handler
+        (MqttAuthHandler.uniffi_check_lower handler)
+      ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttclient_set_auth_handler,uniffi_clone_handle(),(MqttAuthHandler.uniffi_lower handler))
+  end
+  
+  def set_message_listener(listener)
+        listener = listener
+        (MqttMessageListener.uniffi_check_lower listener)
+      ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttclient_set_message_listener,uniffi_clone_handle(),(MqttMessageListener.uniffi_lower listener))
+  end
+  
+  
+  def subscribe(topic_filter, qos)
+        topic_filter = ::MqttClient::uniffi_utf8(topic_filter)
+        
+        qos = qos
+        RustBuffer.check_lower_TypeQoS(qos)
+    ::MqttClient.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_client_fn_method_mqttclient_subscribe(uniffi_clone_handle(),RustBuffer.alloc_from_string(topic_filter),RustBuffer.alloc_from_TypeQoS(qos)),
+      :ffi_mqtt_client_rust_future_poll_rust_buffer,
+      :ffi_mqtt_client_rust_future_cancel_rust_buffer,
+      :ffi_mqtt_client_rust_future_complete_rust_buffer,
+      :ffi_mqtt_client_rust_future_free_rust_buffer,
+      Proc.new { |v| v.consume_into_TypeSubscribeResult },
+    MqttError
+    )
+  end
+  
+  def unsubscribe(topic_filter)
+        topic_filter = ::MqttClient::uniffi_utf8(topic_filter)
+        
+    ::MqttClient.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_client_fn_method_mqttclient_unsubscribe(uniffi_clone_handle(),RustBuffer.alloc_from_string(topic_filter)),
+      :ffi_mqtt_client_rust_future_poll_void,
+      :ffi_mqtt_client_rust_future_cancel_void,
+      :ffi_mqtt_client_rust_future_complete_void,
+      :ffi_mqtt_client_rust_future_free_void,
+      Proc.new { |v| nil },
+    MqttError
+    )
+  end
+  
+end
+  
+  class MqttAuthHandler
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      ::MqttClient.rust_call(
+        :uniffi_mqtt_client_fn_free_mqttauthhandler,
+        handle
+      )
+    end
+  end
+  # HandleMap for trait interface: stores Ruby-native objects keyed by odd handles.
+  @uniffi_handle_map = UniffiHandleMap.new
+
+  class << self
+    attr_reader :uniffi_handle_map
+  end
+
+  # For trait interfaces: check that the object is either a Rust-backed instance or
+  # responds to the required interface methods.
+  def self.uniffi_check_lower(inst)
+    if !inst.respond_to?(:respond)
+      raise TypeError.new "Expected a MqttAuthHandler instance or an object implementing the interface, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle
+    return ::MqttClient.rust_call(
+      :uniffi_mqtt_client_fn_clone_mqttauthhandler,
+      @handle
+    )
+  end
+
+  # For trait interfaces: lowering distinguishes between Rust-backed and Ruby-native instances.
+  def self.uniffi_lower(inst)
+    if inst.is_a?(self) && inst.instance_variable_defined?(:@handle)
+      inst.uniffi_clone_handle()
+    else
+      @uniffi_handle_map.insert(inst)
+    end
+  end
+
+  # For trait interfaces: lifting distinguishes even handles (Rust) from odd handles (Ruby).
+  def self.uniffi_lift(handle)
+    if (handle & 1) == 0
+      uniffi_allocate handle
+    else
+      @uniffi_handle_map.remove handle
+    end
+  end
+
+  
+
+  def respond(method, challenge)
+        method = ::MqttClient::uniffi_utf8(method)
+        
+        challenge = ::MqttClient::uniffi_bytes(challenge)
+        
+    result = ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttauthhandler_respond,uniffi_clone_handle(),RustBuffer.alloc_from_string(method),RustBuffer.alloc_from_bytes(challenge))
+    return result.consume_into_Optionalbytes
+  end
+  
+end
+
+
+# Trait interface vtable implementation for MqttAuthHandler.
+module UniffiCallbackInterfaceMqttAuthHandler
+  # Callback method for respond
+  RESPOND_CALLBACK = Proc.new do |uniffi_handle, method, challenge, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttAuthHandler.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.respond(
+        method.consume_into_string,
+        challenge.consume_into_bytes
+      )
+    end
+    write_return_value = Proc.new do |v|
+      lowered = RustBuffer.alloc_from_Optionalbytes(v)
+      # Write a RustBuffer struct into the out pointer
+      out_buf = RustBuffer.new uniffi_out_return
+      out_buf[:capacity] = lowered[:capacity]
+      out_buf[:len] = lowered[:len]
+      out_buf[:data] = lowered[:data]
+    end
+    ::MqttClient.uniffi_trait_interface_call(
+      uniffi_call_status,
+      make_call,
+      write_return_value,
+    )
+  end
+
+  # Free callback: removes the handle from the map.
+  UNIFFI_FREE_CALLBACK = Proc.new do |uniffi_handle|
+    MqttAuthHandler.uniffi_handle_map.remove uniffi_handle
+  end
+
+  # Clone callback: clones the handle in the map.
+  UNIFFI_CLONE_CALLBACK = Proc.new do |uniffi_handle|
+    MqttAuthHandler.uniffi_handle_map.clone_handle(uniffi_handle)
+  end
+
+  # Create the VTable struct instance.
+  UNIFFI_VTABLE = UniFFILib::VTableCallbackInterfaceMqttAuthHandler.new
+  UNIFFI_VTABLE[:uniffi_free] = UNIFFI_FREE_CALLBACK
+  UNIFFI_VTABLE[:uniffi_clone] = UNIFFI_CLONE_CALLBACK
+  UNIFFI_VTABLE[:respond] = RESPOND_CALLBACK
+
+  # Register the VTable with Rust.
+  UniFFILib.uniffi_mqtt_client_fn_init_callback_vtable_mqttauthhandler(UNIFFI_VTABLE)
+end
+  
+  class MqttMessageListener
+
+  # A private helper for initializing instances of the class from a raw handle,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self.uniffi_allocate(handle)
+    inst = allocate
+    inst.instance_variable_set :@handle, handle
+    ObjectSpace.define_finalizer(inst, uniffi_define_finalizer_by_handle(handle, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying handle.
+  def self.uniffi_define_finalizer_by_handle(handle, object_id)
+    Proc.new do |_id|
+      ::MqttClient.rust_call(
+        :uniffi_mqtt_client_fn_free_mqttmessagelistener,
+        handle
+      )
+    end
+  end
+  # HandleMap for trait interface: stores Ruby-native objects keyed by odd handles.
+  @uniffi_handle_map = UniffiHandleMap.new
+
+  class << self
+    attr_reader :uniffi_handle_map
+  end
+
+  # For trait interfaces: check that the object is either a Rust-backed instance or
+  # responds to the required interface methods.
+  def self.uniffi_check_lower(inst)
+    if !inst.respond_to?(:on_message)
+      raise TypeError.new "Expected a MqttMessageListener instance or an object implementing the interface, got #{inst}"
+    end
+    if !inst.respond_to?(:on_disconnected)
+      raise TypeError.new "Expected a MqttMessageListener instance or an object implementing the interface, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle
+    return ::MqttClient.rust_call(
+      :uniffi_mqtt_client_fn_clone_mqttmessagelistener,
+      @handle
+    )
+  end
+
+  # For trait interfaces: lowering distinguishes between Rust-backed and Ruby-native instances.
+  def self.uniffi_lower(inst)
+    if inst.is_a?(self) && inst.instance_variable_defined?(:@handle)
+      inst.uniffi_clone_handle()
+    else
+      @uniffi_handle_map.insert(inst)
+    end
+  end
+
+  # For trait interfaces: lifting distinguishes even handles (Rust) from odd handles (Ruby).
+  def self.uniffi_lift(handle)
+    if (handle & 1) == 0
+      uniffi_allocate handle
+    else
+      @uniffi_handle_map.remove handle
+    end
+  end
+
+  
+
+  def on_message(message)
+        message = message
+        RustBuffer.check_lower_TypeMqttMessage(message)
+      ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttmessagelistener_on_message,uniffi_clone_handle(),RustBuffer.alloc_from_TypeMqttMessage(message))
+  end
+  
+  def on_disconnected(reason)
+        reason = ::MqttClient::uniffi_utf8(reason)
+        
+      ::MqttClient.rust_call(:uniffi_mqtt_client_fn_method_mqttmessagelistener_on_disconnected,uniffi_clone_handle(),RustBuffer.alloc_from_string(reason))
+  end
+  
+  
+end
+
+
+# Trait interface vtable implementation for MqttMessageListener.
+module UniffiCallbackInterfaceMqttMessageListener
+  # Callback method for on_message
+  ON_MESSAGE_CALLBACK = Proc.new do |uniffi_handle, message, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttMessageListener.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.on_message(
+        message.consume_into_TypeMqttMessage
+      )
+    end
+    # No return value, so do nothing
+    write_return_value = Proc.new { |_v| }
+    ::MqttClient.uniffi_trait_interface_call(
+      uniffi_call_status,
+      make_call,
+      write_return_value,
+    )
+  end
+  # Callback method for on_disconnected
+  ON_DISCONNECTED_CALLBACK = Proc.new do |uniffi_handle, reason, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttMessageListener.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.on_disconnected(
+        reason.consume_into_string
+      )
+    end
+    # No return value, so do nothing
+    write_return_value = Proc.new { |_v| }
+    ::MqttClient.uniffi_trait_interface_call(
+      uniffi_call_status,
+      make_call,
+      write_return_value,
+    )
+  end
+
+  # Free callback: removes the handle from the map.
+  UNIFFI_FREE_CALLBACK = Proc.new do |uniffi_handle|
+    MqttMessageListener.uniffi_handle_map.remove uniffi_handle
+  end
+
+  # Clone callback: clones the handle in the map.
+  UNIFFI_CLONE_CALLBACK = Proc.new do |uniffi_handle|
+    MqttMessageListener.uniffi_handle_map.clone_handle(uniffi_handle)
+  end
+
+  # Create the VTable struct instance.
+  UNIFFI_VTABLE = UniFFILib::VTableCallbackInterfaceMqttMessageListener.new
+  UNIFFI_VTABLE[:uniffi_free] = UNIFFI_FREE_CALLBACK
+  UNIFFI_VTABLE[:uniffi_clone] = UNIFFI_CLONE_CALLBACK
+  UNIFFI_VTABLE[:on_message] = ON_MESSAGE_CALLBACK
+  UNIFFI_VTABLE[:on_disconnected] = ON_DISCONNECTED_CALLBACK
+
+  # Register the VTable with Rust.
+  UniFFILib.uniffi_mqtt_client_fn_init_callback_vtable_mqttmessagelistener(UNIFFI_VTABLE)
+end
+  
+
+  
+end
+