oicana 0.10.0-aarch64-linux-gnu

data/lib/oicana/oicana_uniffi.rb

@@ -0,0 +1,2548 @@
+# 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'
+
+
+module OicanaUniffi
+  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
+
+  class RustBuffer < FFI::Struct
+  layout :capacity, :uint64,
+         :len,      :uint64,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return OicanaUniffi.rust_call(:ffi_oicana_uniffi_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return OicanaUniffi.rust_call(:ffi_oicana_uniffi_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    OicanaUniffi.rust_call(:ffi_oicana_uniffi_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.allocFromString(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoString
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  # The primitive Bytes type.
+
+  def self.allocFromBytes(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Bytes(value)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoBytes
+    consumeWithStream do |stream|
+      return stream.readBytes
+    end
+  end
+
+  # The Record type BlobInput.
+
+  def self.check_lower_TypeBlobInput(v)
+    
+    
+  end
+
+  def self.alloc_from_TypeBlobInput(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeBlobInput(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeBlobInput
+    consumeWithStream do |stream|
+      return stream.readTypeBlobInput
+    end
+  end
+
+  # The Record type Diagnostic.
+
+  def self.check_lower_TypeDiagnostic(v)
+    RustBuffer.check_lower_TypeDiagnosticSeverity(v.severity)
+    
+    RustBuffer.check_lower_OptionalTypeSourceLocation(v.location)
+    RustBuffer.check_lower_Sequencestring(v.hints)
+    RustBuffer.check_lower_SequenceTypeTracePoint(v.trace)
+    
+  end
+
+  def self.alloc_from_TypeDiagnostic(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeDiagnostic(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeDiagnostic
+    consumeWithStream do |stream|
+      return stream.readTypeDiagnostic
+    end
+  end
+
+  # The Record type ExportOnceResult.
+
+  def self.check_lower_TypeExportOnceResult(v)
+    
+    RustBuffer.check_lower_SequenceTypeDiagnostic(v.warnings)
+  end
+
+  def self.alloc_from_TypeExportOnceResult(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeExportOnceResult(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeExportOnceResult
+    consumeWithStream do |stream|
+      return stream.readTypeExportOnceResult
+    end
+  end
+
+  # The Record type PageRange.
+
+  def self.check_lower_TypePageRange(v)
+    RustBuffer.check_lower_Optionalu64(v.start)
+    RustBuffer.check_lower_Optionalu64(v._end)
+  end
+
+  def self.alloc_from_TypePageRange(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypePageRange(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypePageRange
+    consumeWithStream do |stream|
+      return stream.readTypePageRange
+    end
+  end
+
+  # The Record type PageSize.
+
+  def self.check_lower_TypePageSize(v)
+    
+    
+  end
+
+  def self.alloc_from_TypePageSize(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypePageSize(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypePageSize
+    consumeWithStream do |stream|
+      return stream.readTypePageSize
+    end
+  end
+
+  # The Record type RegisteredFont.
+
+  def self.check_lower_TypeRegisteredFont(v)
+    
+    RustBuffer.check_lower_Optionalstring(v.path)
+  end
+
+  def self.alloc_from_TypeRegisteredFont(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeRegisteredFont(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeRegisteredFont
+    consumeWithStream do |stream|
+      return stream.readTypeRegisteredFont
+    end
+  end
+
+  # The Record type SourceLocation.
+
+  def self.check_lower_TypeSourceLocation(v)
+    
+    
+    
+    
+    
+  end
+
+  def self.alloc_from_TypeSourceLocation(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeSourceLocation(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeSourceLocation
+    consumeWithStream do |stream|
+      return stream.readTypeSourceLocation
+    end
+  end
+
+  # The Record type TracePoint.
+
+  def self.check_lower_TypeTracePoint(v)
+    
+    RustBuffer.check_lower_OptionalTypeSourceLocation(v.location)
+  end
+
+  def self.alloc_from_TypeTracePoint(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeTracePoint(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeTracePoint
+    consumeWithStream do |stream|
+      return stream.readTypeTracePoint
+    end
+  end
+
+  # The Record type ZipLimits.
+
+  def self.check_lower_TypeZipLimits(v)
+    RustBuffer.check_lower_Optionalu64(v.max_entries)
+    RustBuffer.check_lower_Optionalu64(v.max_total_decompressed_bytes)
+  end
+
+  def self.alloc_from_TypeZipLimits(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeZipLimits(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeZipLimits
+    consumeWithStream do |stream|
+      return stream.readTypeZipLimits
+    end
+  end
+
+  # The Enum type CompilationMode.
+
+  def self.check_lower_TypeCompilationMode(v)
+  end
+
+  def self.alloc_from_TypeCompilationMode(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeCompilationMode(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeCompilationMode
+    consumeWithStream do |stream|
+      return stream.readTypeCompilationMode
+    end
+  end
+  
+
+  # The Enum type DiagnosticColor.
+
+  def self.check_lower_TypeDiagnosticColor(v)
+  end
+
+  def self.alloc_from_TypeDiagnosticColor(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeDiagnosticColor(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeDiagnosticColor
+    consumeWithStream do |stream|
+      return stream.readTypeDiagnosticColor
+    end
+  end
+  
+
+  # The Enum type DiagnosticSeverity.
+
+  def self.check_lower_TypeDiagnosticSeverity(v)
+  end
+
+  def self.alloc_from_TypeDiagnosticSeverity(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeDiagnosticSeverity(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeDiagnosticSeverity
+    consumeWithStream do |stream|
+      return stream.readTypeDiagnosticSeverity
+    end
+  end
+  
+
+  # The Enum type ExportFormat.
+
+  def self.check_lower_TypeExportFormat(v)
+    if v.pdf?
+      return
+    end
+    if v.png?
+        
+      return
+    end
+    if v.svg?
+      return
+    end
+  end
+
+  def self.alloc_from_TypeExportFormat(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeExportFormat(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeExportFormat
+    consumeWithStream do |stream|
+      return stream.readTypeExportFormat
+    end
+  end
+  
+
+  
+
+  # The Optional<T> type for u64.
+
+  def self.check_lower_Optionalu64(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalu64(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalu64(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalu64
+    consumeWithStream do |stream|
+      return stream.readOptionalu64
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def self.check_lower_Optionalstring(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalstring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalstring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalstring
+    consumeWithStream do |stream|
+      return stream.readOptionalstring
+    end
+  end
+
+  # The Optional<T> type for TypePageRange.
+
+  def self.check_lower_OptionalTypePageRange(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypePageRange(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypePageRange(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypePageRange(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypePageRange
+    consumeWithStream do |stream|
+      return stream.readOptionalTypePageRange
+    end
+  end
+
+  # The Optional<T> type for TypeSourceLocation.
+
+  def self.check_lower_OptionalTypeSourceLocation(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeSourceLocation(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeSourceLocation(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeSourceLocation(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeSourceLocation
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeSourceLocation
+    end
+  end
+
+  # The Optional<T> type for TypeZipLimits.
+
+  def self.check_lower_OptionalTypeZipLimits(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeZipLimits(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeZipLimits(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeZipLimits(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeZipLimits
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeZipLimits
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def self.check_lower_Sequencestring(v)
+    v.each do |item|
+      
+    end
+  end
+
+  def self.alloc_from_Sequencestring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Sequencestring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequencestring
+    consumeWithStream do |stream|
+      return stream.readSequencestring
+    end
+  end
+
+  # The Sequence<T> type for bytes.
+
+  def self.check_lower_Sequencebytes(v)
+    v.each do |item|
+      
+    end
+  end
+
+  def self.alloc_from_Sequencebytes(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Sequencebytes(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequencebytes
+    consumeWithStream do |stream|
+      return stream.readSequencebytes
+    end
+  end
+
+  # The Sequence<T> type for TypeDiagnostic.
+
+  def self.check_lower_SequenceTypeDiagnostic(v)
+    v.each do |item|
+      RustBuffer.check_lower_TypeDiagnostic(item)
+    end
+  end
+
+  def self.alloc_from_SequenceTypeDiagnostic(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_SequenceTypeDiagnostic(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequenceTypeDiagnostic
+    consumeWithStream do |stream|
+      return stream.readSequenceTypeDiagnostic
+    end
+  end
+
+  # The Sequence<T> type for TypePageSize.
+
+  def self.check_lower_SequenceTypePageSize(v)
+    v.each do |item|
+      RustBuffer.check_lower_TypePageSize(item)
+    end
+  end
+
+  def self.alloc_from_SequenceTypePageSize(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_SequenceTypePageSize(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequenceTypePageSize
+    consumeWithStream do |stream|
+      return stream.readSequenceTypePageSize
+    end
+  end
+
+  # The Sequence<T> type for TypeRegisteredFont.
+
+  def self.check_lower_SequenceTypeRegisteredFont(v)
+    v.each do |item|
+      RustBuffer.check_lower_TypeRegisteredFont(item)
+    end
+  end
+
+  def self.alloc_from_SequenceTypeRegisteredFont(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_SequenceTypeRegisteredFont(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequenceTypeRegisteredFont
+    consumeWithStream do |stream|
+      return stream.readSequenceTypeRegisteredFont
+    end
+  end
+
+  # The Sequence<T> type for TypeTracePoint.
+
+  def self.check_lower_SequenceTypeTracePoint(v)
+    v.each do |item|
+      RustBuffer.check_lower_TypeTracePoint(item)
+    end
+  end
+
+  def self.alloc_from_SequenceTypeTracePoint(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_SequenceTypeTracePoint(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequenceTypeTracePoint
+    consumeWithStream do |stream|
+      return stream.readSequenceTypeTracePoint
+    end
+  end
+
+  # The Map<T> type for string.
+
+  def self.check_lower_MapStringString(v)
+    v.each do |k, v|
+      
+      
+    end
+  end
+
+  def self.alloc_from_MapStringString(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_MapStringString(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoMapStringString
+    consumeWithStream do |stream|
+      return stream.readMapStringString
+    end
+  end# The Map<T> type for TypeBlobInput.
+
+  def self.check_lower_MapStringTypeBlobInput(v)
+    v.each do |k, v|
+      
+      RustBuffer.check_lower_TypeBlobInput(v)
+    end
+  end
+
+  def self.alloc_from_MapStringTypeBlobInput(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_MapStringTypeBlobInput(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoMapStringTypeBlobInput
+    consumeWithStream do |stream|
+      return stream.readMapStringTypeBlobInput
+    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 readU32
+    unpack_from 4, 'L>'
+  end
+
+  def readU64
+    unpack_from 8, 'Q>'
+  end
+
+  def readF32
+    unpack_from 4, 'g'
+  end
+
+  def readF64
+    unpack_from 8, 'G'
+  end
+
+  def readBool
+    v = unpack_from 1, 'c'
+
+    return false if v == 0
+    return true if v == 1
+
+    raise InternalError, 'Unexpected byte for Boolean type'
+  end
+
+  def readString
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  def readBytes
+    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 CompiledDocument.
+
+  def readTypeCompiledDocument
+    handle = unpack_from 8, 'Q>'
+    return CompiledDocument.uniffi_allocate(handle)
+  end
+
+  # The Object type Template.
+
+  def readTypeTemplate
+    handle = unpack_from 8, 'Q>'
+    return Template.uniffi_allocate(handle)
+  end
+
+  # The Record type BlobInput.
+
+  def readTypeBlobInput
+    BlobInput.new(
+      data: readBytes,
+      metadata: readString
+    )
+  end
+
+  # The Record type Diagnostic.
+
+  def readTypeDiagnostic
+    Diagnostic.new(
+      severity: readTypeDiagnosticSeverity,
+      message: readString,
+      location: readOptionalTypeSourceLocation,
+      hints: readSequencestring,
+      trace: readSequenceTypeTracePoint,
+      formatted: readString
+    )
+  end
+
+  # The Record type ExportOnceResult.
+
+  def readTypeExportOnceResult
+    ExportOnceResult.new(
+      bytes: readBytes,
+      warnings: readSequenceTypeDiagnostic
+    )
+  end
+
+  # The Record type PageRange.
+
+  def readTypePageRange
+    PageRange.new(
+      start: readOptionalu64,
+      _end: readOptionalu64
+    )
+  end
+
+  # The Record type PageSize.
+
+  def readTypePageSize
+    PageSize.new(
+      width: readF64,
+      height: readF64
+    )
+  end
+
+  # The Record type RegisteredFont.
+
+  def readTypeRegisteredFont
+    RegisteredFont.new(
+      family: readString,
+      path: readOptionalstring
+    )
+  end
+
+  # The Record type SourceLocation.
+
+  def readTypeSourceLocation
+    SourceLocation.new(
+      file: readString,
+      line: readU32,
+      column: readU32,
+      end_line: readU32,
+      end_column: readU32
+    )
+  end
+
+  # The Record type TracePoint.
+
+  def readTypeTracePoint
+    TracePoint.new(
+      message: readString,
+      location: readOptionalTypeSourceLocation
+    )
+  end
+
+  # The Record type ZipLimits.
+
+  def readTypeZipLimits
+    ZipLimits.new(
+      max_entries: readOptionalu64,
+      max_total_decompressed_bytes: readOptionalu64
+    )
+  end
+
+  
+  
+  # The Enum type CompilationMode.
+
+  def readTypeCompilationMode
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return CompilationMode::DEVELOPMENT
+    end
+    if variant == 2
+      return CompilationMode::PRODUCTION
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeCompilationMode'
+  end
+
+  
+
+  
+  
+  # The Enum type DiagnosticColor.
+
+  def readTypeDiagnosticColor
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return DiagnosticColor::NONE
+    end
+    if variant == 2
+      return DiagnosticColor::ANSI
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeDiagnosticColor'
+  end
+
+  
+
+  
+  
+  # The Enum type DiagnosticSeverity.
+
+  def readTypeDiagnosticSeverity
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return DiagnosticSeverity::ERROR
+    end
+    if variant == 2
+      return DiagnosticSeverity::WARNING
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeDiagnosticSeverity'
+  end
+
+  
+
+  
+  
+  # The Enum type ExportFormat.
+
+  def readTypeExportFormat
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return ExportFormat::PDF.new
+        
+    end
+    if variant == 2
+        return ExportFormat::PNG.new(
+            self.readF32()
+        )
+    end
+    if variant == 3
+        return ExportFormat::SVG.new
+        
+    end
+    raise InternalError, 'Unexpected variant tag for TypeExportFormat'
+  end
+
+  
+
+  
+
+  
+
+  # The Error type OicanaError
+
+  def readTypeOicanaError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return OicanaError::InvalidTemplate.new(
+            readString()
+        )
+    end
+    if variant == 2
+        return OicanaError::InvalidInput.new(
+            readString()
+        )
+    end
+    if variant == 3
+        return OicanaError::Compilation.new(
+            readString()
+        )
+    end
+    if variant == 4
+        return OicanaError::FileNotFound.new(
+            readString()
+        )
+    end
+    if variant == 5
+        return OicanaError::Export.new(
+            readString()
+        )
+    end
+    if variant == 6
+        return OicanaError::NotFound.new(
+            readString()
+        )
+    end
+    if variant == 7
+        return OicanaError::Internal.new(
+            readString()
+        )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeOicanaError'
+  end
+  
+
+  # The Optional<T> type for u64.
+
+  def readOptionalu64
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readU64
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalu64'
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def readOptionalstring
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readString
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalstring'
+    end
+  end
+
+  # The Optional<T> type for TypePageRange.
+
+  def readOptionalTypePageRange
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypePageRange
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypePageRange'
+    end
+  end
+
+  # The Optional<T> type for TypeSourceLocation.
+
+  def readOptionalTypeSourceLocation
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeSourceLocation
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeSourceLocation'
+    end
+  end
+
+  # The Optional<T> type for TypeZipLimits.
+
+  def readOptionalTypeZipLimits
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeZipLimits
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeZipLimits'
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def readSequencestring
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readString
+    end
+
+    items
+  end
+
+  # The Sequence<T> type for bytes.
+
+  def readSequencebytes
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readBytes
+    end
+
+    items
+  end
+
+  # The Sequence<T> type for TypeDiagnostic.
+
+  def readSequenceTypeDiagnostic
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readTypeDiagnostic
+    end
+
+    items
+  end
+
+  # The Sequence<T> type for TypePageSize.
+
+  def readSequenceTypePageSize
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readTypePageSize
+    end
+
+    items
+  end
+
+  # The Sequence<T> type for TypeRegisteredFont.
+
+  def readSequenceTypeRegisteredFont
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readTypeRegisteredFont
+    end
+
+    items
+  end
+
+  # The Sequence<T> type for TypeTracePoint.
+
+  def readSequenceTypeTracePoint
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readTypeTracePoint
+    end
+
+    items
+  end
+
+  # The Map<T> type for string.
+
+  def readMapStringString
+    count = unpack_from 4, 'l>'
+    raise InternalError, 'Unexpected negative map size' if count.negative?
+
+    items = {}
+    count.times do
+      key = readString
+      items[key] = readString
+    end
+
+    items
+  end# The Map<T> type for TypeBlobInput.
+
+  def readMapStringTypeBlobInput
+    count = unpack_from 4, 'l>'
+    raise InternalError, 'Unexpected negative map size' if count.negative?
+
+    items = {}
+    count.times do
+      key = readString
+      items[key] = readTypeBlobInput
+    end
+
+    items
+  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_U32(v)
+    v = OicanaUniffi::uniffi_in_range(v, "u32", 0, 2**32)
+    pack_into(4, 'L>', v)
+  end
+
+  def write_U64(v)
+    v = OicanaUniffi::uniffi_in_range(v, "u64", 0, 2**64)
+    pack_into(8, 'Q>', v)
+  end
+
+  def write_F32(v)
+    pack_into(4, 'g', v)
+  end
+
+  def write_F64(v)
+    pack_into(8, 'G', v)
+  end
+
+  def write_Bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  def write_String(v)
+    v = OicanaUniffi::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  def write_Bytes(v)
+    v = OicanaUniffi::uniffi_bytes(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Object type CompiledDocument.
+
+  def write_TypeCompiledDocument(obj)
+    handle = CompiledDocument.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Object type Template.
+
+  def write_TypeTemplate(obj)
+    handle = Template.uniffi_lower obj
+    pack_into(8, 'Q>', handle)
+  end
+
+  # The Record type BlobInput.
+
+  def write_TypeBlobInput(v)
+    self.write_Bytes(v.data)
+    self.write_String(v.metadata)
+  end
+
+  # The Record type Diagnostic.
+
+  def write_TypeDiagnostic(v)
+    self.write_TypeDiagnosticSeverity(v.severity)
+    self.write_String(v.message)
+    self.write_OptionalTypeSourceLocation(v.location)
+    self.write_Sequencestring(v.hints)
+    self.write_SequenceTypeTracePoint(v.trace)
+    self.write_String(v.formatted)
+  end
+
+  # The Record type ExportOnceResult.
+
+  def write_TypeExportOnceResult(v)
+    self.write_Bytes(v.bytes)
+    self.write_SequenceTypeDiagnostic(v.warnings)
+  end
+
+  # The Record type PageRange.
+
+  def write_TypePageRange(v)
+    self.write_Optionalu64(v.start)
+    self.write_Optionalu64(v._end)
+  end
+
+  # The Record type PageSize.
+
+  def write_TypePageSize(v)
+    self.write_F64(v.width)
+    self.write_F64(v.height)
+  end
+
+  # The Record type RegisteredFont.
+
+  def write_TypeRegisteredFont(v)
+    self.write_String(v.family)
+    self.write_Optionalstring(v.path)
+  end
+
+  # The Record type SourceLocation.
+
+  def write_TypeSourceLocation(v)
+    self.write_String(v.file)
+    self.write_U32(v.line)
+    self.write_U32(v.column)
+    self.write_U32(v.end_line)
+    self.write_U32(v.end_column)
+  end
+
+  # The Record type TracePoint.
+
+  def write_TypeTracePoint(v)
+    self.write_String(v.message)
+    self.write_OptionalTypeSourceLocation(v.location)
+  end
+
+  # The Record type ZipLimits.
+
+  def write_TypeZipLimits(v)
+    self.write_Optionalu64(v.max_entries)
+    self.write_Optionalu64(v.max_total_decompressed_bytes)
+  end
+
+  # The Enum type CompilationMode.
+
+  def write_TypeCompilationMode(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type DiagnosticColor.
+
+  def write_TypeDiagnosticColor(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type DiagnosticSeverity.
+
+  def write_TypeDiagnosticSeverity(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type ExportFormat.
+
+  def write_TypeExportFormat(v)
+    if v.pdf?
+      pack_into(4, 'l>', 1)
+    end
+    if v.png?
+      pack_into(4, 'l>', 2)
+      self.write_F32(v.pixels_per_pt)
+    end
+    if v.svg?
+      pack_into(4, 'l>', 3)
+    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 TypePageRange.
+
+  def write_OptionalTypePageRange(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypePageRange(v)
+    end
+  end
+
+  # The Optional<T> type for TypeSourceLocation.
+
+  def write_OptionalTypeSourceLocation(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeSourceLocation(v)
+    end
+  end
+
+  # The Optional<T> type for TypeZipLimits.
+
+  def write_OptionalTypeZipLimits(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeZipLimits(v)
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def write_Sequencestring(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_String(item)
+    end
+  end
+
+  # The Sequence<T> type for bytes.
+
+  def write_Sequencebytes(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_Bytes(item)
+    end
+  end
+
+  # The Sequence<T> type for TypeDiagnostic.
+
+  def write_SequenceTypeDiagnostic(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_TypeDiagnostic(item)
+    end
+  end
+
+  # The Sequence<T> type for TypePageSize.
+
+  def write_SequenceTypePageSize(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_TypePageSize(item)
+    end
+  end
+
+  # The Sequence<T> type for TypeRegisteredFont.
+
+  def write_SequenceTypeRegisteredFont(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_TypeRegisteredFont(item)
+    end
+  end
+
+  # The Sequence<T> type for TypeTracePoint.
+
+  def write_SequenceTypeTracePoint(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_TypeTracePoint(item)
+    end
+  end
+
+  # The Map<T> type for string.
+
+  def write_MapStringString(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |k, v|
+      write_String(k)
+      self.write_String(v)
+    end
+  end# The Map<T> type for TypeBlobInput.
+
+  def write_MapStringTypeBlobInput(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |k, v|
+      write_String(k)
+      self.write_TypeBlobInput(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 OicanaError
+  class InvalidTemplate < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class InvalidInput < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class Compilation < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class FileNotFound < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class Export < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class NotFound < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class Internal < 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 = {
+
+  OicanaError => :readTypeOicanaError,
+
+
+
+
+
+}
+
+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]
+    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.consumeIntoString()
+    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 ::Oicana::Native.prepare(self)
+  
+
+  attach_function :uniffi_oicana_uniffi_fn_clone_compileddocument,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_oicana_uniffi_fn_free_compileddocument,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_oicana_uniffi_fn_method_compileddocument_export,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_method_compileddocument_pages,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_method_compileddocument_warnings,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_clone_template,
+    [:uint64, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_oicana_uniffi_fn_free_template,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_oicana_uniffi_fn_constructor_template_new,
+    [RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_oicana_uniffi_fn_method_template_compile,
+    [:uint64, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_oicana_uniffi_fn_method_template_file,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_method_template_manifest,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_method_template_set_validate_inputs,
+    [:uint64, :int8, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_oicana_uniffi_fn_method_template_source,
+    [:uint64, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_method_template_warnings,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_func_clear_fonts,
+    [RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_oicana_uniffi_fn_func_configure_automatic_cache_eviction,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_oicana_uniffi_fn_func_configure_diagnostic_color,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_oicana_uniffi_fn_func_evict_cache,
+    [:uint64, RustCallStatus.by_ref],
+    :void
+  attach_function :uniffi_oicana_uniffi_fn_func_export_once,
+    [RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_func_register_font_paths,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_oicana_uniffi_fn_func_register_fonts,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_oicana_uniffi_fn_func_registered_fonts,
+    [RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_fn_func_version,
+    [RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_oicana_uniffi_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_oicana_uniffi_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_oicana_uniffi_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :ffi_oicana_uniffi_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_oicana_uniffi_checksum_func_clear_fonts,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_configure_automatic_cache_eviction,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_configure_diagnostic_color,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_evict_cache,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_export_once,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_register_font_paths,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_register_fonts,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_registered_fonts,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_func_version,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_compileddocument_export,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_compileddocument_pages,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_compileddocument_warnings,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_template_compile,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_template_file,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_template_manifest,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_template_set_validate_inputs,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_template_source,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_method_template_warnings,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_oicana_uniffi_checksum_constructor_template_new,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :ffi_oicana_uniffi_uniffi_contract_version,
+    [RustCallStatus.by_ref],
+    :uint32
+  
+end
+
+  # Public interface members begin here.
+
+  
+  
+  
+  
+
+class CompilationMode
+  DEVELOPMENT = 1
+  PRODUCTION = 2
+  
+end
+
+
+  
+  
+  
+
+class DiagnosticColor
+  NONE = 1
+  ANSI = 2
+  
+end
+
+
+  
+  
+  
+
+class DiagnosticSeverity
+  ERROR = 1
+  WARNING = 2
+  
+end
+
+
+  
+  
+  
+
+class ExportFormat
+  def initialize
+    raise RuntimeError, 'ExportFormat cannot be instantiated directly'
+  end
+
+  # Each enum variant is a nested class of the enum itself.
+  class PDF
+    
+    def initialize()
+      
+      
+    end
+
+    def to_s
+      "ExportFormat::PDF()"
+    end
+
+    def ==(other)
+      if !other.pdf?
+        return false
+      end
+
+      true
+    end
+
+    # For each variant, we have an `NAME?` method for easily checking
+    # whether an instance is that variant.
+    
+    def pdf?
+      instance_of? ExportFormat::PDF
+    end
+    
+    def png?
+      instance_of? ExportFormat::PNG
+    end
+    
+    def svg?
+      instance_of? ExportFormat::SVG
+    end
+    
+  end
+  class PNG
+    
+    attr_reader :pixels_per_pt
+    
+    def initialize(pixels_per_pt)
+      
+      @pixels_per_pt = pixels_per_pt
+      
+    end
+
+    def to_s
+      "ExportFormat::PNG(pixels_per_pt=#{@pixels_per_pt})"
+    end
+
+    def ==(other)
+      if !other.png?
+        return false
+      end
+      if @pixels_per_pt != other.pixels_per_pt
+        return false
+      end
+
+      true
+    end
+
+    # For each variant, we have an `NAME?` method for easily checking
+    # whether an instance is that variant.
+    
+    def pdf?
+      instance_of? ExportFormat::PDF
+    end
+    
+    def png?
+      instance_of? ExportFormat::PNG
+    end
+    
+    def svg?
+      instance_of? ExportFormat::SVG
+    end
+    
+  end
+  class SVG
+    
+    def initialize()
+      
+      
+    end
+
+    def to_s
+      "ExportFormat::SVG()"
+    end
+
+    def ==(other)
+      if !other.svg?
+        return false
+      end
+
+      true
+    end
+
+    # For each variant, we have an `NAME?` method for easily checking
+    # whether an instance is that variant.
+    
+    def pdf?
+      instance_of? ExportFormat::PDF
+    end
+    
+    def png?
+      instance_of? ExportFormat::PNG
+    end
+    
+    def svg?
+      instance_of? ExportFormat::SVG
+    end
+    
+  end
+  
+end
+
+
+  
+  # Record type BlobInput
+class BlobInput
+  attr_reader :data, :metadata
+
+  def initialize(data:, metadata: "{}")
+    @data = data
+    @metadata = metadata
+  end
+
+  def ==(other)
+    if @data != other.data
+      return false
+    end
+    if @metadata != other.metadata
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type Diagnostic
+class Diagnostic
+  attr_reader :severity, :message, :location, :hints, :trace, :formatted
+
+  def initialize(severity:, message:, location:, hints:, trace:, formatted:)
+    @severity = severity
+    @message = message
+    @location = location
+    @hints = hints
+    @trace = trace
+    @formatted = formatted
+  end
+
+  def ==(other)
+    if @severity != other.severity
+      return false
+    end
+    if @message != other.message
+      return false
+    end
+    if @location != other.location
+      return false
+    end
+    if @hints != other.hints
+      return false
+    end
+    if @trace != other.trace
+      return false
+    end
+    if @formatted != other.formatted
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type ExportOnceResult
+class ExportOnceResult
+  attr_reader :bytes, :warnings
+
+  def initialize(bytes:, warnings:)
+    @bytes = bytes
+    @warnings = warnings
+  end
+
+  def ==(other)
+    if @bytes != other.bytes
+      return false
+    end
+    if @warnings != other.warnings
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type PageRange
+class PageRange
+  attr_reader :start, :_end
+
+  def initialize(start: nil, _end: nil)
+    @start = start
+    @_end = _end
+  end
+
+  def ==(other)
+    if @start != other.start
+      return false
+    end
+    if @_end != other._end
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type PageSize
+class PageSize
+  attr_reader :width, :height
+
+  def initialize(width:, height:)
+    @width = width
+    @height = height
+  end
+
+  def ==(other)
+    if @width != other.width
+      return false
+    end
+    if @height != other.height
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type RegisteredFont
+class RegisteredFont
+  attr_reader :family, :path
+
+  def initialize(family:, path:)
+    @family = family
+    @path = path
+  end
+
+  def ==(other)
+    if @family != other.family
+      return false
+    end
+    if @path != other.path
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type SourceLocation
+class SourceLocation
+  attr_reader :file, :line, :column, :end_line, :end_column
+
+  def initialize(file:, line:, column:, end_line:, end_column:)
+    @file = file
+    @line = line
+    @column = column
+    @end_line = end_line
+    @end_column = end_column
+  end
+
+  def ==(other)
+    if @file != other.file
+      return false
+    end
+    if @line != other.line
+      return false
+    end
+    if @column != other.column
+      return false
+    end
+    if @end_line != other.end_line
+      return false
+    end
+    if @end_column != other.end_column
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type TracePoint
+class TracePoint
+  attr_reader :message, :location
+
+  def initialize(message:, location:)
+    @message = message
+    @location = location
+  end
+
+  def ==(other)
+    if @message != other.message
+      return false
+    end
+    if @location != other.location
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type ZipLimits
+class ZipLimits
+  attr_reader :max_entries, :max_total_decompressed_bytes
+
+  def initialize(max_entries: nil, max_total_decompressed_bytes: nil)
+    @max_entries = max_entries
+    @max_total_decompressed_bytes = max_total_decompressed_bytes
+  end
+
+  def ==(other)
+    if @max_entries != other.max_entries
+      return false
+    end
+    if @max_total_decompressed_bytes != other.max_total_decompressed_bytes
+      return false
+    end
+
+    true
+  end
+end
+  
+
+  
+  
+
+def self.clear_fonts()
+  OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_clear_fonts,)
+end
+
+  
+  
+
+def self.configure_automatic_cache_eviction(max_age)
+    max_age = (max_age ? OicanaUniffi::uniffi_in_range(max_age, "u64", 0, 2**64) : nil)
+    RustBuffer.check_lower_Optionalu64(max_age)
+    
+  OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_configure_automatic_cache_eviction,RustBuffer.alloc_from_Optionalu64(max_age))
+end
+
+  
+  
+
+def self.configure_diagnostic_color(color)
+    color = color
+    RustBuffer.check_lower_TypeDiagnosticColor(color)
+    
+  OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_configure_diagnostic_color,RustBuffer.alloc_from_TypeDiagnosticColor(color))
+end
+
+  
+  
+
+def self.evict_cache(max_age)
+    max_age = OicanaUniffi::uniffi_in_range(max_age, "u64", 0, 2**64)
+    
+    
+  OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_evict_cache,max_age)
+end
+
+  
+  
+
+def self.export_once(files, json_inputs, blob_inputs, mode, format, pages = nil, limits = nil)
+    files = OicanaUniffi::uniffi_bytes(files)
+    
+    
+    json_inputs = json_inputs.each.with_object({}) { |(k, v), res| res[OicanaUniffi::uniffi_utf8(k)] = OicanaUniffi::uniffi_utf8(v) }
+    RustBuffer.check_lower_MapStringString(json_inputs)
+    
+    blob_inputs = blob_inputs.each.with_object({}) { |(k, v), res| res[OicanaUniffi::uniffi_utf8(k)] = v }
+    RustBuffer.check_lower_MapStringTypeBlobInput(blob_inputs)
+    
+    mode = mode
+    RustBuffer.check_lower_TypeCompilationMode(mode)
+    
+    format = format
+    RustBuffer.check_lower_TypeExportFormat(format)
+    
+    pages = (pages ? pages : nil)
+    RustBuffer.check_lower_OptionalTypePageRange(pages)
+    
+    limits = (limits ? limits : nil)
+    RustBuffer.check_lower_OptionalTypeZipLimits(limits)
+    
+  result = OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_func_export_once,RustBuffer.allocFromBytes(files),RustBuffer.alloc_from_MapStringString(json_inputs),RustBuffer.alloc_from_MapStringTypeBlobInput(blob_inputs),RustBuffer.alloc_from_TypeCompilationMode(mode),RustBuffer.alloc_from_TypeExportFormat(format),RustBuffer.alloc_from_OptionalTypePageRange(pages),RustBuffer.alloc_from_OptionalTypeZipLimits(limits))
+  return result.consumeIntoTypeExportOnceResult
+end
+
+
+  
+  
+
+def self.register_font_paths(paths)
+    paths = paths.map { |v| OicanaUniffi::uniffi_utf8(v) }
+    RustBuffer.check_lower_Sequencestring(paths)
+    
+  result = OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_register_font_paths,RustBuffer.alloc_from_Sequencestring(paths))
+  return result.to_i
+end
+
+
+  
+  
+
+def self.register_fonts(fonts)
+    fonts = fonts.map { |v| OicanaUniffi::uniffi_bytes(v) }
+    RustBuffer.check_lower_Sequencebytes(fonts)
+    
+  result = OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_register_fonts,RustBuffer.alloc_from_Sequencebytes(fonts))
+  return result.to_i
+end
+
+
+  
+  
+
+def self.registered_fonts()
+  result = OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_registered_fonts,)
+  return result.consumeIntoSequenceTypeRegisteredFont
+end
+
+
+  
+  
+
+def self.version()
+  result = OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_func_version,)
+  return result.consumeIntoString
+end
+
+
+  
+
+  
+  class CompiledDocument
+
+  # 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|
+      OicanaUniffi.rust_call(
+        :uniffi_oicana_uniffi_fn_free_compileddocument,
+        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 not inst.is_a? self
+      raise TypeError.new "Expected a CompiledDocument instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return OicanaUniffi.rust_call(
+      :uniffi_oicana_uniffi_fn_clone_compileddocument,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+
+  
+
+  def export(format, pages = nil)
+        format = format
+        RustBuffer.check_lower_TypeExportFormat(format)
+        pages = (pages ? pages : nil)
+        RustBuffer.check_lower_OptionalTypePageRange(pages)
+    result = OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_method_compileddocument_export,uniffi_clone_handle(),RustBuffer.alloc_from_TypeExportFormat(format),RustBuffer.alloc_from_OptionalTypePageRange(pages))
+    return result.consumeIntoBytes
+  end
+  def pages()
+    result = OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_method_compileddocument_pages,uniffi_clone_handle(),)
+    return result.consumeIntoSequenceTypePageSize
+  end
+  def warnings()
+    result = OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_method_compileddocument_warnings,uniffi_clone_handle(),)
+    return result.consumeIntoSequenceTypeDiagnostic
+  end
+  
+end
+  
+  class Template
+
+  # 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|
+      OicanaUniffi.rust_call(
+        :uniffi_oicana_uniffi_fn_free_template,
+        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 not inst.is_a? self
+      raise TypeError.new "Expected a Template instance, got #{inst}"
+    end
+  end
+
+  def uniffi_clone_handle()
+    return OicanaUniffi.rust_call(
+      :uniffi_oicana_uniffi_fn_clone_template,
+      @handle
+    )
+  end
+
+  def self.uniffi_lower(inst)
+    return inst.uniffi_clone_handle()
+  end
+  def initialize(files, json_inputs, blob_inputs, mode, limits = nil)
+        files = OicanaUniffi::uniffi_bytes(files)
+        
+        json_inputs = json_inputs.each.with_object({}) { |(k, v), res| res[OicanaUniffi::uniffi_utf8(k)] = OicanaUniffi::uniffi_utf8(v) }
+        RustBuffer.check_lower_MapStringString(json_inputs)
+        blob_inputs = blob_inputs.each.with_object({}) { |(k, v), res| res[OicanaUniffi::uniffi_utf8(k)] = v }
+        RustBuffer.check_lower_MapStringTypeBlobInput(blob_inputs)
+        mode = mode
+        RustBuffer.check_lower_TypeCompilationMode(mode)
+        limits = (limits ? limits : nil)
+        RustBuffer.check_lower_OptionalTypeZipLimits(limits)
+    handle = OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_constructor_template_new,RustBuffer.allocFromBytes(files),RustBuffer.alloc_from_MapStringString(json_inputs),RustBuffer.alloc_from_MapStringTypeBlobInput(blob_inputs),RustBuffer.alloc_from_TypeCompilationMode(mode),RustBuffer.alloc_from_OptionalTypeZipLimits(limits))
+    @handle = handle
+    ObjectSpace.define_finalizer(self, self.class.uniffi_define_finalizer_by_handle(handle, self.object_id))
+  end
+
+  
+
+  def compile(json_inputs, blob_inputs, mode)
+        json_inputs = json_inputs.each.with_object({}) { |(k, v), res| res[OicanaUniffi::uniffi_utf8(k)] = OicanaUniffi::uniffi_utf8(v) }
+        RustBuffer.check_lower_MapStringString(json_inputs)
+        blob_inputs = blob_inputs.each.with_object({}) { |(k, v), res| res[OicanaUniffi::uniffi_utf8(k)] = v }
+        RustBuffer.check_lower_MapStringTypeBlobInput(blob_inputs)
+        mode = mode
+        RustBuffer.check_lower_TypeCompilationMode(mode)
+    result = OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_method_template_compile,uniffi_clone_handle(),RustBuffer.alloc_from_MapStringString(json_inputs),RustBuffer.alloc_from_MapStringTypeBlobInput(blob_inputs),RustBuffer.alloc_from_TypeCompilationMode(mode))
+    return CompiledDocument.uniffi_allocate(result)
+  end
+  def file(path)
+        path = OicanaUniffi::uniffi_utf8(path)
+        
+    result = OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_method_template_file,uniffi_clone_handle(),RustBuffer.allocFromString(path))
+    return result.consumeIntoBytes
+  end
+  def manifest()
+    result = OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_method_template_manifest,uniffi_clone_handle(),)
+    return result.consumeIntoString
+  end
+  def set_validate_inputs(validate)
+        validate = validate ? true : false
+        
+      OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_method_template_set_validate_inputs,uniffi_clone_handle(),(validate ? 1 : 0))
+  end
+  
+  def source(path)
+        path = OicanaUniffi::uniffi_utf8(path)
+        
+    result = OicanaUniffi.rust_call_with_error(OicanaError,:uniffi_oicana_uniffi_fn_method_template_source,uniffi_clone_handle(),RustBuffer.allocFromString(path))
+    return result.consumeIntoString
+  end
+  def warnings()
+    result = OicanaUniffi.rust_call(:uniffi_oicana_uniffi_fn_method_template_warnings,uniffi_clone_handle(),)
+    return result.consumeIntoSequenceTypeDiagnostic
+  end
+  
+end
+  
+end
+