k9o 1.0.0-aarch64-linux

data/lib/k9o/_ffi/kibo_kms_rest_ffi.rb

@@ -0,0 +1,1912 @@
+# 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 KiboKmsRestFfi
+  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 KiboKmsRestFfi.rust_call(:ffi_kibo_kms_rest_ffi_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return KiboKmsRestFfi.rust_call(:ffi_kibo_kms_rest_ffi_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    KiboKmsRestFfi.rust_call(:ffi_kibo_kms_rest_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.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 DecryptInput.
+
+  def self.check_lower_TypeDecryptInput(v)
+    RustBuffer.check_lower_TypeFfiCredential(v.kms_cred)
+    RustBuffer.check_lower_TypeFfiProviderConfig(v.provider_config)
+    
+    RustBuffer.check_lower_TypeFfiStrategy(v.strategy)
+    RustBuffer.check_lower_TypeFfiAttestationTier(v.attestation_tier)
+    RustBuffer.check_lower_SequenceTypeFfiKvPair(v.encryption_context)
+  end
+
+  def self.alloc_from_TypeDecryptInput(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeDecryptInput(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeDecryptInput
+    consumeWithStream do |stream|
+      return stream.readTypeDecryptInput
+    end
+  end
+
+  # The Record type DecryptOutput.
+
+  def self.check_lower_TypeDecryptOutput(v)
+    
+  end
+
+  def self.alloc_from_TypeDecryptOutput(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeDecryptOutput(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeDecryptOutput
+    consumeWithStream do |stream|
+      return stream.readTypeDecryptOutput
+    end
+  end
+
+  # The Record type EncryptInput.
+
+  def self.check_lower_TypeEncryptInput(v)
+    RustBuffer.check_lower_TypeKmsProvider(v.provider)
+    RustBuffer.check_lower_TypeFfiPosture(v.posture)
+    RustBuffer.check_lower_OptionalTypeFfiStrategy(v.strategy)
+    RustBuffer.check_lower_OptionalTypeFfiOracleMode(v.oracle_mode)
+    RustBuffer.check_lower_TypeFfiCredential(v.kms_cred)
+    RustBuffer.check_lower_TypeFfiKeyRef(v.key_ref)
+    RustBuffer.check_lower_TypeFfiProviderConfig(v.provider_config)
+    RustBuffer.check_lower_TypeFfiAttestationTier(v.attestation_tier)
+    RustBuffer.check_lower_SequenceTypeFfiKvPair(v.encryption_context)
+    
+    RustBuffer.check_lower_OptionalTypeFfiPosturePolicy(v.posture_policy)
+  end
+
+  def self.alloc_from_TypeEncryptInput(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeEncryptInput(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeEncryptInput
+    consumeWithStream do |stream|
+      return stream.readTypeEncryptInput
+    end
+  end
+
+  # The Record type EncryptOutput.
+
+  def self.check_lower_TypeEncryptOutput(v)
+    
+  end
+
+  def self.alloc_from_TypeEncryptOutput(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeEncryptOutput(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeEncryptOutput
+    consumeWithStream do |stream|
+      return stream.readTypeEncryptOutput
+    end
+  end
+
+  # The Record type FfiAllowedOracleModes.
+
+  def self.check_lower_TypeFfiAllowedOracleModes(v)
+    
+    
+  end
+
+  def self.alloc_from_TypeFfiAllowedOracleModes(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiAllowedOracleModes(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiAllowedOracleModes
+    consumeWithStream do |stream|
+      return stream.readTypeFfiAllowedOracleModes
+    end
+  end
+
+  # The Record type FfiCredential.
+
+  def self.check_lower_TypeFfiCredential(v)
+    
+    
+  end
+
+  def self.alloc_from_TypeFfiCredential(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiCredential(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiCredential
+    consumeWithStream do |stream|
+      return stream.readTypeFfiCredential
+    end
+  end
+
+  # The Record type FfiKeyRef.
+
+  def self.check_lower_TypeFfiKeyRef(v)
+    
+    
+  end
+
+  def self.alloc_from_TypeFfiKeyRef(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiKeyRef(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiKeyRef
+    consumeWithStream do |stream|
+      return stream.readTypeFfiKeyRef
+    end
+  end
+
+  # The Record type FfiKvPair.
+
+  def self.check_lower_TypeFfiKvPair(v)
+    
+    
+  end
+
+  def self.alloc_from_TypeFfiKvPair(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiKvPair(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiKvPair
+    consumeWithStream do |stream|
+      return stream.readTypeFfiKvPair
+    end
+  end
+
+  # The Record type FfiPosturePolicy.
+
+  def self.check_lower_TypeFfiPosturePolicy(v)
+    RustBuffer.check_lower_OptionalTypeFfiMinPosture(v.min_custody_posture)
+    RustBuffer.check_lower_OptionalTypeFfiAllowedOracleModes(v.allowed_oracle_modes)
+  end
+
+  def self.alloc_from_TypeFfiPosturePolicy(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiPosturePolicy(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiPosturePolicy
+    consumeWithStream do |stream|
+      return stream.readTypeFfiPosturePolicy
+    end
+  end
+
+  # The Record type FfiProviderConfig.
+
+  def self.check_lower_TypeFfiProviderConfig(v)
+    RustBuffer.check_lower_Optionalstring(v.aws_region)
+    RustBuffer.check_lower_Optionalstring(v.vault_address)
+  end
+
+  def self.alloc_from_TypeFfiProviderConfig(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiProviderConfig(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiProviderConfig
+    consumeWithStream do |stream|
+      return stream.readTypeFfiProviderConfig
+    end
+  end
+
+  # The Enum type FfiAttestationTier.
+
+  def self.check_lower_TypeFfiAttestationTier(v)
+  end
+
+  def self.alloc_from_TypeFfiAttestationTier(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiAttestationTier(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiAttestationTier
+    consumeWithStream do |stream|
+      return stream.readTypeFfiAttestationTier
+    end
+  end
+  
+
+  # The Enum type FfiMinPosture.
+
+  def self.check_lower_TypeFfiMinPosture(v)
+  end
+
+  def self.alloc_from_TypeFfiMinPosture(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiMinPosture(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiMinPosture
+    consumeWithStream do |stream|
+      return stream.readTypeFfiMinPosture
+    end
+  end
+  
+
+  # The Enum type FfiOracleMode.
+
+  def self.check_lower_TypeFfiOracleMode(v)
+  end
+
+  def self.alloc_from_TypeFfiOracleMode(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiOracleMode(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiOracleMode
+    consumeWithStream do |stream|
+      return stream.readTypeFfiOracleMode
+    end
+  end
+  
+
+  # The Enum type FfiPosture.
+
+  def self.check_lower_TypeFfiPosture(v)
+  end
+
+  def self.alloc_from_TypeFfiPosture(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiPosture(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiPosture
+    consumeWithStream do |stream|
+      return stream.readTypeFfiPosture
+    end
+  end
+  
+
+  # The Enum type FfiStrategy.
+
+  def self.check_lower_TypeFfiStrategy(v)
+  end
+
+  def self.alloc_from_TypeFfiStrategy(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeFfiStrategy(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeFfiStrategy
+    consumeWithStream do |stream|
+      return stream.readTypeFfiStrategy
+    end
+  end
+  
+
+  # The Enum type KmsProvider.
+
+  def self.check_lower_TypeKmsProvider(v)
+  end
+
+  def self.alloc_from_TypeKmsProvider(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeKmsProvider(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeKmsProvider
+    consumeWithStream do |stream|
+      return stream.readTypeKmsProvider
+    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 TypeFfiAllowedOracleModes.
+
+  def self.check_lower_OptionalTypeFfiAllowedOracleModes(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeFfiAllowedOracleModes(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeFfiAllowedOracleModes(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeFfiAllowedOracleModes(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeFfiAllowedOracleModes
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeFfiAllowedOracleModes
+    end
+  end
+
+  # The Optional<T> type for TypeFfiPosturePolicy.
+
+  def self.check_lower_OptionalTypeFfiPosturePolicy(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeFfiPosturePolicy(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeFfiPosturePolicy(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeFfiPosturePolicy(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeFfiPosturePolicy
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeFfiPosturePolicy
+    end
+  end
+
+  # The Optional<T> type for TypeFfiMinPosture.
+
+  def self.check_lower_OptionalTypeFfiMinPosture(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeFfiMinPosture(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeFfiMinPosture(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeFfiMinPosture(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeFfiMinPosture
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeFfiMinPosture
+    end
+  end
+
+  # The Optional<T> type for TypeFfiOracleMode.
+
+  def self.check_lower_OptionalTypeFfiOracleMode(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeFfiOracleMode(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeFfiOracleMode(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeFfiOracleMode(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeFfiOracleMode
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeFfiOracleMode
+    end
+  end
+
+  # The Optional<T> type for TypeFfiStrategy.
+
+  def self.check_lower_OptionalTypeFfiStrategy(v)
+    if not v.nil?
+      RustBuffer.check_lower_TypeFfiStrategy(v)
+    end
+  end
+
+  def self.alloc_from_OptionalTypeFfiStrategy(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeFfiStrategy(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeFfiStrategy
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeFfiStrategy
+    end
+  end
+
+  # The Sequence<T> type for TypeFfiKvPair.
+
+  def self.check_lower_SequenceTypeFfiKvPair(v)
+    v.each do |item|
+      RustBuffer.check_lower_TypeFfiKvPair(item)
+    end
+  end
+
+  def self.alloc_from_SequenceTypeFfiKvPair(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_SequenceTypeFfiKvPair(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequenceTypeFfiKvPair
+    consumeWithStream do |stream|
+      return stream.readSequenceTypeFfiKvPair
+    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 readU64
+    unpack_from 8, 'Q>'
+  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 Record type DecryptInput.
+
+  def readTypeDecryptInput
+    DecryptInput.new(
+      kms_cred: readTypeFfiCredential,
+      provider_config: readTypeFfiProviderConfig,
+      envelope: readBytes,
+      strategy: readTypeFfiStrategy,
+      attestation_tier: readTypeFfiAttestationTier,
+      encryption_context: readSequenceTypeFfiKvPair
+    )
+  end
+
+  # The Record type DecryptOutput.
+
+  def readTypeDecryptOutput
+    DecryptOutput.new(
+      plaintext: readBytes
+    )
+  end
+
+  # The Record type EncryptInput.
+
+  def readTypeEncryptInput
+    EncryptInput.new(
+      provider: readTypeKmsProvider,
+      posture: readTypeFfiPosture,
+      strategy: readOptionalTypeFfiStrategy,
+      oracle_mode: readOptionalTypeFfiOracleMode,
+      kms_cred: readTypeFfiCredential,
+      key_ref: readTypeFfiKeyRef,
+      provider_config: readTypeFfiProviderConfig,
+      attestation_tier: readTypeFfiAttestationTier,
+      encryption_context: readSequenceTypeFfiKvPair,
+      plaintext: readBytes,
+      posture_policy: readOptionalTypeFfiPosturePolicy
+    )
+  end
+
+  # The Record type EncryptOutput.
+
+  def readTypeEncryptOutput
+    EncryptOutput.new(
+      envelope: readBytes
+    )
+  end
+
+  # The Record type FfiAllowedOracleModes.
+
+  def readTypeFfiAllowedOracleModes
+    FfiAllowedOracleModes.new(
+      brokered: readBool,
+      direct: readBool
+    )
+  end
+
+  # The Record type FfiCredential.
+
+  def readTypeFfiCredential
+    FfiCredential.new(
+      secret: readString,
+      expires_at_unix_secs: readU64
+    )
+  end
+
+  # The Record type FfiKeyRef.
+
+  def readTypeFfiKeyRef
+    FfiKeyRef.new(
+      version: readU64,
+      external_ref: readString
+    )
+  end
+
+  # The Record type FfiKvPair.
+
+  def readTypeFfiKvPair
+    FfiKvPair.new(
+      key: readString,
+      value: readString
+    )
+  end
+
+  # The Record type FfiPosturePolicy.
+
+  def readTypeFfiPosturePolicy
+    FfiPosturePolicy.new(
+      min_custody_posture: readOptionalTypeFfiMinPosture,
+      allowed_oracle_modes: readOptionalTypeFfiAllowedOracleModes
+    )
+  end
+
+  # The Record type FfiProviderConfig.
+
+  def readTypeFfiProviderConfig
+    FfiProviderConfig.new(
+      aws_region: readOptionalstring,
+      vault_address: readOptionalstring
+    )
+  end
+
+  
+  
+  # The Enum type FfiAttestationTier.
+
+  def readTypeFfiAttestationTier
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return FfiAttestationTier::SOFTWARE
+    end
+    if variant == 2
+      return FfiAttestationTier::HARDWARE_BACKED
+    end
+    if variant == 3
+      return FfiAttestationTier::CONFIDENTIAL
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeFfiAttestationTier'
+  end
+
+  
+
+  
+  
+  # The Enum type FfiMinPosture.
+
+  def readTypeFfiMinPosture
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return FfiMinPosture::PLATFORM_MANAGED
+    end
+    if variant == 2
+      return FfiMinPosture::BYOK
+    end
+    if variant == 3
+      return FfiMinPosture::HYOK
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeFfiMinPosture'
+  end
+
+  
+
+  
+  
+  # The Enum type FfiOracleMode.
+
+  def readTypeFfiOracleMode
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return FfiOracleMode::BROKERED
+    end
+    if variant == 2
+      return FfiOracleMode::DIRECT
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeFfiOracleMode'
+  end
+
+  
+
+  
+  
+  # The Enum type FfiPosture.
+
+  def readTypeFfiPosture
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return FfiPosture::BYOK
+    end
+    if variant == 2
+      return FfiPosture::HYOK
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeFfiPosture'
+  end
+
+  
+
+  
+  
+  # The Enum type FfiStrategy.
+
+  def readTypeFfiStrategy
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return FfiStrategy::LOCAL_ENVELOPE
+    end
+    if variant == 2
+      return FfiStrategy::CUSTOMER_KMS_ORACLE
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeFfiStrategy'
+  end
+
+  
+
+  
+  
+  # The Enum type KmsProvider.
+
+  def readTypeKmsProvider
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return KmsProvider::AWS_KMS
+    end
+    if variant == 2
+      return KmsProvider::GCP_KMS
+    end
+    if variant == 3
+      return KmsProvider::AZURE_KV
+    end
+    if variant == 4
+      return KmsProvider::HASHICORP_VAULT
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeKmsProvider'
+  end
+
+  
+
+  
+
+  
+
+  # The Error type ZkFfiUniffiError
+
+  def readTypeZkFfiUniffiError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return ZkFfiUniffiError::Platform.new(
+            readString(),
+            readString()
+        )
+    end
+    if variant == 2
+        return ZkFfiUniffiError::UpstreamKms.new(
+            readString()
+        )
+    end
+    if variant == 3
+        return ZkFfiUniffiError::PostureViolation.new(
+            readString(),
+            readString(),
+            readString(),
+            readString(),
+            readString()
+        )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeZkFfiUniffiError'
+  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 TypeFfiAllowedOracleModes.
+
+  def readOptionalTypeFfiAllowedOracleModes
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeFfiAllowedOracleModes
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeFfiAllowedOracleModes'
+    end
+  end
+
+  # The Optional<T> type for TypeFfiPosturePolicy.
+
+  def readOptionalTypeFfiPosturePolicy
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeFfiPosturePolicy
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeFfiPosturePolicy'
+    end
+  end
+
+  # The Optional<T> type for TypeFfiMinPosture.
+
+  def readOptionalTypeFfiMinPosture
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeFfiMinPosture
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeFfiMinPosture'
+    end
+  end
+
+  # The Optional<T> type for TypeFfiOracleMode.
+
+  def readOptionalTypeFfiOracleMode
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeFfiOracleMode
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeFfiOracleMode'
+    end
+  end
+
+  # The Optional<T> type for TypeFfiStrategy.
+
+  def readOptionalTypeFfiStrategy
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeFfiStrategy
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeFfiStrategy'
+    end
+  end
+
+  # The Sequence<T> type for TypeFfiKvPair.
+
+  def readSequenceTypeFfiKvPair
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readTypeFfiKvPair
+    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_U64(v)
+    v = KiboKmsRestFfi::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 = KiboKmsRestFfi::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  def write_Bytes(v)
+    v = KiboKmsRestFfi::uniffi_bytes(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Record type DecryptInput.
+
+  def write_TypeDecryptInput(v)
+    self.write_TypeFfiCredential(v.kms_cred)
+    self.write_TypeFfiProviderConfig(v.provider_config)
+    self.write_Bytes(v.envelope)
+    self.write_TypeFfiStrategy(v.strategy)
+    self.write_TypeFfiAttestationTier(v.attestation_tier)
+    self.write_SequenceTypeFfiKvPair(v.encryption_context)
+  end
+
+  # The Record type DecryptOutput.
+
+  def write_TypeDecryptOutput(v)
+    self.write_Bytes(v.plaintext)
+  end
+
+  # The Record type EncryptInput.
+
+  def write_TypeEncryptInput(v)
+    self.write_TypeKmsProvider(v.provider)
+    self.write_TypeFfiPosture(v.posture)
+    self.write_OptionalTypeFfiStrategy(v.strategy)
+    self.write_OptionalTypeFfiOracleMode(v.oracle_mode)
+    self.write_TypeFfiCredential(v.kms_cred)
+    self.write_TypeFfiKeyRef(v.key_ref)
+    self.write_TypeFfiProviderConfig(v.provider_config)
+    self.write_TypeFfiAttestationTier(v.attestation_tier)
+    self.write_SequenceTypeFfiKvPair(v.encryption_context)
+    self.write_Bytes(v.plaintext)
+    self.write_OptionalTypeFfiPosturePolicy(v.posture_policy)
+  end
+
+  # The Record type EncryptOutput.
+
+  def write_TypeEncryptOutput(v)
+    self.write_Bytes(v.envelope)
+  end
+
+  # The Record type FfiAllowedOracleModes.
+
+  def write_TypeFfiAllowedOracleModes(v)
+    self.write_Bool(v.brokered)
+    self.write_Bool(v.direct)
+  end
+
+  # The Record type FfiCredential.
+
+  def write_TypeFfiCredential(v)
+    self.write_String(v.secret)
+    self.write_U64(v.expires_at_unix_secs)
+  end
+
+  # The Record type FfiKeyRef.
+
+  def write_TypeFfiKeyRef(v)
+    self.write_U64(v.version)
+    self.write_String(v.external_ref)
+  end
+
+  # The Record type FfiKvPair.
+
+  def write_TypeFfiKvPair(v)
+    self.write_String(v.key)
+    self.write_String(v.value)
+  end
+
+  # The Record type FfiPosturePolicy.
+
+  def write_TypeFfiPosturePolicy(v)
+    self.write_OptionalTypeFfiMinPosture(v.min_custody_posture)
+    self.write_OptionalTypeFfiAllowedOracleModes(v.allowed_oracle_modes)
+  end
+
+  # The Record type FfiProviderConfig.
+
+  def write_TypeFfiProviderConfig(v)
+    self.write_Optionalstring(v.aws_region)
+    self.write_Optionalstring(v.vault_address)
+  end
+
+  # The Enum type FfiAttestationTier.
+
+  def write_TypeFfiAttestationTier(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type FfiMinPosture.
+
+  def write_TypeFfiMinPosture(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type FfiOracleMode.
+
+  def write_TypeFfiOracleMode(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type FfiPosture.
+
+  def write_TypeFfiPosture(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type FfiStrategy.
+
+  def write_TypeFfiStrategy(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type KmsProvider.
+
+  def write_TypeKmsProvider(v)
+    pack_into(4, 'l>', v)
+ 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 TypeFfiAllowedOracleModes.
+
+  def write_OptionalTypeFfiAllowedOracleModes(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeFfiAllowedOracleModes(v)
+    end
+  end
+
+  # The Optional<T> type for TypeFfiPosturePolicy.
+
+  def write_OptionalTypeFfiPosturePolicy(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeFfiPosturePolicy(v)
+    end
+  end
+
+  # The Optional<T> type for TypeFfiMinPosture.
+
+  def write_OptionalTypeFfiMinPosture(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeFfiMinPosture(v)
+    end
+  end
+
+  # The Optional<T> type for TypeFfiOracleMode.
+
+  def write_OptionalTypeFfiOracleMode(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeFfiOracleMode(v)
+    end
+  end
+
+  # The Optional<T> type for TypeFfiStrategy.
+
+  def write_OptionalTypeFfiStrategy(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeFfiStrategy(v)
+    end
+  end
+
+  # The Sequence<T> type for TypeFfiKvPair.
+
+  def write_SequenceTypeFfiKvPair(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_TypeFfiKvPair(item)
+    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 ZkFfiUniffiError
+  class Platform < 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 UpstreamKms < StandardError
+    def initialize(message)
+        @message = message
+        super()
+      end
+
+    attr_reader :message
+    
+
+    def to_s
+     "#{self.class.name}(message=#{@message.inspect})"
+    end
+  end
+  class PostureViolation < StandardError
+    def initialize(code, message, dimension, requested, declared)
+        @code = code
+        @message = message
+        @dimension = dimension
+        @requested = requested
+        @declared = declared
+        super()
+      end
+
+    attr_reader :code, :message, :dimension, :requested, :declared
+    
+
+    def to_s
+     "#{self.class.name}(code=#{@code.inspect}, message=#{@message.inspect}, dimension=#{@dimension.inspect}, requested=#{@requested.inspect}, declared=#{@declared.inspect})"
+    end
+  end
+
+end
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+
+
+
+
+
+
+
+  ZkFfiUniffiError => :readTypeZkFfiUniffiError,
+
+}
+
+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 File.expand_path(FFI::Platform::LIBPREFIX + 'kibo_kms_rest_ffi.' + FFI::Platform::LIBSUFFIX, __dir__)
+  
+
+  attach_function :uniffi_kibo_kms_rest_ffi_fn_func_zk_decrypt,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_kibo_kms_rest_ffi_fn_func_zk_decrypt_blocking,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_kibo_kms_rest_ffi_fn_func_zk_encrypt,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :uint64
+  attach_function :uniffi_kibo_kms_rest_ffi_fn_func_zk_encrypt_blocking,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_kibo_kms_rest_ffi_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_kibo_kms_rest_ffi_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_kibo_kms_rest_ffi_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :ffi_kibo_kms_rest_ffi_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_kibo_kms_rest_ffi_checksum_func_zk_decrypt,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_kibo_kms_rest_ffi_checksum_func_zk_decrypt_blocking,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_kibo_kms_rest_ffi_checksum_func_zk_encrypt,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_kibo_kms_rest_ffi_checksum_func_zk_encrypt_blocking,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :ffi_kibo_kms_rest_ffi_uniffi_contract_version,
+    [RustCallStatus.by_ref],
+    :uint32
+  
+end
+
+  # Public interface members begin here.
+
+  
+  
+  
+
+class FfiAttestationTier
+  SOFTWARE = 1
+  HARDWARE_BACKED = 2
+  CONFIDENTIAL = 3
+  
+end
+
+
+  
+  
+  
+
+class FfiMinPosture
+  PLATFORM_MANAGED = 1
+  BYOK = 2
+  HYOK = 3
+  
+end
+
+
+  
+  
+  
+
+class FfiOracleMode
+  BROKERED = 1
+  DIRECT = 2
+  
+end
+
+
+  
+  
+  
+
+class FfiPosture
+  BYOK = 1
+  HYOK = 2
+  
+end
+
+
+  
+  
+  
+
+class FfiStrategy
+  LOCAL_ENVELOPE = 1
+  CUSTOMER_KMS_ORACLE = 2
+  
+end
+
+
+  
+  
+  
+
+class KmsProvider
+  AWS_KMS = 1
+  GCP_KMS = 2
+  AZURE_KV = 3
+  HASHICORP_VAULT = 4
+  
+end
+
+
+  
+  
+  # Record type DecryptInput
+class DecryptInput
+  attr_reader :kms_cred, :provider_config, :envelope, :strategy, :attestation_tier, :encryption_context
+
+  def initialize(kms_cred:, provider_config:, envelope:, strategy:, attestation_tier:, encryption_context:)
+    @kms_cred = kms_cred
+    @provider_config = provider_config
+    @envelope = envelope
+    @strategy = strategy
+    @attestation_tier = attestation_tier
+    @encryption_context = encryption_context
+  end
+
+  def ==(other)
+    if @kms_cred != other.kms_cred
+      return false
+    end
+    if @provider_config != other.provider_config
+      return false
+    end
+    if @envelope != other.envelope
+      return false
+    end
+    if @strategy != other.strategy
+      return false
+    end
+    if @attestation_tier != other.attestation_tier
+      return false
+    end
+    if @encryption_context != other.encryption_context
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type DecryptOutput
+class DecryptOutput
+  attr_reader :plaintext
+
+  def initialize(plaintext:)
+    @plaintext = plaintext
+  end
+
+  def ==(other)
+    if @plaintext != other.plaintext
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type EncryptInput
+class EncryptInput
+  attr_reader :provider, :posture, :strategy, :oracle_mode, :kms_cred, :key_ref, :provider_config, :attestation_tier, :encryption_context, :plaintext, :posture_policy
+
+  def initialize(provider:, posture:, strategy:, oracle_mode:, kms_cred:, key_ref:, provider_config:, attestation_tier:, encryption_context:, plaintext:, posture_policy:)
+    @provider = provider
+    @posture = posture
+    @strategy = strategy
+    @oracle_mode = oracle_mode
+    @kms_cred = kms_cred
+    @key_ref = key_ref
+    @provider_config = provider_config
+    @attestation_tier = attestation_tier
+    @encryption_context = encryption_context
+    @plaintext = plaintext
+    @posture_policy = posture_policy
+  end
+
+  def ==(other)
+    if @provider != other.provider
+      return false
+    end
+    if @posture != other.posture
+      return false
+    end
+    if @strategy != other.strategy
+      return false
+    end
+    if @oracle_mode != other.oracle_mode
+      return false
+    end
+    if @kms_cred != other.kms_cred
+      return false
+    end
+    if @key_ref != other.key_ref
+      return false
+    end
+    if @provider_config != other.provider_config
+      return false
+    end
+    if @attestation_tier != other.attestation_tier
+      return false
+    end
+    if @encryption_context != other.encryption_context
+      return false
+    end
+    if @plaintext != other.plaintext
+      return false
+    end
+    if @posture_policy != other.posture_policy
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type EncryptOutput
+class EncryptOutput
+  attr_reader :envelope
+
+  def initialize(envelope:)
+    @envelope = envelope
+  end
+
+  def ==(other)
+    if @envelope != other.envelope
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type FfiAllowedOracleModes
+class FfiAllowedOracleModes
+  attr_reader :brokered, :direct
+
+  def initialize(brokered:, direct:)
+    @brokered = brokered
+    @direct = direct
+  end
+
+  def ==(other)
+    if @brokered != other.brokered
+      return false
+    end
+    if @direct != other.direct
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type FfiCredential
+class FfiCredential
+  attr_reader :secret, :expires_at_unix_secs
+
+  def initialize(secret:, expires_at_unix_secs:)
+    @secret = secret
+    @expires_at_unix_secs = expires_at_unix_secs
+  end
+
+  def ==(other)
+    if @secret != other.secret
+      return false
+    end
+    if @expires_at_unix_secs != other.expires_at_unix_secs
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type FfiKeyRef
+class FfiKeyRef
+  attr_reader :version, :external_ref
+
+  def initialize(version:, external_ref:)
+    @version = version
+    @external_ref = external_ref
+  end
+
+  def ==(other)
+    if @version != other.version
+      return false
+    end
+    if @external_ref != other.external_ref
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type FfiKvPair
+class FfiKvPair
+  attr_reader :key, :value
+
+  def initialize(key:, value:)
+    @key = key
+    @value = value
+  end
+
+  def ==(other)
+    if @key != other.key
+      return false
+    end
+    if @value != other.value
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type FfiPosturePolicy
+class FfiPosturePolicy
+  attr_reader :min_custody_posture, :allowed_oracle_modes
+
+  def initialize(min_custody_posture:, allowed_oracle_modes:)
+    @min_custody_posture = min_custody_posture
+    @allowed_oracle_modes = allowed_oracle_modes
+  end
+
+  def ==(other)
+    if @min_custody_posture != other.min_custody_posture
+      return false
+    end
+    if @allowed_oracle_modes != other.allowed_oracle_modes
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type FfiProviderConfig
+class FfiProviderConfig
+  attr_reader :aws_region, :vault_address
+
+  def initialize(aws_region:, vault_address:)
+    @aws_region = aws_region
+    @vault_address = vault_address
+  end
+
+  def ==(other)
+    if @aws_region != other.aws_region
+      return false
+    end
+    if @vault_address != other.vault_address
+      return false
+    end
+
+    true
+  end
+end
+  
+
+  
+  
+
+def self.zk_decrypt(input)
+    input = input
+    RustBuffer.check_lower_TypeDecryptInput(input)
+    
+  result = KiboKmsRestFfi.rust_call_with_error(ZkFfiUniffiError,:uniffi_kibo_kms_rest_ffi_fn_func_zk_decrypt,RustBuffer.alloc_from_TypeDecryptInput(input))
+  return result.consumeIntoTypeDecryptOutput
+end
+
+
+  
+  
+
+def self.zk_decrypt_blocking(input)
+    input = input
+    RustBuffer.check_lower_TypeDecryptInput(input)
+    
+  result = KiboKmsRestFfi.rust_call_with_error(ZkFfiUniffiError,:uniffi_kibo_kms_rest_ffi_fn_func_zk_decrypt_blocking,RustBuffer.alloc_from_TypeDecryptInput(input))
+  return result.consumeIntoTypeDecryptOutput
+end
+
+
+  
+  
+
+def self.zk_encrypt(input)
+    input = input
+    RustBuffer.check_lower_TypeEncryptInput(input)
+    
+  result = KiboKmsRestFfi.rust_call_with_error(ZkFfiUniffiError,:uniffi_kibo_kms_rest_ffi_fn_func_zk_encrypt,RustBuffer.alloc_from_TypeEncryptInput(input))
+  return result.consumeIntoTypeEncryptOutput
+end
+
+
+  
+  
+
+def self.zk_encrypt_blocking(input)
+    input = input
+    RustBuffer.check_lower_TypeEncryptInput(input)
+    
+  result = KiboKmsRestFfi.rust_call_with_error(ZkFfiUniffiError,:uniffi_kibo_kms_rest_ffi_fn_func_zk_encrypt_blocking,RustBuffer.alloc_from_TypeEncryptInput(input))
+  return result.consumeIntoTypeEncryptOutput
+end
+
+
+  
+
+  
+end
+