stem-mqtt-broker 0.6.1-aarch64-linux

data/lib/stem_mqtt_broker/mqtt_broker.rb

@@ -0,0 +1,2956 @@
+# 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 MqttBroker
+  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 ::MqttBroker.rust_call(:ffi_mqtt_broker_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return ::MqttBroker.rust_call(:ffi_mqtt_broker_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    ::MqttBroker.rust_call(:ffi_mqtt_broker_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 AuthRequest.
+
+  def self.check_lower_TypeAuthRequest(v)
+    
+    
+    RustBuffer.check_lower_Optionalstring(v.username)
+    RustBuffer.check_lower_Optionalbytes(v.password)
+  end
+
+  def self.alloc_from_TypeAuthRequest(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeAuthRequest(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeAuthRequest
+    consumeWithStream do |stream|
+      return stream.read_TypeAuthRequest
+    end
+  end
+
+  # The Record type BrokerTlsConfig.
+
+  def self.check_lower_TypeBrokerTlsConfig(v)
+    
+    
+    
+    RustBuffer.check_lower_Optionalbytes(v.client_ca_pem)
+  end
+
+  def self.alloc_from_TypeBrokerTlsConfig(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeBrokerTlsConfig(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeBrokerTlsConfig
+    consumeWithStream do |stream|
+      return stream.read_TypeBrokerTlsConfig
+    end
+  end
+
+  # The Record type EnhancedAuthStep.
+
+  def self.check_lower_TypeEnhancedAuthStep(v)
+    RustBuffer.check_lower_TypeEnhancedAuthOutcome(v.outcome)
+    
+  end
+
+  def self.alloc_from_TypeEnhancedAuthStep(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeEnhancedAuthStep(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeEnhancedAuthStep
+    consumeWithStream do |stream|
+      return stream.read_TypeEnhancedAuthStep
+    end
+  end
+
+  # The Record type MqttBrokerConfig.
+
+  def self.check_lower_TypeMqttBrokerConfig(v)
+    
+    
+    RustBuffer.check_lower_Optionalu16(v.ws_port)
+    
+    
+    RustBuffer.check_lower_TypeQoS(v.max_qos)
+    
+    
+    
+    RustBuffer.check_lower_OptionalTypeBrokerTlsConfig(v.tls)
+    
+    
+    
+  end
+
+  def self.alloc_from_TypeMqttBrokerConfig(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeMqttBrokerConfig(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeMqttBrokerConfig
+    consumeWithStream do |stream|
+      return stream.read_TypeMqttBrokerConfig
+    end
+  end
+
+  # The Enum type BrokerEvent.
+
+  def self.check_lower_TypeBrokerEvent(v)
+    if v.client_connected?
+        
+      return
+    end
+    if v.client_disconnected?
+        
+        
+      return
+    end
+    if v.message_published?
+        
+        
+        RustBuffer.check_lower_TypeQoS(v.qos)
+      return
+    end
+  end
+
+  def self.alloc_from_TypeBrokerEvent(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeBrokerEvent(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeBrokerEvent
+    consumeWithStream do |stream|
+      return stream.read_TypeBrokerEvent
+    end
+  end
+  
+
+  # The Enum type EnhancedAuthOutcome.
+
+  def self.check_lower_TypeEnhancedAuthOutcome(v)
+  end
+
+  def self.alloc_from_TypeEnhancedAuthOutcome(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeEnhancedAuthOutcome(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeEnhancedAuthOutcome
+    consumeWithStream do |stream|
+      return stream.read_TypeEnhancedAuthOutcome
+    end
+  end
+  
+
+  # Error enum - generate alloc_from for callback error serialization
+  def self.alloc_from_TypeMqttBrokerError(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeMqttBrokerError(v)
+      return builder.finalize
+    end
+  end
+
+  # Enum used as error - generate consume_into_ for use as a return value
+  def consume_into_TypeMqttBrokerError
+    consumeWithStream do |stream|
+      return stream.read_TypeMqttBrokerError
+    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 u16.
+
+  def self.check_lower_Optionalu16(v)
+    if !v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalu16(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalu16(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_Optionalu16
+    consumeWithStream do |stream|
+      return stream.read_Optionalu16
+    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 TypeAuthRequest.
+
+  def self.check_lower_OptionalTypeAuthRequest(v)
+    if !v.nil?
+      RustBuffer.check_lower_TypeAuthRequest(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeAuthRequest(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeAuthRequest(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_OptionalTypeAuthRequest
+    consumeWithStream do |stream|
+      return stream.read_OptionalTypeAuthRequest
+    end
+  end
+
+  # The Optional<T> type for TypeBrokerTlsConfig.
+
+  def self.check_lower_OptionalTypeBrokerTlsConfig(v)
+    if !v.nil?
+      RustBuffer.check_lower_TypeBrokerTlsConfig(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeBrokerTlsConfig(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeBrokerTlsConfig(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_OptionalTypeBrokerTlsConfig
+    consumeWithStream do |stream|
+      return stream.read_OptionalTypeBrokerTlsConfig
+    end
+  end
+
+  # The Optional<T> type for TypeBrokerEvent.
+
+  def self.check_lower_OptionalTypeBrokerEvent(v)
+    if !v.nil?
+      RustBuffer.check_lower_TypeBrokerEvent(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeBrokerEvent(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeBrokerEvent(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_OptionalTypeBrokerEvent
+    consumeWithStream do |stream|
+      return stream.read_OptionalTypeBrokerEvent
+    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_u16
+    unpack_from 2, 'S>'
+  end
+
+  def read_u32
+    unpack_from 4, 'L>'
+  end
+
+  def read_u64
+    unpack_from 8, 'Q>'
+  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 MqttAuthProvider.
+
+  def read_TypeMqttAuthProvider
+    handle = unpack_from 8, 'Q>'
+    return MqttAuthProvider.uniffi_lift(handle)
+  end
+
+  # The Object type MqttBroker.
+
+  def read_TypeMqttBroker
+    handle = unpack_from 8, 'Q>'
+    return MqttBroker.uniffi_lift(handle)
+  end
+
+  # The Object type MqttBrokerEventListener.
+
+  def read_TypeMqttBrokerEventListener
+    handle = unpack_from 8, 'Q>'
+    return MqttBrokerEventListener.uniffi_lift(handle)
+  end
+
+  # The Object type MqttEnhancedAuthProvider.
+
+  def read_TypeMqttEnhancedAuthProvider
+    handle = unpack_from 8, 'Q>'
+    return MqttEnhancedAuthProvider.uniffi_lift(handle)
+  end
+
+  # The Record type AuthRequest.
+
+  def read_TypeAuthRequest
+    AuthRequest.new(
+      id: read_u64,
+      client_id: read_string,
+      username: read_Optionalstring,
+      password: read_Optionalbytes
+    )
+  end
+
+  # The Record type BrokerTlsConfig.
+
+  def read_TypeBrokerTlsConfig
+    BrokerTlsConfig.new(
+      port: read_u16,
+      cert_pem: read_bytes,
+      key_pem: read_bytes,
+      client_ca_pem: read_Optionalbytes
+    )
+  end
+
+  # The Record type EnhancedAuthStep.
+
+  def read_TypeEnhancedAuthStep
+    EnhancedAuthStep.new(
+      outcome: read_TypeEnhancedAuthOutcome,
+      data: read_bytes
+    )
+  end
+
+  # The Record type MqttBrokerConfig.
+
+  def read_TypeMqttBrokerConfig
+    MqttBrokerConfig.new(
+      bind_address: read_string,
+      port: read_u16,
+      ws_port: read_Optionalu16,
+      allow_anonymous: read_bool,
+      max_clients: read_u32,
+      max_qos: read_TypeQoS,
+      max_retained_messages: read_u32,
+      max_queued_per_client: read_u32,
+      redelivery_interval_secs: read_u32,
+      tls: read_OptionalTypeBrokerTlsConfig,
+      max_packet_size: read_u32,
+      max_outbound_queue: read_u32,
+      session_expiry_secs: read_u32
+    )
+  end
+
+  
+  
+  # The Enum type BrokerEvent.
+
+  def read_TypeBrokerEvent
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return BrokerEvent::CLIENT_CONNECTED.new(
+            client_id: self.read_string()
+        )
+    end
+    if variant == 2
+        return BrokerEvent::CLIENT_DISCONNECTED.new(
+            client_id: self.read_string(),
+            reason: self.read_string()
+        )
+    end
+    if variant == 3
+        return BrokerEvent::MESSAGE_PUBLISHED.new(
+            client_id: self.read_string(),
+            topic: self.read_string(),
+            qos: self.read_TypeQoS()
+        )
+    end
+    raise InternalError, 'Unexpected variant tag for TypeBrokerEvent'
+  end
+
+  
+
+  
+  
+  # The Enum type EnhancedAuthOutcome.
+
+  def read_TypeEnhancedAuthOutcome
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return EnhancedAuthOutcome::CONTINUE
+    end
+    if variant == 2
+      return EnhancedAuthOutcome::SUCCESS
+    end
+    if variant == 3
+      return EnhancedAuthOutcome::FAILURE
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeEnhancedAuthOutcome'
+  end
+
+  
+
+  
+
+  
+
+  # The Error type MqttBrokerError
+
+  def read_TypeMqttBrokerError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return MqttBrokerError::AlreadyRunning.new(
+        read_string()
+      )
+    end
+    if variant == 2
+      return MqttBrokerError::Io.new(
+        read_string()
+      )
+    end
+    if variant == 3
+      return MqttBrokerError::Tls.new(
+        read_string()
+      )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeMqttBrokerError'
+  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 u16.
+
+  def read_Optionalu16
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_u16
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalu16'
+    end
+  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 TypeAuthRequest.
+
+  def read_OptionalTypeAuthRequest
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_TypeAuthRequest
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeAuthRequest'
+    end
+  end
+
+  
+  # The Optional<T> type for TypeBrokerTlsConfig.
+
+  def read_OptionalTypeBrokerTlsConfig
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_TypeBrokerTlsConfig
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeBrokerTlsConfig'
+    end
+  end
+
+  
+  # The Optional<T> type for TypeBrokerEvent.
+
+  def read_OptionalTypeBrokerEvent
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_TypeBrokerEvent
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeBrokerEvent'
+    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_u16(v)
+    v = ::MqttBroker::uniffi_in_range(v, "u16", 0, 2**16)
+    pack_into(2, 'S>', v)
+  end
+
+  def write_u32(v)
+    v = ::MqttBroker::uniffi_in_range(v, "u32", 0, 2**32)
+    pack_into(4, 'L>', v)
+  end
+
+  def write_u64(v)
+    v = ::MqttBroker::uniffi_in_range(v, "u64", 0, 2**64)
+    pack_into(8, 'Q>', v)
+  end
+
+  def write_bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  def write_string(v)
+    v = ::MqttBroker::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  def write_bytes(v)
+    v = ::MqttBroker::uniffi_bytes(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Object type MqttAuthProvider.
+
+  def write_TypeMqttAuthProvider(obj)
+    handle = MqttAuthProvider.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type MqttBroker.
+
+  def write_TypeMqttBroker(obj)
+    handle = MqttBroker.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type MqttBrokerEventListener.
+
+  def write_TypeMqttBrokerEventListener(obj)
+    handle = MqttBrokerEventListener.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type MqttEnhancedAuthProvider.
+
+  def write_TypeMqttEnhancedAuthProvider(obj)
+    handle = MqttEnhancedAuthProvider.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Record type AuthRequest.
+
+  def write_TypeAuthRequest(v)
+    self.write_u64(v.id)
+    self.write_string(v.client_id)
+    self.write_Optionalstring(v.username)
+    self.write_Optionalbytes(v.password)
+  end
+
+  # The Record type BrokerTlsConfig.
+
+  def write_TypeBrokerTlsConfig(v)
+    self.write_u16(v.port)
+    self.write_bytes(v.cert_pem)
+    self.write_bytes(v.key_pem)
+    self.write_Optionalbytes(v.client_ca_pem)
+  end
+
+  # The Record type EnhancedAuthStep.
+
+  def write_TypeEnhancedAuthStep(v)
+    self.write_TypeEnhancedAuthOutcome(v.outcome)
+    self.write_bytes(v.data)
+  end
+
+  # The Record type MqttBrokerConfig.
+
+  def write_TypeMqttBrokerConfig(v)
+    self.write_string(v.bind_address)
+    self.write_u16(v.port)
+    self.write_Optionalu16(v.ws_port)
+    self.write_bool(v.allow_anonymous)
+    self.write_u32(v.max_clients)
+    self.write_TypeQoS(v.max_qos)
+    self.write_u32(v.max_retained_messages)
+    self.write_u32(v.max_queued_per_client)
+    self.write_u32(v.redelivery_interval_secs)
+    self.write_OptionalTypeBrokerTlsConfig(v.tls)
+    self.write_u32(v.max_packet_size)
+    self.write_u32(v.max_outbound_queue)
+    self.write_u32(v.session_expiry_secs)
+  end
+
+  # The Enum type BrokerEvent.
+
+  def write_TypeBrokerEvent(v)
+    if v.client_connected?
+      pack_into(4, 'l>', 1)
+        self.write_string(v.client_id)
+    end
+    if v.client_disconnected?
+      pack_into(4, 'l>', 2)
+        self.write_string(v.client_id)
+        self.write_string(v.reason)
+    end
+    if v.message_published?
+      pack_into(4, 'l>', 3)
+        self.write_string(v.client_id)
+        self.write_string(v.topic)
+        self.write_TypeQoS(v.qos)
+    end
+ end
+  
+
+  # The Enum type EnhancedAuthOutcome.
+
+  def write_TypeEnhancedAuthOutcome(v)
+    if v == EnhancedAuthOutcome::CONTINUE
+      pack_into(4, 'l>', 1)
+    end
+    if v == EnhancedAuthOutcome::SUCCESS
+      pack_into(4, 'l>', 2)
+    end
+    if v == EnhancedAuthOutcome::FAILURE
+      pack_into(4, 'l>', 3)
+    end
+ end
+  
+
+  # The Error type MqttBrokerError - write for callback error returns.
+
+  def write_TypeMqttBrokerError(v)
+    if v.is_a?(MqttBrokerError::AlreadyRunning)
+      pack_into 4, 'l>', 1
+      return
+    end
+    if v.is_a?(MqttBrokerError::Io)
+      pack_into 4, 'l>', 2
+      return
+    end
+    if v.is_a?(MqttBrokerError::Tls)
+      pack_into 4, 'l>', 3
+      return
+    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 u16.
+
+  def write_Optionalu16(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_u16(v)
+    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 TypeAuthRequest.
+
+  def write_OptionalTypeAuthRequest(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeAuthRequest(v)
+    end
+  end
+
+  # The Optional<T> type for TypeBrokerTlsConfig.
+
+  def write_OptionalTypeBrokerTlsConfig(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeBrokerTlsConfig(v)
+    end
+  end
+
+  # The Optional<T> type for TypeBrokerEvent.
+
+  def write_OptionalTypeBrokerEvent(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeBrokerEvent(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 MqttBrokerError
+    AlreadyRunning = Class.new StandardError
+    Io = Class.new StandardError
+    Tls = Class.new StandardError
+
+end
+
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+MqttBrokerError => :read_TypeMqttBrokerError,
+}
+
+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_broker')}", __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 :CallbackInterfaceMqttAuthProviderMethod0,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  callback :CallbackInterfaceMqttBrokerEventListenerMethod0,
+    [:uint64, RustBuffer.by_value, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  callback :CallbackInterfaceMqttBrokerEventListenerMethod1,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  callback :CallbackInterfaceMqttBrokerEventListenerMethod2,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  callback :CallbackInterfaceMqttEnhancedAuthProviderMethod0,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :uint32, :pointer, RustCallStatus.by_ref],
+    :void
+  
+  class VTableCallbackInterfaceMqttAuthProvider < FFI::Struct
+    layout(
+      :uniffi_free, :CallbackInterfaceFree,
+      :uniffi_clone, :CallbackInterfaceClone,
+      :authenticate, :CallbackInterfaceMqttAuthProviderMethod0
+    )
+  end
+  
+  class VTableCallbackInterfaceMqttBrokerEventListener < FFI::Struct
+    layout(
+      :uniffi_free, :CallbackInterfaceFree,
+      :uniffi_clone, :CallbackInterfaceClone,
+      :on_client_connected, :CallbackInterfaceMqttBrokerEventListenerMethod0,
+      :on_client_disconnected, :CallbackInterfaceMqttBrokerEventListenerMethod1,
+      :on_message_published, :CallbackInterfaceMqttBrokerEventListenerMethod2
+    )
+  end
+  
+  class VTableCallbackInterfaceMqttEnhancedAuthProvider < FFI::Struct
+    layout(
+      :uniffi_free, :CallbackInterfaceFree,
+      :uniffi_clone, :CallbackInterfaceClone,
+      :step, :CallbackInterfaceMqttEnhancedAuthProviderMethod0
+    )
+  end
+  
+  attach_function :uniffi_mqtt_broker_fn_clone_mqttbroker,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_free_mqttbroker,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_constructor_mqttbroker_new,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_bound_port,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_bound_tls_port,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_bound_ws_port,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_client_count,
+    [:uint64, RustCallStatus.by_ref],
+    :uint32
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_enable_auth_queue,
+    [:uint64, :uint32, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_enable_event_queue,
+    [:uint64, :uint32, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_is_running,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_next_auth_request,
+    [:uint64, :uint32, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_next_event,
+    [:uint64, :uint32, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_resolve_auth_request,
+    [:uint64, :uint64, :int8, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_set_auth_provider,
+    [:uint64, :uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_set_enhanced_auth_provider,
+    [:uint64, :uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_set_event_listener,
+    [:uint64, :uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_start,
+    [:uint64, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbroker_stop,
+    [:uint64, ],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_clone_mqttauthprovider,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_free_mqttauthprovider,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_init_callback_vtable_mqttauthprovider,
+    [VTableCallbackInterfaceMqttAuthProvider.by_ref, ],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttauthprovider_authenticate,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :uniffi_mqtt_broker_fn_clone_mqttbrokereventlistener,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_free_mqttbrokereventlistener,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_init_callback_vtable_mqttbrokereventlistener,
+    [VTableCallbackInterfaceMqttBrokerEventListener.by_ref, ],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbrokereventlistener_on_client_connected,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbrokereventlistener_on_client_disconnected,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttbrokereventlistener_on_message_published,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_clone_mqttenhancedauthprovider,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_mqtt_broker_fn_free_mqttenhancedauthprovider,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_init_callback_vtable_mqttenhancedauthprovider,
+    [VTableCallbackInterfaceMqttEnhancedAuthProvider.by_ref, ],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_fn_method_mqttenhancedauthprovider_step,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, :uint32, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_broker_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_broker_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_broker_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_u8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_u8,
+    [:uint64, RustCallStatus.by_ref],
+    :uint8
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_i8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_i8,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_u16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_u16,
+    [:uint64, RustCallStatus.by_ref],
+    :uint16
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_i16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_i16,
+    [:uint64, RustCallStatus.by_ref],
+    :int16
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_u32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_u32,
+    [:uint64, RustCallStatus.by_ref],
+    :uint32
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_i32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_i32,
+    [:uint64, RustCallStatus.by_ref],
+    :int32
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_u64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_u64,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_i64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_i64,
+    [:uint64, RustCallStatus.by_ref],
+    :int64
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_f32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_f32,
+    [:uint64, RustCallStatus.by_ref],
+    :float
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_f64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_f64,
+    [:uint64, RustCallStatus.by_ref],
+    :double
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_rust_buffer,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_rust_buffer,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_mqtt_broker_rust_future_poll_void,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_cancel_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_free_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_mqtt_broker_rust_future_complete_void,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_bound_port,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_bound_tls_port,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_bound_ws_port,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_client_count,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_enable_auth_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_enable_event_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_is_running,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_next_auth_request,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_next_event,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_resolve_auth_request,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_set_auth_provider,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_set_enhanced_auth_provider,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_set_event_listener,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_start,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbroker_stop,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttauthprovider_authenticate,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbrokereventlistener_on_client_connected,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbrokereventlistener_on_client_disconnected,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttbrokereventlistener_on_message_published,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_method_mqttenhancedauthprovider_step,
+    [],
+    :uint16
+  
+  attach_function :uniffi_mqtt_broker_checksum_constructor_mqttbroker_new,
+    [],
+    :uint16
+  
+  attach_function :ffi_mqtt_broker_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?
+      ::MqttBroker.rust_call(complete_fn, rust_future)
+    else
+      ::MqttBroker.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 EnhancedAuthOutcome
+  CONTINUE = 0
+  SUCCESS = 1
+  FAILURE = 2
+  
+end
+
+
+  
+  
+  
+
+class QoS
+  AT_MOST_ONCE = 0
+  AT_LEAST_ONCE = 1
+  EXACTLY_ONCE = 2
+  
+end
+
+
+  
+  
+  
+  
+
+class BrokerEvent
+  def initialize
+    raise RuntimeError, 'BrokerEvent cannot be instantiated directly'
+  end
+
+
+  # Each enum variant is a nested class of the enum itself.
+  class CLIENT_CONNECTED < BrokerEvent
+    
+      attr_reader :client_id
+    
+    def initialize(client_id:
+      )
+        @client_id = client_id
+    end
+    def to_s
+      "BrokerEvent::CLIENT_CONNECTED"
+    end
+    def ==(other)
+      return false unless other.respond_to?(:client_connected?)
+      return false unless other.client_connected?
+        return false if @client_id != other.client_id
+      true
+    end
+
+    # For each variant, we have an `NAME?` method for easily checking
+    # whether an instance is that variant.
+    
+    def client_connected?
+      instance_of? BrokerEvent::CLIENT_CONNECTED
+    end
+    
+    def client_disconnected?
+      instance_of? BrokerEvent::CLIENT_DISCONNECTED
+    end
+    
+    def message_published?
+      instance_of? BrokerEvent::MESSAGE_PUBLISHED
+    end
+    
+  end
+  class CLIENT_DISCONNECTED < BrokerEvent
+    
+      attr_reader :client_id, :reason
+    
+    def initialize(client_id:
+      , reason:
+      )
+        @client_id = client_id
+        @reason = reason
+    end
+    def to_s
+      "BrokerEvent::CLIENT_DISCONNECTED"
+    end
+    def ==(other)
+      return false unless other.respond_to?(:client_disconnected?)
+      return false unless other.client_disconnected?
+        return false if @client_id != other.client_id
+        return false if @reason != other.reason
+      true
+    end
+
+    # For each variant, we have an `NAME?` method for easily checking
+    # whether an instance is that variant.
+    
+    def client_connected?
+      instance_of? BrokerEvent::CLIENT_CONNECTED
+    end
+    
+    def client_disconnected?
+      instance_of? BrokerEvent::CLIENT_DISCONNECTED
+    end
+    
+    def message_published?
+      instance_of? BrokerEvent::MESSAGE_PUBLISHED
+    end
+    
+  end
+  class MESSAGE_PUBLISHED < BrokerEvent
+    
+      attr_reader :client_id, :topic, :qos
+    
+    def initialize(client_id:
+      , topic:
+      , qos:
+      )
+        @client_id = client_id
+        @topic = topic
+        @qos = qos
+    end
+    def to_s
+      "BrokerEvent::MESSAGE_PUBLISHED"
+    end
+    def ==(other)
+      return false unless other.respond_to?(:message_published?)
+      return false unless other.message_published?
+        return false if @client_id != other.client_id
+        return false if @topic != other.topic
+        return false if @qos != other.qos
+      true
+    end
+
+    # For each variant, we have an `NAME?` method for easily checking
+    # whether an instance is that variant.
+    
+    def client_connected?
+      instance_of? BrokerEvent::CLIENT_CONNECTED
+    end
+    
+    def client_disconnected?
+      instance_of? BrokerEvent::CLIENT_DISCONNECTED
+    end
+    
+    def message_published?
+      instance_of? BrokerEvent::MESSAGE_PUBLISHED
+    end
+    
+  end
+  
+end
+
+
+  
+  # Record type AuthRequest
+class AuthRequest
+  attr_reader :id, :client_id, :username, :password
+
+  def initialize(id:, client_id:, username:, password:)
+    @id = id
+    @client_id = client_id
+    @username = username
+    @password = password
+  end
+
+  def ==(other)
+    if @id != other.id
+      return false
+    end
+    if @client_id != other.client_id
+      return false
+    end
+    if @username != other.username
+      return false
+    end
+    if @password != other.password
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type BrokerTlsConfig
+class BrokerTlsConfig
+  attr_reader :port, :cert_pem, :key_pem, :client_ca_pem
+
+  def initialize(port:, cert_pem:, key_pem:, client_ca_pem:)
+    @port = port
+    @cert_pem = cert_pem
+    @key_pem = key_pem
+    @client_ca_pem = client_ca_pem
+  end
+
+  def ==(other)
+    if @port != other.port
+      return false
+    end
+    if @cert_pem != other.cert_pem
+      return false
+    end
+    if @key_pem != other.key_pem
+      return false
+    end
+    if @client_ca_pem != other.client_ca_pem
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type EnhancedAuthStep
+class EnhancedAuthStep
+  attr_reader :outcome, :data
+
+  def initialize(outcome:, data:)
+    @outcome = outcome
+    @data = data
+  end
+
+  def ==(other)
+    if @outcome != other.outcome
+      return false
+    end
+    if @data != other.data
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type MqttBrokerConfig
+class MqttBrokerConfig
+  attr_reader :bind_address, :port, :ws_port, :allow_anonymous, :max_clients, :max_qos, :max_retained_messages, :max_queued_per_client, :redelivery_interval_secs, :tls, :max_packet_size, :max_outbound_queue, :session_expiry_secs
+
+  def initialize(bind_address:, port:, ws_port:, allow_anonymous:, max_clients:, max_qos:, max_retained_messages:, max_queued_per_client:, redelivery_interval_secs:, tls:, max_packet_size: 0, max_outbound_queue: 0, session_expiry_secs: 0)
+    @bind_address = bind_address
+    @port = port
+    @ws_port = ws_port
+    @allow_anonymous = allow_anonymous
+    @max_clients = max_clients
+    @max_qos = max_qos
+    @max_retained_messages = max_retained_messages
+    @max_queued_per_client = max_queued_per_client
+    @redelivery_interval_secs = redelivery_interval_secs
+    @tls = tls
+    @max_packet_size = max_packet_size
+    @max_outbound_queue = max_outbound_queue
+    @session_expiry_secs = session_expiry_secs
+  end
+
+  def ==(other)
+    if @bind_address != other.bind_address
+      return false
+    end
+    if @port != other.port
+      return false
+    end
+    if @ws_port != other.ws_port
+      return false
+    end
+    if @allow_anonymous != other.allow_anonymous
+      return false
+    end
+    if @max_clients != other.max_clients
+      return false
+    end
+    if @max_qos != other.max_qos
+      return false
+    end
+    if @max_retained_messages != other.max_retained_messages
+      return false
+    end
+    if @max_queued_per_client != other.max_queued_per_client
+      return false
+    end
+    if @redelivery_interval_secs != other.redelivery_interval_secs
+      return false
+    end
+    if @tls != other.tls
+      return false
+    end
+    if @max_packet_size != other.max_packet_size
+      return false
+    end
+    if @max_outbound_queue != other.max_outbound_queue
+      return false
+    end
+    if @session_expiry_secs != other.session_expiry_secs
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+
+  
+
+  
+  class MqttBroker
+
+  # 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|
+      ::MqttBroker.rust_call(
+        :uniffi_mqtt_broker_fn_free_mqttbroker,
+        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 MqttBroker instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return ::MqttBroker.rust_call(
+      :uniffi_mqtt_broker_fn_clone_mqttbroker,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+
+  def self.uniffi_lift(handle)
+    uniffi_allocate handle
+  end
+  def initialize(config)
+        config = config
+        RustBuffer.check_lower_TypeMqttBrokerConfig(config)
+    handle = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_constructor_mqttbroker_new,RustBuffer.alloc_from_TypeMqttBrokerConfig(config))
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def bound_port()
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_bound_port,uniffi_clone_handle(),)
+    return result.consume_into_Optionalu16
+  end
+  def bound_tls_port()
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_bound_tls_port,uniffi_clone_handle(),)
+    return result.consume_into_Optionalu16
+  end
+  def bound_ws_port()
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_bound_ws_port,uniffi_clone_handle(),)
+    return result.consume_into_Optionalu16
+  end
+  def client_count()
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_client_count,uniffi_clone_handle(),)
+    return result.to_i
+  end
+  def enable_auth_queue(capacity)
+        capacity = ::MqttBroker::uniffi_in_range(capacity, "u32", 0, 2**32)
+        
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_enable_auth_queue,uniffi_clone_handle(),capacity)
+  end
+  
+  def enable_event_queue(capacity)
+        capacity = ::MqttBroker::uniffi_in_range(capacity, "u32", 0, 2**32)
+        
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_enable_event_queue,uniffi_clone_handle(),capacity)
+  end
+  
+  def is_running()
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_is_running,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  
+  def next_auth_request(timeout_ms)
+        timeout_ms = ::MqttBroker::uniffi_in_range(timeout_ms, "u32", 0, 2**32)
+        
+    ::MqttBroker.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_broker_fn_method_mqttbroker_next_auth_request(uniffi_clone_handle(),timeout_ms),
+      :ffi_mqtt_broker_rust_future_poll_rust_buffer,
+      :ffi_mqtt_broker_rust_future_cancel_rust_buffer,
+      :ffi_mqtt_broker_rust_future_complete_rust_buffer,
+      :ffi_mqtt_broker_rust_future_free_rust_buffer,
+      Proc.new { |v| v.consume_into_OptionalTypeAuthRequest },
+    nil
+    )
+  end
+  
+  def next_event(timeout_ms)
+        timeout_ms = ::MqttBroker::uniffi_in_range(timeout_ms, "u32", 0, 2**32)
+        
+    ::MqttBroker.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_broker_fn_method_mqttbroker_next_event(uniffi_clone_handle(),timeout_ms),
+      :ffi_mqtt_broker_rust_future_poll_rust_buffer,
+      :ffi_mqtt_broker_rust_future_cancel_rust_buffer,
+      :ffi_mqtt_broker_rust_future_complete_rust_buffer,
+      :ffi_mqtt_broker_rust_future_free_rust_buffer,
+      Proc.new { |v| v.consume_into_OptionalTypeBrokerEvent },
+    nil
+    )
+  end
+  def resolve_auth_request(id, allow)
+        id = ::MqttBroker::uniffi_in_range(id, "u64", 0, 2**64)
+        
+        allow = allow ? true : false
+        
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_resolve_auth_request,uniffi_clone_handle(),id,(allow ? 1 : 0))
+    return 1 == result
+  end
+  def set_auth_provider(provider)
+        provider = provider
+        (MqttAuthProvider.uniffi_check_lower provider)
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_set_auth_provider,uniffi_clone_handle(),(MqttAuthProvider.uniffi_lower provider))
+  end
+  
+  def set_enhanced_auth_provider(provider)
+        provider = provider
+        (MqttEnhancedAuthProvider.uniffi_check_lower provider)
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_set_enhanced_auth_provider,uniffi_clone_handle(),(MqttEnhancedAuthProvider.uniffi_lower provider))
+  end
+  
+  def set_event_listener(listener)
+        listener = listener
+        (MqttBrokerEventListener.uniffi_check_lower listener)
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbroker_set_event_listener,uniffi_clone_handle(),(MqttBrokerEventListener.uniffi_lower listener))
+  end
+  
+  
+  def start()
+    ::MqttBroker.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_broker_fn_method_mqttbroker_start(uniffi_clone_handle(),),
+      :ffi_mqtt_broker_rust_future_poll_void,
+      :ffi_mqtt_broker_rust_future_cancel_void,
+      :ffi_mqtt_broker_rust_future_complete_void,
+      :ffi_mqtt_broker_rust_future_free_void,
+      Proc.new { |v| nil },
+    MqttBrokerError
+    )
+  end
+  
+  def stop()
+    ::MqttBroker.uniffi_rust_call_async(
+      UniFFILib.uniffi_mqtt_broker_fn_method_mqttbroker_stop(uniffi_clone_handle(),),
+      :ffi_mqtt_broker_rust_future_poll_void,
+      :ffi_mqtt_broker_rust_future_cancel_void,
+      :ffi_mqtt_broker_rust_future_complete_void,
+      :ffi_mqtt_broker_rust_future_free_void,
+      Proc.new { |v| nil },
+    MqttBrokerError
+    )
+  end
+  
+end
+  
+  class MqttAuthProvider
+
+  # 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|
+      ::MqttBroker.rust_call(
+        :uniffi_mqtt_broker_fn_free_mqttauthprovider,
+        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?(:authenticate)
+      raise TypeError.new "Expected a MqttAuthProvider instance or an object implementing the interface, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle
+    return ::MqttBroker.rust_call(
+      :uniffi_mqtt_broker_fn_clone_mqttauthprovider,
+      @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 authenticate(client_id, username, password)
+        client_id = ::MqttBroker::uniffi_utf8(client_id)
+        
+        username = (username ? ::MqttBroker::uniffi_utf8(username) : nil)
+        RustBuffer.check_lower_Optionalstring(username)
+        password = (password ? ::MqttBroker::uniffi_bytes(password) : nil)
+        RustBuffer.check_lower_Optionalbytes(password)
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttauthprovider_authenticate,uniffi_clone_handle(),RustBuffer.alloc_from_string(client_id),RustBuffer.alloc_from_Optionalstring(username),RustBuffer.alloc_from_Optionalbytes(password))
+    return 1 == result
+  end
+  
+end
+
+
+# Trait interface vtable implementation for MqttAuthProvider.
+module UniffiCallbackInterfaceMqttAuthProvider
+  # Callback method for authenticate
+  AUTHENTICATE_CALLBACK = Proc.new do |uniffi_handle, client_id, username, password, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttAuthProvider.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.authenticate(
+        client_id.consume_into_string,
+        username.consume_into_Optionalstring,
+        password.consume_into_Optionalbytes
+      )
+    end
+    write_return_value = Proc.new do |v|
+      lowered = (v ? 1 : 0)
+      uniffi_out_return.write_int8(lowered)
+    end
+    ::MqttBroker.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|
+    MqttAuthProvider.uniffi_handle_map.remove uniffi_handle
+  end
+
+  # Clone callback: clones the handle in the map.
+  UNIFFI_CLONE_CALLBACK = Proc.new do |uniffi_handle|
+    MqttAuthProvider.uniffi_handle_map.clone_handle(uniffi_handle)
+  end
+
+  # Create the VTable struct instance.
+  UNIFFI_VTABLE = UniFFILib::VTableCallbackInterfaceMqttAuthProvider.new
+  UNIFFI_VTABLE[:uniffi_free] = UNIFFI_FREE_CALLBACK
+  UNIFFI_VTABLE[:uniffi_clone] = UNIFFI_CLONE_CALLBACK
+  UNIFFI_VTABLE[:authenticate] = AUTHENTICATE_CALLBACK
+
+  # Register the VTable with Rust.
+  UniFFILib.uniffi_mqtt_broker_fn_init_callback_vtable_mqttauthprovider(UNIFFI_VTABLE)
+end
+  
+  class MqttBrokerEventListener
+
+  # 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|
+      ::MqttBroker.rust_call(
+        :uniffi_mqtt_broker_fn_free_mqttbrokereventlistener,
+        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_client_connected)
+      raise TypeError.new "Expected a MqttBrokerEventListener instance or an object implementing the interface, got #{inst}"
+    end
+    if !inst.respond_to?(:on_client_disconnected)
+      raise TypeError.new "Expected a MqttBrokerEventListener instance or an object implementing the interface, got #{inst}"
+    end
+    if !inst.respond_to?(:on_message_published)
+      raise TypeError.new "Expected a MqttBrokerEventListener instance or an object implementing the interface, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle
+    return ::MqttBroker.rust_call(
+      :uniffi_mqtt_broker_fn_clone_mqttbrokereventlistener,
+      @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_client_connected(client_id)
+        client_id = ::MqttBroker::uniffi_utf8(client_id)
+        
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbrokereventlistener_on_client_connected,uniffi_clone_handle(),RustBuffer.alloc_from_string(client_id))
+  end
+  
+  def on_client_disconnected(client_id, reason)
+        client_id = ::MqttBroker::uniffi_utf8(client_id)
+        
+        reason = ::MqttBroker::uniffi_utf8(reason)
+        
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbrokereventlistener_on_client_disconnected,uniffi_clone_handle(),RustBuffer.alloc_from_string(client_id),RustBuffer.alloc_from_string(reason))
+  end
+  
+  def on_message_published(client_id, topic, qos)
+        client_id = ::MqttBroker::uniffi_utf8(client_id)
+        
+        topic = ::MqttBroker::uniffi_utf8(topic)
+        
+        qos = qos
+        RustBuffer.check_lower_TypeQoS(qos)
+      ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttbrokereventlistener_on_message_published,uniffi_clone_handle(),RustBuffer.alloc_from_string(client_id),RustBuffer.alloc_from_string(topic),RustBuffer.alloc_from_TypeQoS(qos))
+  end
+  
+  
+end
+
+
+# Trait interface vtable implementation for MqttBrokerEventListener.
+module UniffiCallbackInterfaceMqttBrokerEventListener
+  # Callback method for on_client_connected
+  ON_CLIENT_CONNECTED_CALLBACK = Proc.new do |uniffi_handle, client_id, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttBrokerEventListener.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.on_client_connected(
+        client_id.consume_into_string
+      )
+    end
+    # No return value, so do nothing
+    write_return_value = Proc.new { |_v| }
+    ::MqttBroker.uniffi_trait_interface_call(
+      uniffi_call_status,
+      make_call,
+      write_return_value,
+    )
+  end
+  # Callback method for on_client_disconnected
+  ON_CLIENT_DISCONNECTED_CALLBACK = Proc.new do |uniffi_handle, client_id, reason, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttBrokerEventListener.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.on_client_disconnected(
+        client_id.consume_into_string,
+        reason.consume_into_string
+      )
+    end
+    # No return value, so do nothing
+    write_return_value = Proc.new { |_v| }
+    ::MqttBroker.uniffi_trait_interface_call(
+      uniffi_call_status,
+      make_call,
+      write_return_value,
+    )
+  end
+  # Callback method for on_message_published
+  ON_MESSAGE_PUBLISHED_CALLBACK = Proc.new do |uniffi_handle, client_id, topic, qos, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttBrokerEventListener.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.on_message_published(
+        client_id.consume_into_string,
+        topic.consume_into_string,
+        qos.consume_into_TypeQoS
+      )
+    end
+    # No return value, so do nothing
+    write_return_value = Proc.new { |_v| }
+    ::MqttBroker.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|
+    MqttBrokerEventListener.uniffi_handle_map.remove uniffi_handle
+  end
+
+  # Clone callback: clones the handle in the map.
+  UNIFFI_CLONE_CALLBACK = Proc.new do |uniffi_handle|
+    MqttBrokerEventListener.uniffi_handle_map.clone_handle(uniffi_handle)
+  end
+
+  # Create the VTable struct instance.
+  UNIFFI_VTABLE = UniFFILib::VTableCallbackInterfaceMqttBrokerEventListener.new
+  UNIFFI_VTABLE[:uniffi_free] = UNIFFI_FREE_CALLBACK
+  UNIFFI_VTABLE[:uniffi_clone] = UNIFFI_CLONE_CALLBACK
+  UNIFFI_VTABLE[:on_client_connected] = ON_CLIENT_CONNECTED_CALLBACK
+  UNIFFI_VTABLE[:on_client_disconnected] = ON_CLIENT_DISCONNECTED_CALLBACK
+  UNIFFI_VTABLE[:on_message_published] = ON_MESSAGE_PUBLISHED_CALLBACK
+
+  # Register the VTable with Rust.
+  UniFFILib.uniffi_mqtt_broker_fn_init_callback_vtable_mqttbrokereventlistener(UNIFFI_VTABLE)
+end
+  
+  class MqttEnhancedAuthProvider
+
+  # 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|
+      ::MqttBroker.rust_call(
+        :uniffi_mqtt_broker_fn_free_mqttenhancedauthprovider,
+        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?(:step)
+      raise TypeError.new "Expected a MqttEnhancedAuthProvider instance or an object implementing the interface, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle
+    return ::MqttBroker.rust_call(
+      :uniffi_mqtt_broker_fn_clone_mqttenhancedauthprovider,
+      @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 step(client_id, method, data, round)
+        client_id = ::MqttBroker::uniffi_utf8(client_id)
+        
+        method = ::MqttBroker::uniffi_utf8(method)
+        
+        data = (data ? ::MqttBroker::uniffi_bytes(data) : nil)
+        RustBuffer.check_lower_Optionalbytes(data)
+        round = ::MqttBroker::uniffi_in_range(round, "u32", 0, 2**32)
+        
+    result = ::MqttBroker.rust_call(:uniffi_mqtt_broker_fn_method_mqttenhancedauthprovider_step,uniffi_clone_handle(),RustBuffer.alloc_from_string(client_id),RustBuffer.alloc_from_string(method),RustBuffer.alloc_from_Optionalbytes(data),round)
+    return result.consume_into_TypeEnhancedAuthStep
+  end
+  
+end
+
+
+# Trait interface vtable implementation for MqttEnhancedAuthProvider.
+module UniffiCallbackInterfaceMqttEnhancedAuthProvider
+  # Callback method for step
+  STEP_CALLBACK = Proc.new do |uniffi_handle, client_id, method, data, round, uniffi_out_return, uniffi_call_status|
+    uniffi_obj = MqttEnhancedAuthProvider.uniffi_handle_map.get(uniffi_handle)
+    make_call = Proc.new do
+      uniffi_obj.step(
+        client_id.consume_into_string,
+        method.consume_into_string,
+        data.consume_into_Optionalbytes,
+        round.to_i
+      )
+    end
+    write_return_value = Proc.new do |v|
+      lowered = RustBuffer.alloc_from_TypeEnhancedAuthStep(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
+    ::MqttBroker.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|
+    MqttEnhancedAuthProvider.uniffi_handle_map.remove uniffi_handle
+  end
+
+  # Clone callback: clones the handle in the map.
+  UNIFFI_CLONE_CALLBACK = Proc.new do |uniffi_handle|
+    MqttEnhancedAuthProvider.uniffi_handle_map.clone_handle(uniffi_handle)
+  end
+
+  # Create the VTable struct instance.
+  UNIFFI_VTABLE = UniFFILib::VTableCallbackInterfaceMqttEnhancedAuthProvider.new
+  UNIFFI_VTABLE[:uniffi_free] = UNIFFI_FREE_CALLBACK
+  UNIFFI_VTABLE[:uniffi_clone] = UNIFFI_CLONE_CALLBACK
+  UNIFFI_VTABLE[:step] = STEP_CALLBACK
+
+  # Register the VTable with Rust.
+  UniFFILib.uniffi_mqtt_broker_fn_init_callback_vtable_mqttenhancedauthprovider(UNIFFI_VTABLE)
+end
+  
+
+  
+end
+