volcano-sdk 0.29.0 → 0.31.0

data/lib/volcano/storage_mutations.rb

@@ -11,7 +11,9 @@ module Volcano
     end
 
     def move(from_path, to_path)
-      source, destination = storage_paths([from_path, to_path])
+      paths = storage_paths([from_path, to_path])
+      source = paths.fetch(0)
+      destination = paths.fetch(1)
       response = storage_request do |token|
         @transport.move_storage_object(
           authorization: token,
@@ -24,7 +26,9 @@ module Volcano
     end
 
     def copy(from_path, to_path)
-      source, destination = storage_paths([from_path, to_path])
+      paths = storage_paths([from_path, to_path])
+      source = paths.fetch(0)
+      destination = paths.fetch(1)
       response = storage_request do |token|
         @transport.copy_storage_object(
           authorization: token,
@@ -75,7 +79,8 @@ module Volcano
     end
 
     def visibility_value(value)
-      return value if [true, false].include?(value)
+      return true if value == true
+      return false if value == false
 
       raise ArgumentError, 'public must be true or false'
     end

data/lib/volcano/storage_object_response.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Validates object metadata and paginated storage responses.
+  module StorageObjectResponse
+    include StorageResponse
+
+    private
+
+    def storage_object(payload)
+      payload = storage_payload(payload)
+      required = storage_object_required(payload)
+      optional = storage_object_optional(payload)
+      StorageObject.new(
+        id: required.fetch(0), bucket_id: required.fetch(1), name: required.fetch(2),
+        size: required.fetch(3), mime_type: required.fetch(4), is_public: required.fetch(5),
+        owner_id: optional.fetch(0), etag: optional.fetch(1), metadata: optional.fetch(2),
+        created_at: optional.fetch(3), updated_at: optional.fetch(4), public_url: optional.fetch(5)
+      )
+    end
+
+    def storage_object_required(payload)
+      [
+        storage_string(payload.fetch('id')), storage_string(payload.fetch('bucket_id')),
+        storage_string(payload.fetch('name')), storage_integer(payload.fetch('size')),
+        storage_string(payload.fetch('mime_type')), storage_boolean(payload.fetch('is_public'))
+      ]
+    end
+
+    def storage_object_optional(payload)
+      [
+        storage_optional_string(payload['owner_id']), storage_optional_string(payload['etag']),
+        storage_optional_metadata(payload['metadata']), storage_optional_time(payload['created_at']),
+        storage_optional_time(payload['updated_at']), storage_optional_string(payload['public_url'])
+      ]
+    end
+
+    def storage_object_list(value)
+      raise Error::TransportError, 'invalid storage objects' unless value.is_a?(Array)
+
+      value.map { |object| storage_object(object) }
+    end
+
+    def storage_cursor(value)
+      return if value.nil? || value == ''
+
+      storage_string(value)
+    end
+
+    def storage_boolean(value)
+      return true if value == true
+      return false if value == false
+
+      raise Error::TransportError, 'invalid storage boolean'
+    end
+
+    def storage_optional_string(value)
+      value.nil? ? nil : storage_string(value)
+    end
+
+    def storage_optional_time(value)
+      value.nil? ? nil : storage_time(value)
+    end
+
+    def storage_optional_metadata(value)
+      value.nil? ? nil : storage_json_hash(value)
+    end
+
+    def storage_json_hash(value)
+      raise Error::TransportError, 'invalid storage JSON object' unless value.is_a?(Hash)
+
+      value.to_h do |key, item|
+        raise Error::TransportError, 'invalid storage JSON key' unless key.is_a?(String)
+
+        [key, storage_json_value(item)]
+      end
+    end
+
+    def storage_json_value(value)
+      case value
+      when NilClass, TrueClass, FalseClass, Integer, Float, String then value
+      when Array then value.map { |item| storage_json_value(item) }
+      when Hash then storage_json_hash(value)
+      else raise Error::TransportError, 'invalid storage JSON value'
+      end
+    end
+  end
+end

data/lib/volcano/storage_response.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Decodes resumable-upload responses before creating public records.
+  module StorageResponse
+    private
+
+    def upload_session(payload)
+      payload = storage_payload(payload)
+      UploadSession.new(
+        session_id: storage_string(payload.fetch('session_id')),
+        part_size: storage_integer(payload.fetch('part_size')),
+        total_parts: storage_integer(payload.fetch('total_parts')),
+        expires_at: storage_time(payload.fetch('expires_at'))
+      )
+    end
+
+    def upload_part_metadata(payload)
+      payload = storage_payload(payload)
+      UploadPart.new(
+        part_number: storage_integer(payload.fetch('part_number')),
+        etag: storage_string(payload.fetch('etag')),
+        size: storage_integer(payload.fetch('size'))
+      )
+    end
+
+    def upload_session_status(payload)
+      payload = storage_payload(payload)
+      text = storage_status_text(payload)
+      counts = storage_status_counts(payload)
+      storage_status_record(payload, text, counts)
+    end
+
+    def storage_status_record(payload, text, counts)
+      UploadSessionStatus.new(
+        session_id: text.fetch(0), status: text.fetch(1), path: text.fetch(2),
+        content_type: text.fetch(3), total_size: counts.fetch(0), part_size: counts.fetch(1),
+        total_parts: counts.fetch(2), parts_uploaded: counts.fetch(3),
+        bytes_uploaded: counts.fetch(4), parts: storage_parts(payload.fetch('parts', [])),
+        expires_at: storage_time(payload.fetch('expires_at')),
+        created_at: storage_time(payload.fetch('created_at'))
+      )
+    end
+
+    def storage_status_text(payload)
+      [
+        storage_string(payload.fetch('session_id')), storage_string(payload.fetch('status')),
+        storage_string(payload.fetch('path')), storage_string(payload.fetch('content_type'))
+      ]
+    end
+
+    def storage_status_counts(payload)
+      [
+        storage_integer(payload.fetch('total_size')), storage_integer(payload.fetch('part_size')),
+        storage_integer(payload.fetch('total_parts')), storage_integer(payload.fetch('parts_uploaded')),
+        storage_integer(payload.fetch('bytes_uploaded'))
+      ]
+    end
+
+    def storage_parts(value)
+      raise Error::TransportError, 'invalid upload parts' unless value.is_a?(Array)
+
+      value.map { |part| upload_part_metadata(part) }
+    end
+
+    def storage_payload(value)
+      raise Error::TransportError, 'invalid storage response' unless value.is_a?(Hash)
+      raise Error::TransportError, 'invalid storage response key' unless value.keys.all?(String)
+
+      value
+    end
+
+    def storage_string(value)
+      raise Error::TransportError, 'invalid storage string' unless value.is_a?(String)
+
+      value
+    end
+
+    def storage_integer(value)
+      raise Error::TransportError, 'invalid storage integer' unless value.is_a?(Integer)
+
+      value
+    end
+
+    def storage_time(value)
+      return value if value.is_a?(Time)
+      return Time.iso8601(value) if value.is_a?(String)
+
+      raise Error::TransportError, 'invalid storage time'
+    end
+  end
+end

data/lib/volcano/storage_resumable_upload.rb

@@ -30,7 +30,7 @@ module Volcano
     def upload_session_parts(path, source, session, total_size, on_progress)
       uploaded = 0
       session.total_parts.times do |part_index|
-        part = source.read(session.part_size)
+        part = source.read(session.part_size) || raise(IOError, 'upload source ended before completion')
         upload_part(
           path,
           session_id: session.session_id,
@@ -64,11 +64,22 @@ module Volcano
     def remaining_upload_bytes(source)
       return unless source.respond_to?(:size) && source.respond_to?(:pos)
 
-      source.size - source.pos
+      dimensions = upload_source_dimensions(source)
+      return unless dimensions
+
+      dimensions.fetch(0) - dimensions.fetch(1)
     rescue IOError, SystemCallError
       nil
     end
 
+    def upload_source_dimensions(source)
+      size = source.method(:size).call
+      position = source.method(:pos).call
+      return unless size.is_a?(Integer) && position.is_a?(Integer)
+
+      [size, position]
+    end
+
     def with_spooled_upload_source(source)
       Tempfile.create('volcano-upload') do |file|
         file.binmode

data/lib/volcano/storage_session_adapter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Validates the client methods that storage uses for session-scoped requests.
+  class StorageSessionAdapter
+    def initialize(client)
+      @client = client
+    end
+
+    def capture_session_binding
+      binding = storage_binding_array(@client.method(:capture_session_binding).call)
+      generation, owner, session = binding
+      [storage_generation(generation), storage_owner(owner), storage_session(session)]
+    end
+
+    def session_token
+      token = @client.method(:session_token).call
+      raise Error::TransportError, 'invalid storage session token' unless token.is_a?(String)
+
+      token
+    end
+
+    def session_request(binding:, &)
+      method_name = :session_request
+      response = @client.public_send(method_name, binding: binding) do |token|
+        raise Error::TransportError, 'invalid storage session token' unless token.is_a?(String)
+
+        yield token
+      end
+      raise Error::TransportError, 'invalid storage session response' unless response.is_a?(Transport::Response)
+
+      response
+    end
+
+    private
+
+    def storage_binding_array(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.is_a?(Array) && value.size == 3
+
+      value
+    end
+
+    def storage_generation(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.is_a?(Integer)
+
+      value
+    end
+
+    def storage_owner(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.is_a?(SessionOperations)
+
+      value
+    end
+
+    def storage_session(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.nil? || value.is_a?(Session)
+
+      value
+    end
+  end
+end

data/lib/volcano/storage_transport_adapter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Narrows generated and test transport calls to checked storage responses.
+  class StorageTransportAdapter
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def upload_storage_object(authorization:, bucket_name:, path:, data:, content_type:)
+      invoke(:upload_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                     path: path, data: data, content_type: content_type)
+    end
+
+    def download_storage_object(authorization:, bucket_name:, path:, byte_range:)
+      invoke(:download_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                       path: path, byte_range: byte_range)
+    end
+
+    def list_storage_objects(authorization:, bucket_name:, prefix:, limit:, cursor:)
+      invoke(:list_storage_objects, authorization: authorization, bucket_name: bucket_name,
+                                    prefix: prefix, limit: limit, cursor: cursor)
+    end
+
+    def delete_storage_object(authorization:, bucket_name:, path:)
+      invoke(:delete_storage_object, authorization: authorization, bucket_name: bucket_name, path: path)
+    end
+
+    def move_storage_object(authorization:, bucket_name:, from_path:, to_path:)
+      invoke(:move_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                   from_path: from_path, to_path: to_path)
+    end
+
+    def copy_storage_object(authorization:, bucket_name:, from_path:, to_path:)
+      invoke(:copy_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                   from_path: from_path, to_path: to_path)
+    end
+
+    def update_storage_object_visibility(authorization:, bucket_name:, path:, is_public:)
+      invoke(:update_storage_object_visibility, authorization: authorization, bucket_name: bucket_name,
+                                                path: path, is_public: is_public)
+    end
+
+    def create_upload_session(authorization:, bucket_name:, request:)
+      invoke(:create_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def upload_part(authorization:, bucket_name:, request:)
+      invoke(:upload_part, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def complete_upload_session(authorization:, bucket_name:, request:)
+      invoke(:complete_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def get_upload_session(authorization:, bucket_name:, request:)
+      invoke(:get_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def abort_upload_session(authorization:, bucket_name:, request:)
+      invoke(:abort_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    private
+
+    def invoke(name, **arguments)
+      response = @transport.public_send(name, **arguments)
+      raise Error::TransportError, 'invalid storage transport response' unless response.is_a?(Transport::Response)
+
+      response
+    end
+  end
+end

data/lib/volcano/storage_upload_models.rb

@@ -1,51 +1,68 @@
 # frozen_string_literal: true
 
 module Volcano
-  UploadSessionRequest = Data.define(:path, :content_type, :total_size, :part_size) do
+  UploadSessionRequest = Data.define(:path, :content_type, :total_size, :part_size)
+
+  # Freezes the arguments sent to create a resumable upload.
+  class UploadSessionRequest
+    # @dynamic path, content_type, total_size, part_size
     def initialize(path:, content_type:, total_size:, part_size: nil)
-      super(
-        path: path.dup.freeze,
-        content_type: content_type.dup.freeze,
-        total_size: total_size,
-        part_size: part_size
-      )
+      path = path.dup.freeze
+      content_type = content_type.dup.freeze
+      super
     end
   end
   private_constant :UploadSessionRequest
 
-  UploadPartRequest = Data.define(:path, :session_id, :part_number, :data) do
+  UploadPartRequest = Data.define(:path, :session_id, :part_number, :data)
+
+  # Freezes one resumable upload part before transport dispatch.
+  class UploadPartRequest
+    # @dynamic path, session_id, part_number, data
     def initialize(path:, session_id:, part_number:, data:)
-      super(
-        path: path.dup.freeze,
-        session_id: session_id.dup.freeze,
-        part_number: part_number,
-        data: data.dup.freeze
-      )
+      path = path.dup.freeze
+      session_id = session_id.dup.freeze
+      data = data.dup.freeze
+      super
     end
   end
   private_constant :UploadPartRequest
 
-  UploadSessionReference = Data.define(:path, :session_id) do
+  UploadSessionReference = Data.define(:path, :session_id)
+
+  # Freezes the path and identifier used for upload session operations.
+  class UploadSessionReference
+    # @dynamic path, session_id
     def initialize(path:, session_id:)
-      super(path: path.dup.freeze, session_id: session_id.dup.freeze)
+      path = path.dup.freeze
+      session_id = session_id.dup.freeze
+      super
     end
   end
   private_constant :UploadSessionReference
 
-  UploadSession = Data.define(:session_id, :part_size, :total_parts, :expires_at) do
+  UploadSession = Data.define(:session_id, :part_size, :total_parts, :expires_at)
+
+  # Describes a newly created upload session.
+  class UploadSession
+    # @dynamic session_id, part_size, total_parts, expires_at, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(session_id:, part_size:, total_parts:, expires_at:)
-      super(
-        session_id: session_id.dup.freeze,
-        part_size: part_size,
-        total_parts: total_parts,
-        expires_at: expires_at.dup.freeze
-      )
+      session_id = session_id.dup.freeze
+      expires_at = expires_at.dup.freeze
+      super
     end
   end
 
-  UploadPart = Data.define(:part_number, :etag, :size) do
+  UploadPart = Data.define(:part_number, :etag, :size)
+
+  # Describes an accepted upload part.
+  class UploadPart
+    # @dynamic part_number, etag, size, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(part_number:, etag:, size:)
-      super(part_number: part_number, etag: etag.dup.freeze, size: size)
+      etag = etag.dup.freeze
+      super
     end
   end
 
@@ -55,7 +72,13 @@ module Volcano
   ].freeze
   private_constant :UPLOAD_SESSION_STATUS_ATTRIBUTES
 
-  UploadSessionStatus = Data.define(*UPLOAD_SESSION_STATUS_ATTRIBUTES) do
+  UploadSessionStatus = Data.define(*UPLOAD_SESSION_STATUS_ATTRIBUTES)
+
+  # Freezes upload progress returned by storage.
+  class UploadSessionStatus
+    # @dynamic session_id, status, path, content_type, total_size, part_size
+    # @dynamic total_parts, parts_uploaded, bytes_uploaded, parts, expires_at, created_at
+    # @dynamic members, with, to_h, deconstruct, deconstruct_keys, self.[], self.members
     def initialize(**attributes)
       unknown = attributes.keys - UPLOAD_SESSION_STATUS_ATTRIBUTES
       raise ArgumentError, "unknown keywords: #{unknown.join(', ')}" unless unknown.empty?
@@ -66,7 +89,8 @@ module Volcano
       values = UPLOAD_SESSION_STATUS_ATTRIBUTES.to_h do |name|
         [name, immutable_value(attributes.fetch(name))]
       end
-      super(**values)
+      attributes = values
+      super
     end
 
     private

data/lib/volcano/storage_upload_sessions.rb

@@ -51,7 +51,7 @@ module Volcano
           request: request
         )
       end
-      storage_object(Transport.body(response, 200).fetch('object'))
+      storage_object(storage_payload(Transport.body(response, 200)).fetch('object'))
     end
 
     def get_upload_session(path, session_id:)
@@ -78,39 +78,5 @@ module Volcano
       Transport.body(response, 200)
       nil
     end
-
-    private
-
-    def upload_session(payload)
-      UploadSession.new(
-        session_id: payload.fetch('session_id'),
-        part_size: payload.fetch('part_size'),
-        total_parts: payload.fetch('total_parts'),
-        expires_at: parse_time(payload.fetch('expires_at'))
-      )
-    end
-
-    def upload_part_metadata(payload)
-      UploadPart.new(
-        part_number: payload.fetch('part_number'),
-        etag: payload.fetch('etag'),
-        size: payload.fetch('size')
-      )
-    end
-
-    def upload_session_status(payload)
-      attributes = upload_session_status_attributes(payload)
-      attributes[:parts] = attributes.fetch(:parts).map { |part| upload_part_metadata(part) }
-      attributes[:expires_at] = parse_time(attributes.fetch(:expires_at))
-      attributes[:created_at] = parse_time(attributes.fetch(:created_at))
-      UploadSessionStatus.new(**attributes)
-    end
-
-    def upload_session_status_attributes(payload)
-      UPLOAD_SESSION_STATUS_ATTRIBUTES.to_h do |name|
-        value = name == :parts ? payload.fetch(name.to_s, []) : payload.fetch(name.to_s)
-        [name, value]
-      end
-    end
   end
 end

data/lib/volcano/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Volcano
-  VERSION = '0.29.0'
+  VERSION = '0.31.0'
 end

data/lib/volcano.rb

@@ -5,6 +5,7 @@ require_relative 'volcano/connection_string'
 require_relative 'volcano/models'
 require_relative 'volcano/user'
 require_relative 'volcano/session'
+require_relative 'volcano/session_credentials'
 require_relative 'volcano/function_response'
 require_relative 'volcano/durable_models'
 require_relative 'volcano/log_responses'
@@ -16,16 +17,22 @@ require_relative 'volcano/errors'
 require_relative 'volcano/redaction'
 require_relative 'volcano/transport'
 require_relative 'volcano/generated_transport'
-require_relative 'volcano/auth'
+require_relative 'volcano/auth_notification_dispatch'
+require_relative 'volcano/auth_session_binding'
 require_relative 'volcano/auth_sign_out'
 require_relative 'volcano/auth_refresh'
+require_relative 'volcano/auth_profile_fields'
+require_relative 'volcano/auth_get_user'
+require_relative 'volcano/auth_update_user'
+require_relative 'volcano/auth_email_change'
+require_relative 'volcano/auth_sessions'
+require_relative 'volcano/auth_session_construction'
+require_relative 'volcano/auth'
 require_relative 'volcano/auth_sign_up'
 require_relative 'volcano/sign_up_result'
 require_relative 'volcano/auth_anonymous'
 require_relative 'volcano/auth_confirm_email'
 require_relative 'volcano/auth_resend_confirmation'
-require_relative 'volcano/auth_email_change'
-require_relative 'volcano/auth_sessions'
 require_relative 'volcano/auth_oauth'
 require_relative 'volcano/auth_oauth_sign_in'
 require_relative 'volcano/auth_hosted'
@@ -33,13 +40,15 @@ require_relative 'volcano/auth_oauth_token'
 require_relative 'volcano/auth_oauth_api'
 require_relative 'volcano/auth_reset_password_for_email'
 require_relative 'volcano/auth_reset_password'
-require_relative 'volcano/auth_get_user'
-require_relative 'volcano/auth_update_user'
 require_relative 'volcano/database'
 require_relative 'volcano/function_resolution'
 require_relative 'volcano/functions'
 require_relative 'volcano/durable'
 require_relative 'volcano/logs'
+require_relative 'volcano/storage_session_adapter'
+require_relative 'volcano/storage_transport_adapter'
+require_relative 'volcano/storage_response'
+require_relative 'volcano/storage_object_response'
 require_relative 'volcano/storage'
 require_relative 'volcano/storage_upload_sessions'
 require_relative 'volcano/storage_resumable_upload'
@@ -58,8 +67,10 @@ require_relative 'volcano/client'
 
 # Public namespace for the Volcano Ruby SDK.
 module Volcano
-  private_constant :GeneratedTransport, :LockAutoRenewal, :LockLeaseClock, :LockRenewer, :LockSession, :LockResponse,
-                   :Redaction, :SessionOperations
+  private_constant :AuthRefresh, :AuthSignOut, :AuthProfile, :AuthProfileFields, :AuthUpdateUser, :AuthEmailChange,
+                   :AuthSessions, :AuthSessionConstruction,
+                   :GeneratedTransport, :LockAutoRenewal, :LockLeaseClock, :LockRenewer,
+                   :LockSession, :LockResponse, :Redaction, :SessionOperations
 
   Realtime.private_constant :Protocol, :ProtocolDispatch, :ProtocolPublicationDispatch, :ProtocolRecovery,
                             :ProtocolRecoveryDispatch, :ProtocolRecoveryPosition

data/sig/auth_credentials.rbs

@@ -0,0 +1,15 @@
+module Volcano
+  class Auth
+    def current_session: () -> Session?
+    def current_session=: (Session session) -> void
+    def on_auth_state_change: () { (Symbol, Session?) -> void } -> AuthSubscription
+    def sign_in: (email: String, password: String) -> Session
+    def sign_up: (email: String, password: String, ?metadata: session_user_input, ?sign_in_when_allowed: bool) -> SignUpResult
+    def sign_in_anonymously: (?metadata: session_user_input) -> Session
+    def convert_anonymous: (email: String, password: String, ?metadata: session_user_input) -> User
+    def confirm_email: (token: String) -> nil
+    def resend_confirmation: (email: String) -> nil
+    def reset_password_for_email: (email: String) -> nil
+    def reset_password: (token: String, new_password: String) -> nil
+  end
+end

data/sig/auth_oauth.rbs

@@ -0,0 +1,16 @@
+module Volcano
+  type oauth_api_input = session_input
+
+  class Auth
+    def list_linked_oauth_providers: () -> Array[LinkedOAuthProvider]
+    def link_oauth_provider: (String provider) -> String
+    def unlink_oauth_provider: (String provider) -> nil
+    def get_oauth_provider_token: (String provider) -> OAuthProviderTokenStatus
+    def refresh_oauth_provider_token: (String provider) -> OAuthProviderTokenStatus
+    def call_oauth_api: (String provider, endpoint: String, ?method: String, ?body: oauth_api_input) -> Object?
+    def sign_in_with_oauth: (String provider, redirect_to: String, state: String) -> String
+    def exchange_oauth_code: (code: String, redirect_to: String, state: String, expected_state: String) -> Session
+    def get_hosted_auth_url: (project_id: String, state: String, ?action: String) -> String
+    def adopt_hosted_auth_session: (Session session, state: String, expected_state: String) -> Session
+  end
+end

data/sig/auth_profile.rbs

@@ -0,0 +1,10 @@
+module Volcano
+  class Auth
+    def user: () -> User
+    def get_user: () -> User
+    def update_user: (?password: String?, ?metadata: session_user_input?) -> User
+    def request_email_change: (new_email: String) -> EmailChangeResult
+    def cancel_email_change: () -> nil
+    def confirm_email_change: (token: String) -> User
+  end
+end

data/sig/auth_sessions.rbs

@@ -0,0 +1,7 @@
+module Volcano
+  class Auth
+    def list_sessions: (?page: Integer, ?limit: Integer) -> SessionPage
+    def delete_all_other_sessions: () -> nil
+    def delete_session: (String session_id) -> nil
+  end
+end