firemq 0.1.0-x86_64-linux

data/lib/firemq/firemq_client_ffi.rb

@@ -0,0 +1,2075 @@
+# 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'
+
+module FiremqClientFfi
+  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
+  class RustBuffer < FFI::Struct
+  layout :capacity, :uint64,
+         :len,      :uint64,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return ::FiremqClientFfi.rust_call(:ffi_firemq_client_ffi_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return ::FiremqClientFfi.rust_call(:ffi_firemq_client_ffi_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    ::FiremqClientFfi.rust_call(:ffi_firemq_client_ffi_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 MessageProperties.
+
+  def self.check_lower_TypeMessageProperties(v)
+    RustBuffer.check_lower_Optionalstring(v.content_type)
+    RustBuffer.check_lower_Optionalstring(v.content_encoding)
+    RustBuffer.check_lower_Optionalstring(v.correlation_id)
+    RustBuffer.check_lower_Optionalstring(v.reply_to)
+    RustBuffer.check_lower_Optionalu64(v.expiration)
+    RustBuffer.check_lower_Optionalstring(v.message_id)
+    RustBuffer.check_lower_Optionalu64(v.timestamp)
+    RustBuffer.check_lower_Optionalstring(v.message_type)
+    RustBuffer.check_lower_Optionalstring(v.user_id)
+    RustBuffer.check_lower_Optionalstring(v.app_id)
+    RustBuffer.check_lower_Optionalu8(v.priority)
+  end
+
+  def self.alloc_from_TypeMessageProperties(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeMessageProperties(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeMessageProperties
+    consumeWithStream do |stream|
+      return stream.read_TypeMessageProperties
+    end
+  end
+
+  # The Record type PublishOptions.
+
+  def self.check_lower_TypePublishOptions(v)
+    
+    
+    
+    RustBuffer.check_lower_TypeMessageProperties(v.properties)
+    RustBuffer.check_lower_Optionalstring(v.headers_json)
+  end
+
+  def self.alloc_from_TypePublishOptions(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypePublishOptions(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypePublishOptions
+    consumeWithStream do |stream|
+      return stream.read_TypePublishOptions
+    end
+  end
+
+  # The Record type QueueInfo.
+
+  def self.check_lower_TypeQueueInfo(v)
+    
+    
+    
+  end
+
+  def self.alloc_from_TypeQueueInfo(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeQueueInfo(v)
+      return builder.finalize
+    end
+  end
+
+  def consume_into_TypeQueueInfo
+    consumeWithStream do |stream|
+      return stream.read_TypeQueueInfo
+    end
+  end
+
+  # Error enum - generate alloc_from for callback error serialization
+  def self.alloc_from_TypeFireMqError(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFireMqError(v)
+      return builder.finalize
+    end
+  end
+
+  # Enum used as error - generate consume_into_ for use as a return value
+  def consume_into_TypeFireMqError
+    consumeWithStream do |stream|
+      return stream.read_TypeFireMqError
+    end
+  end
+  
+
+  # The Optional<T> type for u8.
+
+  def self.check_lower_Optionalu8(v)
+    if !v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalu8(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalu8(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_Optionalu8
+    consumeWithStream do |stream|
+      return stream.read_Optionalu8
+    end
+  end
+
+  # The Optional<T> type for u64.
+
+  def self.check_lower_Optionalu64(v)
+    if !v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalu64(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalu64(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_Optionalu64
+    consumeWithStream do |stream|
+      return stream.read_Optionalu64
+    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 TypeDelivery.
+
+  def self.check_lower_OptionalTypeDelivery(v)
+    if !v.nil?
+      (Delivery.uniffi_check_lower v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeDelivery(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeDelivery(v)
+      return builder.finalize()
+    end
+  end
+
+  def consume_into_OptionalTypeDelivery
+    consumeWithStream do |stream|
+      return stream.read_OptionalTypeDelivery
+    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_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 Client.
+
+  def read_TypeClient
+    handle = unpack_from 8, 'Q>'
+    return Client.uniffi_lift(handle)
+  end
+
+  # The Object type Delivery.
+
+  def read_TypeDelivery
+    handle = unpack_from 8, 'Q>'
+    return Delivery.uniffi_lift(handle)
+  end
+
+  # The Object type Subscription.
+
+  def read_TypeSubscription
+    handle = unpack_from 8, 'Q>'
+    return Subscription.uniffi_lift(handle)
+  end
+
+  # The Record type MessageProperties.
+
+  def read_TypeMessageProperties
+    MessageProperties.new(
+      content_type: read_Optionalstring,
+      content_encoding: read_Optionalstring,
+      correlation_id: read_Optionalstring,
+      reply_to: read_Optionalstring,
+      expiration: read_Optionalu64,
+      message_id: read_Optionalstring,
+      timestamp: read_Optionalu64,
+      message_type: read_Optionalstring,
+      user_id: read_Optionalstring,
+      app_id: read_Optionalstring,
+      priority: read_Optionalu8
+    )
+  end
+
+  # The Record type PublishOptions.
+
+  def read_TypePublishOptions
+    PublishOptions.new(
+      persistent: read_bool,
+      mandatory: read_bool,
+      confirm: read_bool,
+      properties: read_TypeMessageProperties,
+      headers_json: read_Optionalstring
+    )
+  end
+
+  # The Record type QueueInfo.
+
+  def read_TypeQueueInfo
+    QueueInfo.new(
+      name: read_string,
+      messages: read_u64,
+      consumers: read_u32
+    )
+  end
+
+  
+
+  
+
+  # The Error type FireMqError
+
+  def read_TypeFireMqError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return FireMqError::Server.new(
+            code: read_u16(),
+            message: read_string()
+        )
+    end
+    if variant == 2
+        return FireMqError::Unroutable.new(
+            message: read_string()
+        )
+    end
+    if variant == 3
+        return FireMqError::Nacked.new(
+            code: read_u16(),
+            message: read_string()
+        )
+    end
+    if variant == 4
+        return FireMqError::Closed.new(
+            message: read_string()
+        )
+    end
+    if variant == 5
+        return FireMqError::Other.new(
+            message: read_string()
+        )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeFireMqError'
+  end
+  
+
+  
+  # The Optional<T> type for u8.
+
+  def read_Optionalu8
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_u8
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalu8'
+    end
+  end
+
+  
+  # The Optional<T> type for u64.
+
+  def read_Optionalu64
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_u64
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalu64'
+    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 TypeDelivery.
+
+  def read_OptionalTypeDelivery
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return read_TypeDelivery
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeDelivery'
+    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 = ::FiremqClientFfi::uniffi_in_range(v, "u8", 0, 2**8)
+    pack_into(1, 'c', v)
+  end
+
+  def write_u16(v)
+    v = ::FiremqClientFfi::uniffi_in_range(v, "u16", 0, 2**16)
+    pack_into(2, 'S>', v)
+  end
+
+  def write_u32(v)
+    v = ::FiremqClientFfi::uniffi_in_range(v, "u32", 0, 2**32)
+    pack_into(4, 'L>', v)
+  end
+
+  def write_u64(v)
+    v = ::FiremqClientFfi::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 = ::FiremqClientFfi::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  def write_bytes(v)
+    v = ::FiremqClientFfi::uniffi_bytes(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Object type Client.
+
+  def write_TypeClient(obj)
+    handle = Client.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Delivery.
+
+  def write_TypeDelivery(obj)
+    handle = Delivery.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Subscription.
+
+  def write_TypeSubscription(obj)
+    handle = Subscription.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Record type MessageProperties.
+
+  def write_TypeMessageProperties(v)
+    self.write_Optionalstring(v.content_type)
+    self.write_Optionalstring(v.content_encoding)
+    self.write_Optionalstring(v.correlation_id)
+    self.write_Optionalstring(v.reply_to)
+    self.write_Optionalu64(v.expiration)
+    self.write_Optionalstring(v.message_id)
+    self.write_Optionalu64(v.timestamp)
+    self.write_Optionalstring(v.message_type)
+    self.write_Optionalstring(v.user_id)
+    self.write_Optionalstring(v.app_id)
+    self.write_Optionalu8(v.priority)
+  end
+
+  # The Record type PublishOptions.
+
+  def write_TypePublishOptions(v)
+    self.write_bool(v.persistent)
+    self.write_bool(v.mandatory)
+    self.write_bool(v.confirm)
+    self.write_TypeMessageProperties(v.properties)
+    self.write_Optionalstring(v.headers_json)
+  end
+
+  # The Record type QueueInfo.
+
+  def write_TypeQueueInfo(v)
+    self.write_string(v.name)
+    self.write_u64(v.messages)
+    self.write_u32(v.consumers)
+  end
+
+  # The Error type FireMqError - write for callback error returns.
+
+  def write_TypeFireMqError(v)
+    if v.is_a?(FireMqError::Server)
+      pack_into 4, 'l>', 1
+        self.write_u16(v.code)
+        self.write_string(v.message)
+      return
+    end
+    if v.is_a?(FireMqError::Unroutable)
+      pack_into 4, 'l>', 2
+        self.write_string(v.message)
+      return
+    end
+    if v.is_a?(FireMqError::Nacked)
+      pack_into 4, 'l>', 3
+        self.write_u16(v.code)
+        self.write_string(v.message)
+      return
+    end
+    if v.is_a?(FireMqError::Closed)
+      pack_into 4, 'l>', 4
+        self.write_string(v.message)
+      return
+    end
+    if v.is_a?(FireMqError::Other)
+      pack_into 4, 'l>', 5
+        self.write_string(v.message)
+      return
+    end
+  end
+  
+
+  # The Optional<T> type for u8.
+
+  def write_Optionalu8(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_u8(v)
+    end
+  end
+
+  # The Optional<T> type for u64.
+
+  def write_Optionalu64(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_u64(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 TypeDelivery.
+
+  def write_OptionalTypeDelivery(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeDelivery(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
+
+
+module FireMqError
+  class Server < StandardError
+    def initialize(code:, message:)
+        
+        @code = code
+        
+        @message = message
+        
+        super()
+    end
+    
+
+    attr_reader :code, :message
+    
+
+    def to_s
+        "#{self.class.name}(code=#{@code.inspect}, message=#{@message.inspect})"
+
+    end
+  end
+  class Unroutable < StandardError
+    def initialize(message:)
+        
+        @message = message
+        
+        super()
+    end
+    
+
+    attr_reader :message
+    
+
+    def to_s
+        "#{self.class.name}(message=#{@message.inspect})"
+
+    end
+  end
+  class Nacked < StandardError
+    def initialize(code:, message:)
+        
+        @code = code
+        
+        @message = message
+        
+        super()
+    end
+    
+
+    attr_reader :code, :message
+    
+
+    def to_s
+        "#{self.class.name}(code=#{@code.inspect}, message=#{@message.inspect})"
+
+    end
+  end
+  class Closed < StandardError
+    def initialize(message:)
+        
+        @message = message
+        
+        super()
+    end
+    
+
+    attr_reader :message
+    
+
+    def to_s
+        "#{self.class.name}(message=#{@message.inspect})"
+
+    end
+  end
+  class Other < StandardError
+    def initialize(message:)
+        
+        @message = message
+        
+        super()
+    end
+    
+
+    attr_reader :message
+    
+
+    def to_s
+        "#{self.class.name}(message=#{@message.inspect})"
+
+    end
+  end
+
+end
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+FireMqError => :read_TypeFireMqError,
+}
+
+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 [ENV['FIREMQ_LIB'], File.expand_path(FFI.map_library_name('firemq_client_ffi'), __dir__), 'firemq_client_ffi'].compact
+  
+
+  # 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
+  
+  attach_function :uniffi_firemq_client_ffi_fn_clone_client,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_free_client,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_constructor_client_connect,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_bind_exchange,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_bind_queue,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_close,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_declare_exchange,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, :int8, :int8, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_declare_queue,
+    [:uint64, RustBuffer.by_value, :int8, :int8, :int8, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_delete_exchange,
+    [:uint64, RustBuffer.by_value, :int8, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_delete_queue,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_get,
+    [:uint64, RustBuffer.by_value, :int8, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_is_closed,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_publish,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_purge_queue,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_subscribe,
+    [:uint64, RustBuffer.by_value, :uint32, :int8, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_client_unbind_queue,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_clone_delivery,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_free_delivery,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_ack,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_body,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_delivery_tag,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_exchange,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_headers_json,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_nack,
+    [:uint64, :int8, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_properties,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_redelivered,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_delivery_routing_key,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :uniffi_firemq_client_ffi_fn_clone_subscription,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :uniffi_firemq_client_ffi_fn_free_subscription,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_subscription_cancel,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_fn_method_subscription_next,
+    [:uint64, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_firemq_client_ffi_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_firemq_client_ffi_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_firemq_client_ffi_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_u8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_u8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_u8,
+    [:uint64, RustCallStatus.by_ref],
+    :uint8
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_i8,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_i8,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_i8,
+    [:uint64, RustCallStatus.by_ref],
+    :int8
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_u16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_u16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_u16,
+    [:uint64, RustCallStatus.by_ref],
+    :uint16
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_i16,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_i16,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_i16,
+    [:uint64, RustCallStatus.by_ref],
+    :int16
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_u32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_u32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_u32,
+    [:uint64, RustCallStatus.by_ref],
+    :uint32
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_i32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_i32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_i32,
+    [:uint64, RustCallStatus.by_ref],
+    :int32
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_u64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_u64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_u64,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_i64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_i64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_i64,
+    [:uint64, RustCallStatus.by_ref],
+    :int64
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_f32,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_f32,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_f32,
+    [:uint64, RustCallStatus.by_ref],
+    :float
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_f64,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_f64,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_f64,
+    [:uint64, RustCallStatus.by_ref],
+    :double
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_rust_buffer,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_rust_buffer,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_rust_buffer,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_poll_void,
+    [:uint64, :RustFutureContinuationCallback, :uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_cancel_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_free_void,
+    [:uint64, ],
+    :void
+  
+  attach_function :ffi_firemq_client_ffi_rust_future_complete_void,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_bind_exchange,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_bind_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_close,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_declare_exchange,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_declare_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_delete_exchange,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_delete_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_get,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_is_closed,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_publish,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_purge_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_subscribe,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_client_unbind_queue,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_ack,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_body,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_delivery_tag,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_exchange,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_headers_json,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_nack,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_properties,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_redelivered,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_delivery_routing_key,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_subscription_cancel,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_method_subscription_next,
+    [],
+    :uint16
+  
+  attach_function :uniffi_firemq_client_ffi_checksum_constructor_client_connect,
+    [],
+    :uint16
+  
+  attach_function :ffi_firemq_client_ffi_uniffi_contract_version,
+    [],
+    :uint32
+  
+end
+
+  # Custom type definitions.
+
+  # Public interface members begin here.
+
+  
+  
+  # Record type MessageProperties
+class MessageProperties
+  attr_reader :content_type, :content_encoding, :correlation_id, :reply_to, :expiration, :message_id, :timestamp, :message_type, :user_id, :app_id, :priority
+
+  def initialize(content_type: nil, content_encoding: nil, correlation_id: nil, reply_to: nil, expiration: nil, message_id: nil, timestamp: nil, message_type: nil, user_id: nil, app_id: nil, priority: nil)
+    @content_type = content_type
+    @content_encoding = content_encoding
+    @correlation_id = correlation_id
+    @reply_to = reply_to
+    @expiration = expiration
+    @message_id = message_id
+    @timestamp = timestamp
+    @message_type = message_type
+    @user_id = user_id
+    @app_id = app_id
+    @priority = priority
+  end
+
+  def ==(other)
+    if @content_type != other.content_type
+      return false
+    end
+    if @content_encoding != other.content_encoding
+      return false
+    end
+    if @correlation_id != other.correlation_id
+      return false
+    end
+    if @reply_to != other.reply_to
+      return false
+    end
+    if @expiration != other.expiration
+      return false
+    end
+    if @message_id != other.message_id
+      return false
+    end
+    if @timestamp != other.timestamp
+      return false
+    end
+    if @message_type != other.message_type
+      return false
+    end
+    if @user_id != other.user_id
+      return false
+    end
+    if @app_id != other.app_id
+      return false
+    end
+    if @priority != other.priority
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type PublishOptions
+class PublishOptions
+  attr_reader :persistent, :mandatory, :confirm, :properties, :headers_json
+
+  def initialize(persistent: true, mandatory: false, confirm: true, properties: MessageProperties.new, headers_json: nil)
+    @persistent = persistent
+    @mandatory = mandatory
+    @confirm = confirm
+    @properties = properties
+    @headers_json = headers_json
+  end
+
+  def ==(other)
+    if @persistent != other.persistent
+      return false
+    end
+    if @mandatory != other.mandatory
+      return false
+    end
+    if @confirm != other.confirm
+      return false
+    end
+    if @properties != other.properties
+      return false
+    end
+    if @headers_json != other.headers_json
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+  # Record type QueueInfo
+class QueueInfo
+  attr_reader :name, :messages, :consumers
+
+  def initialize(name:, messages:, consumers:)
+    @name = name
+    @messages = messages
+    @consumers = consumers
+  end
+
+  def ==(other)
+    if @name != other.name
+      return false
+    end
+    if @messages != other.messages
+      return false
+    end
+    if @consumers != other.consumers
+      return false
+    end
+
+    true
+  end
+  
+end
+  
+
+  
+
+  
+  class Client
+
+  # 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|
+      ::FiremqClientFfi.rust_call(
+        :uniffi_firemq_client_ffi_fn_free_client,
+        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 Client instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return ::FiremqClientFfi.rust_call(
+      :uniffi_firemq_client_ffi_fn_clone_client,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+
+  def self.uniffi_lift(handle)
+    uniffi_allocate handle
+  end
+
+  
+  def self.connect(url)
+        url = ::FiremqClientFfi::uniffi_utf8(url)
+        
+    # Call the (fallible) function before creating any half-baked object instances.
+    # Lightly yucky way to bypass the usual "initialize" logic
+    # and just create a new instance with the required handle.
+    return uniffi_allocate(::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_constructor_client_connect,RustBuffer.alloc_from_string(url)))
+  end
+  
+
+  def bind_exchange(destination, source, key)
+        destination = ::FiremqClientFfi::uniffi_utf8(destination)
+        
+        source = ::FiremqClientFfi::uniffi_utf8(source)
+        
+        key = ::FiremqClientFfi::uniffi_utf8(key)
+        
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_bind_exchange,uniffi_clone_handle(),RustBuffer.alloc_from_string(destination),RustBuffer.alloc_from_string(source),RustBuffer.alloc_from_string(key))
+  end
+  
+  def bind_queue(queue, exchange, key, args_json = nil)
+        queue = ::FiremqClientFfi::uniffi_utf8(queue)
+        
+        exchange = ::FiremqClientFfi::uniffi_utf8(exchange)
+        
+        key = ::FiremqClientFfi::uniffi_utf8(key)
+        
+        args_json = (args_json ? ::FiremqClientFfi::uniffi_utf8(args_json) : nil)
+        RustBuffer.check_lower_Optionalstring(args_json)
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_bind_queue,uniffi_clone_handle(),RustBuffer.alloc_from_string(queue),RustBuffer.alloc_from_string(exchange),RustBuffer.alloc_from_string(key),RustBuffer.alloc_from_Optionalstring(args_json))
+  end
+  
+  def close()
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_close,uniffi_clone_handle(),)
+  end
+  
+  def declare_exchange(name, kind, durable = true, auto_delete = false, args_json = nil)
+        name = ::FiremqClientFfi::uniffi_utf8(name)
+        
+        kind = ::FiremqClientFfi::uniffi_utf8(kind)
+        
+        durable = durable ? true : false
+        
+        auto_delete = auto_delete ? true : false
+        
+        args_json = (args_json ? ::FiremqClientFfi::uniffi_utf8(args_json) : nil)
+        RustBuffer.check_lower_Optionalstring(args_json)
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_declare_exchange,uniffi_clone_handle(),RustBuffer.alloc_from_string(name),RustBuffer.alloc_from_string(kind),(durable ? 1 : 0),(auto_delete ? 1 : 0),RustBuffer.alloc_from_Optionalstring(args_json))
+  end
+  
+  def declare_queue(name, durable = true, exclusive = false, auto_delete = false, args_json = nil)
+        name = ::FiremqClientFfi::uniffi_utf8(name)
+        
+        durable = durable ? true : false
+        
+        exclusive = exclusive ? true : false
+        
+        auto_delete = auto_delete ? true : false
+        
+        args_json = (args_json ? ::FiremqClientFfi::uniffi_utf8(args_json) : nil)
+        RustBuffer.check_lower_Optionalstring(args_json)
+    result = ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_declare_queue,uniffi_clone_handle(),RustBuffer.alloc_from_string(name),(durable ? 1 : 0),(exclusive ? 1 : 0),(auto_delete ? 1 : 0),RustBuffer.alloc_from_Optionalstring(args_json))
+    return result.consume_into_TypeQueueInfo
+  end
+  def delete_exchange(name, if_unused = false)
+        name = ::FiremqClientFfi::uniffi_utf8(name)
+        
+        if_unused = if_unused ? true : false
+        
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_delete_exchange,uniffi_clone_handle(),RustBuffer.alloc_from_string(name),(if_unused ? 1 : 0))
+  end
+  
+  def delete_queue(name)
+        name = ::FiremqClientFfi::uniffi_utf8(name)
+        
+    result = ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_delete_queue,uniffi_clone_handle(),RustBuffer.alloc_from_string(name))
+    return result.to_i
+  end
+  def get(queue, no_ack = false)
+        queue = ::FiremqClientFfi::uniffi_utf8(queue)
+        
+        no_ack = no_ack ? true : false
+        
+    result = ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_get,uniffi_clone_handle(),RustBuffer.alloc_from_string(queue),(no_ack ? 1 : 0))
+    return result.consume_into_OptionalTypeDelivery
+  end
+  def is_closed()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_client_is_closed,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def publish(exchange, key, body, options = PublishOptions.new)
+        exchange = ::FiremqClientFfi::uniffi_utf8(exchange)
+        
+        key = ::FiremqClientFfi::uniffi_utf8(key)
+        
+        body = ::FiremqClientFfi::uniffi_bytes(body)
+        
+        options = options
+        RustBuffer.check_lower_TypePublishOptions(options)
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_publish,uniffi_clone_handle(),RustBuffer.alloc_from_string(exchange),RustBuffer.alloc_from_string(key),RustBuffer.alloc_from_bytes(body),RustBuffer.alloc_from_TypePublishOptions(options))
+  end
+  
+  def purge_queue(name)
+        name = ::FiremqClientFfi::uniffi_utf8(name)
+        
+    result = ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_purge_queue,uniffi_clone_handle(),RustBuffer.alloc_from_string(name))
+    return result.to_i
+  end
+  def subscribe(queue, prefetch = 100, no_ack = false)
+        queue = ::FiremqClientFfi::uniffi_utf8(queue)
+        
+        prefetch = ::FiremqClientFfi::uniffi_in_range(prefetch, "u32", 0, 2**32)
+        
+        no_ack = no_ack ? true : false
+        
+    result = ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_subscribe,uniffi_clone_handle(),RustBuffer.alloc_from_string(queue),prefetch,(no_ack ? 1 : 0))
+    return Subscription.uniffi_lift(result)
+  end
+  def unbind_queue(queue, exchange, key)
+        queue = ::FiremqClientFfi::uniffi_utf8(queue)
+        
+        exchange = ::FiremqClientFfi::uniffi_utf8(exchange)
+        
+        key = ::FiremqClientFfi::uniffi_utf8(key)
+        
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_client_unbind_queue,uniffi_clone_handle(),RustBuffer.alloc_from_string(queue),RustBuffer.alloc_from_string(exchange),RustBuffer.alloc_from_string(key))
+  end
+  
+  
+end
+  
+  class Delivery
+
+  # 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|
+      ::FiremqClientFfi.rust_call(
+        :uniffi_firemq_client_ffi_fn_free_delivery,
+        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 Delivery instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return ::FiremqClientFfi.rust_call(
+      :uniffi_firemq_client_ffi_fn_clone_delivery,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+
+  def self.uniffi_lift(handle)
+    uniffi_allocate handle
+  end
+
+  
+
+  def ack()
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_delivery_ack,uniffi_clone_handle(),)
+  end
+  
+  def body()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_delivery_body,uniffi_clone_handle(),)
+    return result.consume_into_bytes
+  end
+  def delivery_tag()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_delivery_delivery_tag,uniffi_clone_handle(),)
+    return result.to_i
+  end
+  def exchange()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_delivery_exchange,uniffi_clone_handle(),)
+    return result.consume_into_string
+  end
+  def headers_json()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_delivery_headers_json,uniffi_clone_handle(),)
+    return result.consume_into_string
+  end
+  def nack(requeue)
+        requeue = requeue ? true : false
+        
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_delivery_nack,uniffi_clone_handle(),(requeue ? 1 : 0))
+  end
+  
+  def properties()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_delivery_properties,uniffi_clone_handle(),)
+    return result.consume_into_TypeMessageProperties
+  end
+  def redelivered()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_delivery_redelivered,uniffi_clone_handle(),)
+    return 1 == result
+  end
+  def routing_key()
+    result = ::FiremqClientFfi.rust_call(:uniffi_firemq_client_ffi_fn_method_delivery_routing_key,uniffi_clone_handle(),)
+    return result.consume_into_string
+  end
+  
+end
+  
+  class Subscription
+
+  # 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|
+      ::FiremqClientFfi.rust_call(
+        :uniffi_firemq_client_ffi_fn_free_subscription,
+        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 Subscription instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return ::FiremqClientFfi.rust_call(
+      :uniffi_firemq_client_ffi_fn_clone_subscription,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+
+  def self.uniffi_lift(handle)
+    uniffi_allocate handle
+  end
+
+  
+
+  def cancel()
+      ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_subscription_cancel,uniffi_clone_handle(),)
+  end
+  
+  def next(timeout_ms)
+        timeout_ms = ::FiremqClientFfi::uniffi_in_range(timeout_ms, "u64", 0, 2**64)
+        
+    result = ::FiremqClientFfi.rust_call_with_error(FireMqError,:uniffi_firemq_client_ffi_fn_method_subscription_next,uniffi_clone_handle(),timeout_ms)
+    return result.consume_into_OptionalTypeDelivery
+  end
+  
+end
+  
+
+  
+end
+