rafflesia 0.1.0

data/lib/rafflesia/sequences.rb

@@ -0,0 +1,3158 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+require 'json'
+
+module Rafflesia
+  class Sequences
+    def initialize(client)
+      @client = client
+    end
+
+    # POST /v1/sequences/alignments/align
+    # @param gap [Integer, nil] Gap penalty (default -2)
+    # @param match [Integer, nil] Match score (default 1)
+    # @param mismatch [Integer, nil] Mismatch penalty (default -1)
+    # @param query [String] Sequence ID or local FASTA path for query sequence
+    # @param query_positions [Array<Integer>, nil] Optional 1-based query residue positions to project through the alignment; input order and duplicates are preserved.
+    # @param target [String] Sequence ID or local FASTA path for target sequence
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceAlignData]
+    def alignmentsAlign(
+      query:,
+      target:,
+      gap: nil,
+      match: nil,
+      mismatch: nil,
+      query_positions: nil,
+      request_options: {}
+    )
+      body = {
+        'gap' => gap,
+        'match' => match,
+        'mismatch' => mismatch,
+        'query' => query,
+        'query_positions' => query_positions,
+        'target' => target
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/alignments/align',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceAlignData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/catalogs/build
+    # @param dataset_name [String, nil] Optional dataset name carried into catalog provenance
+    # @param dataset_version [String, nil] Optional dataset version carried into catalog provenance
+    # @param input_object_id [String, nil] Object id containing input FASTA bytes
+    # @param input_path [String, nil] Input FASTA path
+    # @param name [String] Logical catalog name, for example uniprot_swissprot
+    # @param source_database_snapshot [Rafflesia::DatabaseSnapshot, nil] Optional source database snapshot that produced the FASTA
+    # @param source_tool_version [Rafflesia::ToolVersion, nil] Optional source tool version that produced the FASTA
+    # @param version [String] Immutable catalog version or source snapshot
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCatalogBuildData]
+    def catalogsBuild(
+      name:,
+      version:,
+      dataset_name: nil,
+      dataset_version: nil,
+      input_object_id: nil,
+      input_path: nil,
+      source_database_snapshot: nil,
+      source_tool_version: nil,
+      request_options: {}
+    )
+      body = {
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'name' => name,
+        'source_database_snapshot' => source_database_snapshot,
+        'source_tool_version' => source_tool_version,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/catalogs/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCatalogBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/catalogs/inspect
+    # @param catalog_id [String, nil] Deterministic sequence catalog id
+    # @param catalog_object_id [String, nil] Sequence catalog manifest object id
+    # @param name [String, nil] Catalog name to resolve through the local catalog registry
+    # @param version [String, nil] Catalog version to resolve through the local catalog registry
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCatalogInspectData]
+    def catalogsInspect(
+      catalog_id: nil,
+      catalog_object_id: nil,
+      name: nil,
+      version: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog_id' => catalog_id,
+        'catalog_object_id' => catalog_object_id,
+        'name' => name,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/catalogs/inspect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCatalogInspectData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # GET /v1/sequences/catalogs/list
+    # @param name [String, nil]
+    # @param version [String, nil]
+    # @param limit [Integer, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCatalogListData]
+    def catalogsList(
+      name: nil,
+      version: nil,
+      limit: nil,
+      request_options: {}
+    )
+      params = {
+        'name' => name,
+        'version' => version,
+        'limit' => limit
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: '/v1/sequences/catalogs/list',
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCatalogListData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/blast/build
+    # @param allow_unbenchmarked_publish [Boolean, nil] Unsafe local/dev escape hatch: allow register_manifest to publish a rafflesia_pack manifest without benchmark evidence.
+    # @param blastdb_version [Integer, nil] BLAST DB version; defaults to 5
+    # @param dry_run [Boolean, nil] Return the deterministic plan without executing makeblastdb
+    # @param extra_args [Array<String>, nil] Explicit additional makeblastdb arguments
+    # @param index_format [Rafflesia::Types::BlastDbBuildRequestIndexFormat, nil] Index format to build; blastdb uses makeblastdb, rafflesia_pack builds a protein pack consumed by rafflesia_blastp
+    # @param input_file_name [String, nil] Optional filename to use when materializing input_object_id
+    # @param input_object_id [String, nil] Object id for an input FASTA artifact
+    # @param input_path [String, nil] Input FASTA path
+    # @param molecule [Rafflesia::Types::BlastDbBuildRequestMolecule, nil] BLAST molecule type; defaults to prot
+    # @param name [String] Logical database name, for example uniprot_swissprot
+    # @param output_dir [String, nil] Directory for generated BLAST DB files and manifest
+    # @param parse_seqids [Boolean, nil] Pass -parse_seqids to makeblastdb
+    # @param register_manifest [Boolean, nil] Whether to publish the manifest into the local BLAST DB registry after build
+    # @param store_artifacts [Boolean, nil] Whether to store generated artifacts in the object store; defaults to true
+    # @param title [String, nil] Optional makeblastdb title
+    # @param version [String] Immutable logical database version
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastDbBuildData]
+    def indexesBlastBuild(
+      name:,
+      version:,
+      allow_unbenchmarked_publish: nil,
+      blastdb_version: nil,
+      dry_run: nil,
+      extra_args: nil,
+      index_format: nil,
+      input_file_name: nil,
+      input_object_id: nil,
+      input_path: nil,
+      molecule: nil,
+      output_dir: nil,
+      parse_seqids: nil,
+      register_manifest: nil,
+      store_artifacts: nil,
+      title: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_unbenchmarked_publish' => allow_unbenchmarked_publish,
+        'blastdb_version' => blastdb_version,
+        'dry_run' => dry_run,
+        'extra_args' => extra_args,
+        'index_format' => index_format,
+        'input_file_name' => input_file_name,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'molecule' => molecule,
+        'name' => name,
+        'output_dir' => output_dir,
+        'parse_seqids' => parse_seqids,
+        'register_manifest' => register_manifest,
+        'store_artifacts' => store_artifacts,
+        'title' => title,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/blast/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastDbBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/blast/describe
+    # @param manifest_path [String, nil] Local manifest path
+    # @param ref [String, nil] Published DB ref such as name:version or manifest object id
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastDbDescribeData]
+    def indexesBlastDescribe(
+      manifest_path: nil,
+      ref: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_path' => manifest_path,
+        'ref' => ref
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/blast/describe',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastDbDescribeData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/blast/evict
+    # @param dry_run [Boolean, nil]
+    # @param manifest_path [String, nil]
+    # @param max_bytes [Integer, nil] If positive, evict oldest selected cache files until selected cache bytes are less than or equal to this limit. Zero evicts every selected file.
+    # @param policy [Rafflesia::CacheEvictionPolicy, nil] Optional cache policy for TTL and pinned-path eviction controls.
+    # @param ref [String, nil]
+    # @param target_dir [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastDbEvictData]
+    def indexesBlastEvict(
+      dry_run: nil,
+      manifest_path: nil,
+      max_bytes: nil,
+      policy: nil,
+      ref: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'dry_run' => dry_run,
+        'manifest_path' => manifest_path,
+        'max_bytes' => max_bytes,
+        'policy' => policy,
+        'ref' => ref,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/blast/evict',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastDbEvictData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # GET /v1/sequences/indexes/blast/list
+    # @param limit [Integer, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastDbListData]
+    def indexesBlastList(
+      limit: nil,
+      request_options: {}
+    )
+      params = {
+        'limit' => limit
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: '/v1/sequences/indexes/blast/list',
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastDbListData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/blast/materialize
+    # @param manifest_path [String, nil] Local manifest path
+    # @param ref [String, nil] Published DB ref such as name:version or manifest object id
+    # @param target_dir [String, nil] Directory used as the local BLAST DB cache
+    # @param verify [Boolean, nil] Verify materialized files by SHA-256
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastDbMaterializeData]
+    def indexesBlastMaterialize(
+      manifest_path: nil,
+      ref: nil,
+      target_dir: nil,
+      verify: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_path' => manifest_path,
+        'ref' => ref,
+        'target_dir' => target_dir,
+        'verify' => verify
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/blast/materialize',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastDbMaterializeData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/blast/publish
+    # @param allow_unbenchmarked_publish [Boolean, nil] Unsafe local/dev escape hatch: allow publishing a rafflesia_pack manifest without benchmark evidence.
+    # @param benchmark_object_id [String, nil] Object id of a BLAST search benchmark artifact produced by sequences.search.blast.benchmark
+    # @param manifest_object_id [String, nil] Manifest object id
+    # @param manifest_path [String, nil] Local manifest path
+    # @param max_local_control_bytes [Integer, nil] Optional publish gate threshold for object-native local control bytes
+    # @param max_object_bytes [Integer, nil] Optional publish gate threshold for object-native object bytes fetched
+    # @param max_object_reads [Integer, nil] Optional publish gate threshold for object-native object reads
+    # @param min_byte_reduction_fraction [Float, nil] Optional publish gate threshold for object-native byte reduction versus the materialized baseline
+    # @param min_hit_overlap_fraction [Float, nil] Optional publish gate threshold for full hit-overlap fraction against the materialized BLAST baseline
+    # @param min_recall_at_1 [Float, nil] Optional publish gate threshold for object-native recall@1 against the materialized BLAST baseline
+    # @param min_recall_at_10 [Float, nil] Optional publish gate threshold for object-native recall@10 against the materialized BLAST baseline
+    # @param ref [String, nil] Published DB ref override
+    # @param require_benchmark [Boolean, nil] Require a passing BLAST object-native benchmark artifact before publishing
+    # @param require_exact_pack_reads [Boolean, nil] Require benchmark evidence that exact scoring read Rafflesia pack sequence objects directly
+    # @param require_no_local_control_files [Boolean, nil] Require benchmark evidence that object-native exact scoring wrote no local candidate/control files
+    # @param require_zero_materialization [Boolean, nil] Require benchmark evidence that object-native search materialized zero local database bytes
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastDbPublishData]
+    def indexesBlastPublish(
+      allow_unbenchmarked_publish: nil,
+      benchmark_object_id: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_local_control_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      min_byte_reduction_fraction: nil,
+      min_hit_overlap_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      ref: nil,
+      require_benchmark: nil,
+      require_exact_pack_reads: nil,
+      require_no_local_control_files: nil,
+      require_zero_materialization: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_unbenchmarked_publish' => allow_unbenchmarked_publish,
+        'benchmark_object_id' => benchmark_object_id,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_local_control_bytes' => max_local_control_bytes,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'min_byte_reduction_fraction' => min_byte_reduction_fraction,
+        'min_hit_overlap_fraction' => min_hit_overlap_fraction,
+        'min_recall_at_1' => min_recall_at_1,
+        'min_recall_at_10' => min_recall_at_10,
+        'ref' => ref,
+        'require_benchmark' => require_benchmark,
+        'require_exact_pack_reads' => require_exact_pack_reads,
+        'require_no_local_control_files' => require_no_local_control_files,
+        'require_zero_materialization' => require_zero_materialization
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/blast/publish',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastDbPublishData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/blast/verify
+    # @param manifest_path [String, nil]
+    # @param ref [String, nil]
+    # @param target_dir [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastDbVerifyData]
+    def indexesBlastVerify(
+      manifest_path: nil,
+      ref: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_path' => manifest_path,
+        'ref' => ref,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/blast/verify',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastDbVerifyData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/candidates/apply
+    # @param build_policy [Rafflesia::Types::SequenceCandidateApplyRequestBuildPolicy, nil] Immutable publish policy for the canonical namespace. Defaults to if_not_exists.
+    # @param dataset_name [String, nil] Optional dataset name override carried into build provenance.
+    # @param dataset_version [String, nil] Optional dataset version override carried into build provenance.
+    # @param decision_object_id [String, nil] Object id containing a sequence candidate decision artifact.
+    # @param decision_path [String, nil] Local JSON path containing a sequence candidate decision artifact.
+    # @param input_object_id [String, nil] Optional FASTA source object override.
+    # @param input_path [String, nil] Optional FASTA source override readable by the API server.
+    # @param name [String, nil] Optional logical name override carried into build provenance.
+    # @param namespace [String] Canonical namespace to build with the selected layout.
+    # @param timeout_ms [Integer, nil] Hard deadline for applying the selected layout in milliseconds.
+    # @param version [String, nil] Optional logical version override carried into build provenance.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateApplyData]
+    def indexesCandidatesApply(
+      namespace:,
+      build_policy: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      decision_object_id: nil,
+      decision_path: nil,
+      input_object_id: nil,
+      input_path: nil,
+      name: nil,
+      timeout_ms: nil,
+      version: nil,
+      request_options: {}
+    )
+      body = {
+        'build_policy' => build_policy,
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'decision_object_id' => decision_object_id,
+        'decision_path' => decision_path,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'name' => name,
+        'namespace' => namespace,
+        'timeout_ms' => timeout_ms,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/candidates/apply',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateApplyData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/candidates/benchmark
+    # @param max_hits [Integer, nil] Maximum hits per query; defaults to 10.
+    # @param max_object_bytes_per_query [Integer, nil] Optional pass threshold for object bytes fetched per query.
+    # @param max_object_reads_per_query [Integer, nil] Optional pass threshold for object reads per query.
+    # @param min_recall_at_k [Float, nil] Optional minimum mean recall@k against exact_safe search.
+    # @param min_top_hit_identity [Float, nil] Optional minimum identity for each query top hit.
+    # @param namespace [String] Sequence candidate namespace to benchmark.
+    # @param queries_object_id [String, nil] Object id containing benchmark query FASTA bytes.
+    # @param queries_path [String, nil] Multi-record FASTA path containing benchmark queries.
+    # @param query_mode [Rafflesia::Types::SequenceCandidateBenchmarkRequestQueryMode, nil] Seed serving mode used for each query.
+    # @param require_top_hit_id_matches_query_id [Boolean, nil] Require each query record id to match the top returned sequence id.
+    # @param require_zero_materialization [Boolean, nil] Require every query to report zero materialized database bytes.
+    # @param store_artifact [Boolean, nil] Whether to store the benchmark JSON artifact in the object store; defaults to true.
+    # @param timeout_ms [Integer, nil] Hard deadline for this benchmark in milliseconds; defaults to the sequence candidate benchmark timeout.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateBenchmarkData]
+    def indexesCandidatesBenchmark(
+      namespace:,
+      max_hits: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      min_recall_at_k: nil,
+      min_top_hit_identity: nil,
+      queries_object_id: nil,
+      queries_path: nil,
+      query_mode: nil,
+      require_top_hit_id_matches_query_id: nil,
+      require_zero_materialization: nil,
+      store_artifact: nil,
+      timeout_ms: nil,
+      request_options: {}
+    )
+      body = {
+        'max_hits' => max_hits,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'min_recall_at_k' => min_recall_at_k,
+        'min_top_hit_identity' => min_top_hit_identity,
+        'namespace' => namespace,
+        'queries_object_id' => queries_object_id,
+        'queries_path' => queries_path,
+        'query_mode' => query_mode,
+        'require_top_hit_id_matches_query_id' => require_top_hit_id_matches_query_id,
+        'require_zero_materialization' => require_zero_materialization,
+        'store_artifact' => store_artifact,
+        'timeout_ms' => timeout_ms
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/candidates/benchmark',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateBenchmarkData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/candidates/build
+    # @param build_policy [Rafflesia::Types::SequenceCandidateBuildRequestBuildPolicy, nil] Immutable publish policy for an existing namespace. Defaults to if_not_exists.
+    # @param dataset_name [String, nil] Optional dataset name carried into build provenance.
+    # @param dataset_version [String, nil] Optional dataset version carried into build provenance.
+    # @param input_object_id [String, nil] Object id containing input FASTA bytes.
+    # @param input_path [String, nil] Input FASTA path readable by the API server.
+    # @param kmer_size [Integer, nil] k-mer size used by the sequence candidate; defaults to 5.
+    # @param minimizer_window [Integer, nil] Minimizer window used by the sequence candidate; 1 means ordinary contiguous k-mers.
+    # @param name [String, nil] Logical seed index name carried into provenance and namespace derivation.
+    # @param namespace [String, nil] Explicit sequence candidate namespace. Defaults to a deterministic namespace derived from name and version.
+    # @param payload_shard_records [Integer, nil] Target records per payload shard in the sequence candidate; defaults to the engine default.
+    # @param reduced_alphabet [String, nil] Optional reduced alphabet used before seed extraction, for example protein13.
+    # @param timeout_ms [Integer, nil] Hard deadline for this build operation in milliseconds; defaults to the sequence candidate build timeout.
+    # @param version [String, nil] Immutable seed index version carried into provenance and namespace derivation.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateBuildData]
+    def indexesCandidatesBuild(
+      build_policy: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      input_object_id: nil,
+      input_path: nil,
+      kmer_size: nil,
+      minimizer_window: nil,
+      name: nil,
+      namespace: nil,
+      payload_shard_records: nil,
+      reduced_alphabet: nil,
+      timeout_ms: nil,
+      version: nil,
+      request_options: {}
+    )
+      body = {
+        'build_policy' => build_policy,
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'kmer_size' => kmer_size,
+        'minimizer_window' => minimizer_window,
+        'name' => name,
+        'namespace' => namespace,
+        'payload_shard_records' => payload_shard_records,
+        'reduced_alphabet' => reduced_alphabet,
+        'timeout_ms' => timeout_ms,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/candidates/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/candidates/gc
+    # @param apply [Boolean, nil] Delete garbage objects. False is a dry-run plan.
+    # @param from_generation [Integer, nil] Manifest generation to retain from; 0 lets the engine use its default current-generation behavior.
+    # @param keep_last_generations [Integer, nil] Retain the N most recent manifest generations. 0 selects the engine default.
+    # @param max_garbage_keys [Integer, nil] Maximum garbage object keys returned in the response. Defaults to 100; 0 returns all keys.
+    # @param min_generation_age_ms [Integer, nil] Optional minimum generation age before an otherwise-garbage generation can be deleted. Requires now_unix_ms.
+    # @param namespace [String] Sequence candidate namespace to plan or apply GC for.
+    # @param now_unix_ms [Integer, nil] Explicit clock used with min_generation_age_ms for deterministic GC plans.
+    # @param timeout_ms [Integer, nil] Hard deadline for this GC operation in milliseconds.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateGcPlanData]
+    def indexesCandidatesGc(
+      namespace:,
+      apply: nil,
+      from_generation: nil,
+      keep_last_generations: nil,
+      max_garbage_keys: nil,
+      min_generation_age_ms: nil,
+      now_unix_ms: nil,
+      timeout_ms: nil,
+      request_options: {}
+    )
+      body = {
+        'apply' => apply,
+        'from_generation' => from_generation,
+        'keep_last_generations' => keep_last_generations,
+        'max_garbage_keys' => max_garbage_keys,
+        'min_generation_age_ms' => min_generation_age_ms,
+        'namespace' => namespace,
+        'now_unix_ms' => now_unix_ms,
+        'timeout_ms' => timeout_ms
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/candidates/gc',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateGcPlanData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/candidates/inspect
+    # @param namespace [String] Sequence candidate namespace to inspect.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateInspectData]
+    def indexesCandidatesInspect(
+      namespace:,
+      request_options: {}
+    )
+      body = {
+        'namespace' => namespace
+      }
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/candidates/inspect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateInspectData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/candidates/sweep
+    # @param case_timeout_ms [Integer, nil] Hard deadline per candidate layout build/measurement case in milliseconds; defaults to the sequence candidate case timeout.
+    # @param dataset_name [String, nil] Optional dataset name carried into scratch build provenance.
+    # @param dataset_version [String, nil] Optional dataset version carried into scratch build provenance.
+    # @param input_object_id [String, nil] Object id containing input FASTA bytes.
+    # @param input_path [String, nil] Input FASTA path readable by the API server.
+    # @param kmer_sizes [Array<Integer>, nil] k-mer sizes to sweep. Defaults to [3,4,5].
+    # @param max_hits [Integer, nil] Maximum hits per query; defaults to 10.
+    # @param max_object_bytes_per_query [Integer, nil] Optional feasibility threshold for mean object bytes fetched per query.
+    # @param max_object_reads_per_query [Integer, nil] Optional feasibility threshold for mean object reads per query.
+    # @param min_recall_at_k [Float, nil] Feasibility threshold for mean recall@k. Defaults to 0.99.
+    # @param minimizer_windows [Array<Integer>, nil] Minimizer windows to sweep. Defaults to [1,4].
+    # @param name [String, nil] Logical seed index name carried into scratch namespace derivation and provenance.
+    # @param namespace_prefix [String, nil] Optional scratch namespace prefix. Defaults to a deterministic prefix derived from name/version/source/query hashes.
+    # @param payload_shard_records [Array<Integer>, nil] Payload shard record targets to sweep. Defaults to [64,256].
+    # @param publish_selected_namespace [String, nil] Optional canonical namespace to build with the selected layout after the sweep completes.
+    # @param queries_object_id [String, nil] Object id containing benchmark query FASTA bytes.
+    # @param queries_path [String, nil] Multi-record FASTA path containing benchmark queries.
+    # @param query_modes [Array<String>, nil] Query modes to sweep. Defaults to [bounded_fast,exact_safe].
+    # @param reduced_alphabets [Array<String>, nil] Reduced alphabets to sweep. Empty string means identity alphabet.
+    # @param require_zero_materialization [Boolean, nil] Require every measured query to report zero materialized database bytes.
+    # @param store_artifact [Boolean, nil] Whether to store the sweep JSON artifact in the object store; defaults to true.
+    # @param timeout_ms [Integer, nil] Hard deadline for the whole sweep in milliseconds; defaults to the sequence candidate sweep timeout.
+    # @param version [String, nil] Logical seed index version carried into scratch namespace derivation and provenance.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateSweepData]
+    def indexesCandidatesSweep(
+      case_timeout_ms: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      input_object_id: nil,
+      input_path: nil,
+      kmer_sizes: nil,
+      max_hits: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      min_recall_at_k: nil,
+      minimizer_windows: nil,
+      name: nil,
+      namespace_prefix: nil,
+      payload_shard_records: nil,
+      publish_selected_namespace: nil,
+      queries_object_id: nil,
+      queries_path: nil,
+      query_modes: nil,
+      reduced_alphabets: nil,
+      require_zero_materialization: nil,
+      store_artifact: nil,
+      timeout_ms: nil,
+      version: nil,
+      request_options: {}
+    )
+      body = {
+        'case_timeout_ms' => case_timeout_ms,
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'kmer_sizes' => kmer_sizes,
+        'max_hits' => max_hits,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'min_recall_at_k' => min_recall_at_k,
+        'minimizer_windows' => minimizer_windows,
+        'name' => name,
+        'namespace_prefix' => namespace_prefix,
+        'payload_shard_records' => payload_shard_records,
+        'publish_selected_namespace' => publish_selected_namespace,
+        'queries_object_id' => queries_object_id,
+        'queries_path' => queries_path,
+        'query_modes' => query_modes,
+        'reduced_alphabets' => reduced_alphabets,
+        'require_zero_materialization' => require_zero_materialization,
+        'store_artifact' => store_artifact,
+        'timeout_ms' => timeout_ms,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/candidates/sweep',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateSweepData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/candidates/verify
+    # @param check_gc_plan [Boolean, nil] Also compute a dry-run GC plan.
+    # @param expected_source_sha_256 [String, nil] Optional source SHA-256 that the namespace must advertise.
+    # @param max_gc_garbage_count [Integer, nil] Optional maximum dry-run garbage object count when check_gc_plan is true. Set 0 to require no garbage objects.
+    # @param max_object_bytes [Integer, nil] Optional object-byte budget for the probe query.
+    # @param max_object_reads [Integer, nil] Optional object-read budget for the probe query.
+    # @param min_record_count [Integer, nil] Optional minimum indexed record count.
+    # @param min_top_hit_identity [Float, nil] Optional minimum identity for the probe top hit.
+    # @param namespace [String] Sequence candidate namespace to verify.
+    # @param probe_max_hits [Integer, nil] Maximum probe hits; defaults to 1.
+    # @param probe_query [String, nil] Optional query sequence, sequence id, or FASTA path to probe with the index.
+    # @param require_payload_shards [Boolean, nil] Require the directory to expose at least one payload shard.
+    # @param require_posting_segment [Boolean, nil] Require the directory to expose a posting segment object.
+    # @param require_probe_hit [Boolean, nil] Require the optional probe query to return at least one hit.
+    # @param require_zero_materialization [Boolean, nil] Require optional probe query to report zero materialized database bytes.
+    # @param timeout_ms [Integer, nil] Hard deadline for this verification in milliseconds.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateVerifyData]
+    def indexesCandidatesVerify(
+      namespace:,
+      check_gc_plan: nil,
+      expected_source_sha_256: nil,
+      max_gc_garbage_count: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      min_record_count: nil,
+      min_top_hit_identity: nil,
+      probe_max_hits: nil,
+      probe_query: nil,
+      require_payload_shards: nil,
+      require_posting_segment: nil,
+      require_probe_hit: nil,
+      require_zero_materialization: nil,
+      timeout_ms: nil,
+      request_options: {}
+    )
+      body = {
+        'check_gc_plan' => check_gc_plan,
+        'expected_source_sha256' => expected_source_sha_256,
+        'max_gc_garbage_count' => max_gc_garbage_count,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'min_record_count' => min_record_count,
+        'min_top_hit_identity' => min_top_hit_identity,
+        'namespace' => namespace,
+        'probe_max_hits' => probe_max_hits,
+        'probe_query' => probe_query,
+        'require_payload_shards' => require_payload_shards,
+        'require_posting_segment' => require_posting_segment,
+        'require_probe_hit' => require_probe_hit,
+        'require_zero_materialization' => require_zero_materialization,
+        'timeout_ms' => timeout_ms
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/candidates/verify',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateVerifyData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/diamond/build
+    # @param dry_run [Boolean, nil] Return the deterministic plan without executing diamond makedb
+    # @param extra_args [Array<String>, nil] Explicit additional diamond makedb arguments
+    # @param input_file_name [String, nil] Optional filename to use when materializing input_object_id
+    # @param input_object_id [String, nil] Object id for an input protein FASTA artifact
+    # @param input_path [String, nil] Input protein FASTA path
+    # @param name [String] Logical database name, for example uniprot_swissprot
+    # @param output_dir [String, nil] Directory for generated DIAMOND DB files and manifest
+    # @param register_manifest [Boolean, nil] Whether to publish the manifest into the local DIAMOND DB registry after build
+    # @param store_artifacts [Boolean, nil] Whether to store generated artifacts in the object store; defaults to true
+    # @param threads [Integer, nil] DIAMOND makedb thread count
+    # @param version [String] Immutable logical database version
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondDbBuildData]
+    def indexesDiamondBuild(
+      name:,
+      version:,
+      dry_run: nil,
+      extra_args: nil,
+      input_file_name: nil,
+      input_object_id: nil,
+      input_path: nil,
+      output_dir: nil,
+      register_manifest: nil,
+      store_artifacts: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'dry_run' => dry_run,
+        'extra_args' => extra_args,
+        'input_file_name' => input_file_name,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'name' => name,
+        'output_dir' => output_dir,
+        'register_manifest' => register_manifest,
+        'store_artifacts' => store_artifacts,
+        'threads' => threads,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/diamond/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondDbBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/diamond/catalog/build
+    # @param catalog [String, nil] Object key for the catalog JSON; defaults to catalogs/{name}/{version}/diamond-catalog.json
+    # @param dry_run [Boolean, nil] Return the deterministic sharded build plan without executing diamond makedb
+    # @param extra_args [Array<String>, nil] Explicit additional diamond makedb arguments
+    # @param input_file_name [String, nil] Optional filename to use when materializing input_object_id
+    # @param input_object_id [String, nil] Object id for an input protein FASTA artifact
+    # @param input_path [String, nil] Input protein FASTA path
+    # @param name [String] Logical catalog name, for example uniprot_swissprot
+    # @param output_dir [String, nil] Directory for temporary shard FASTA and DIAMOND DB build files
+    # @param shard_count [Integer, nil] Requested number of FASTA shards; defaults to 1 and is capped at the number of records
+    # @param store_root [String, nil] Object-store root for the catalog and shard databases; defaults to the server data dir
+    # @param threads [Integer, nil] DIAMOND makedb thread count per shard
+    # @param version [String] Immutable logical catalog version
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondCatalogBuildData]
+    def indexesDiamondCatalogBuild(
+      name:,
+      version:,
+      catalog: nil,
+      dry_run: nil,
+      extra_args: nil,
+      input_file_name: nil,
+      input_object_id: nil,
+      input_path: nil,
+      output_dir: nil,
+      shard_count: nil,
+      store_root: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog' => catalog,
+        'dry_run' => dry_run,
+        'extra_args' => extra_args,
+        'input_file_name' => input_file_name,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'name' => name,
+        'output_dir' => output_dir,
+        'shard_count' => shard_count,
+        'store_root' => store_root,
+        'threads' => threads,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/diamond/catalog/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondCatalogBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/diamond/describe
+    # @param manifest_path [String, nil] Local manifest path
+    # @param ref [String, nil] Published DB ref such as name:version or manifest object id
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondDbDescribeData]
+    def indexesDiamondDescribe(
+      manifest_path: nil,
+      ref: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_path' => manifest_path,
+        'ref' => ref
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/diamond/describe',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondDbDescribeData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/diamond/evict
+    # @param dry_run [Boolean, nil]
+    # @param manifest_path [String, nil]
+    # @param max_bytes [Integer, nil] If positive, evict oldest selected cache files until selected cache bytes are at or below this limit. Zero evicts every selected file.
+    # @param policy [Rafflesia::CacheEvictionPolicy, nil] Optional cache policy for TTL and pinned-path eviction controls.
+    # @param ref [String, nil]
+    # @param target_dir [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondDbEvictData]
+    def indexesDiamondEvict(
+      dry_run: nil,
+      manifest_path: nil,
+      max_bytes: nil,
+      policy: nil,
+      ref: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'dry_run' => dry_run,
+        'manifest_path' => manifest_path,
+        'max_bytes' => max_bytes,
+        'policy' => policy,
+        'ref' => ref,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/diamond/evict',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondDbEvictData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # GET /v1/sequences/indexes/diamond/list
+    # @param limit [Integer, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondDbListData]
+    def indexesDiamondList(
+      limit: nil,
+      request_options: {}
+    )
+      params = {
+        'limit' => limit
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: '/v1/sequences/indexes/diamond/list',
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondDbListData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/diamond/materialize
+    # @param manifest_path [String, nil] Local manifest path
+    # @param ref [String, nil] Published DB ref such as name:version or manifest object id
+    # @param target_dir [String, nil] Directory used as the local DIAMOND DB cache
+    # @param verify [Boolean, nil] Verify materialized files by SHA-256
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondDbMaterializeData]
+    def indexesDiamondMaterialize(
+      manifest_path: nil,
+      ref: nil,
+      target_dir: nil,
+      verify: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_path' => manifest_path,
+        'ref' => ref,
+        'target_dir' => target_dir,
+        'verify' => verify
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/diamond/materialize',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondDbMaterializeData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/diamond/publish
+    # @param manifest_object_id [String, nil] Manifest object id
+    # @param manifest_path [String, nil] Local manifest path
+    # @param ref [String, nil] Published DB ref override
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondDbPublishData]
+    def indexesDiamondPublish(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      ref: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'ref' => ref
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/diamond/publish',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondDbPublishData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/diamond/verify
+    # @param manifest_path [String, nil]
+    # @param ref [String, nil]
+    # @param target_dir [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondDbVerifyData]
+    def indexesDiamondVerify(
+      manifest_path: nil,
+      ref: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_path' => manifest_path,
+        'ref' => ref,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/diamond/verify',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondDbVerifyData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/benchmark
+    # @param concurrency [Integer, nil] Maximum concurrent object block reads; defaults to 8
+    # @param db [String, nil] Baseline FASTA path for the materialized builtin k-mer search; defaults to input_path when available
+    # @param index_id [String, nil] Published sequence seed index id
+    # @param input_object_id [String, nil] Object id containing input FASTA bytes used to build a seed index when no manifest is supplied
+    # @param input_path [String, nil] Input FASTA path used to build a seed index when no manifest is supplied
+    # @param kmer_size [Integer, nil] k-mer size used for build/search; defaults to the index k-mer size or 9
+    # @param manifest_object_id [String, nil] Object id for an existing sequence seed index manifest
+    # @param manifest_path [String, nil] Local path to an existing sequence seed index manifest JSON file
+    # @param max_hits [Integer, nil] Maximum hits per query; defaults to 100
+    # @param max_object_bytes_per_query [Integer, nil] Optional pass threshold for object bytes fetched per query
+    # @param max_object_reads_per_query [Integer, nil] Optional pass threshold for object reads per query
+    # @param min_identity [Float, nil] Minimum k-mer identity fraction for both search paths
+    # @param min_mean_overlap_fraction [Float, nil] Optional pass threshold for mean hit-overlap fraction
+    # @param name [String, nil] Logical seed index name when building an index for the benchmark
+    # @param payload_block_size [Integer, nil] Payload block size when building an index for the benchmark
+    # @param posting_block_size [Integer, nil] Posting block size when building an index for the benchmark
+    # @param queries_path [String] Multi-record FASTA path containing benchmark queries
+    # @param require_zero_materialization [Boolean, nil] Require the object-native search path to report zero materialized database bytes
+    # @param rerank_alignment [Boolean, nil] Whether seed-index candidate hits are alignment-reranked before comparison
+    # @param store_artifact [Boolean, nil] Whether to store the benchmark JSON artifact in the object store; defaults to true
+    # @param use_block_cache [Boolean, nil] Whether to use the process-local seed-index object block cache; defaults to true
+    # @param version [String, nil] Logical seed index version when building an index for the benchmark
+    # @param wal_object_ids [Array<String>, nil] Optional WAL object ids to overlay on the immutable index during benchmark queries
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexBenchmarkData]
+    def indexesSeedBenchmark(
+      queries_path:,
+      concurrency: nil,
+      db: nil,
+      index_id: nil,
+      input_object_id: nil,
+      input_path: nil,
+      kmer_size: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_hits: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      min_identity: nil,
+      min_mean_overlap_fraction: nil,
+      name: nil,
+      payload_block_size: nil,
+      posting_block_size: nil,
+      require_zero_materialization: nil,
+      rerank_alignment: nil,
+      store_artifact: nil,
+      use_block_cache: nil,
+      version: nil,
+      wal_object_ids: nil,
+      request_options: {}
+    )
+      body = {
+        'concurrency' => concurrency,
+        'db' => db,
+        'index_id' => index_id,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'kmer_size' => kmer_size,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_hits' => max_hits,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'min_identity' => min_identity,
+        'min_mean_overlap_fraction' => min_mean_overlap_fraction,
+        'name' => name,
+        'payload_block_size' => payload_block_size,
+        'posting_block_size' => posting_block_size,
+        'queries_path' => queries_path,
+        'require_zero_materialization' => require_zero_materialization,
+        'rerank_alignment' => rerank_alignment,
+        'store_artifact' => store_artifact,
+        'use_block_cache' => use_block_cache,
+        'version' => version,
+        'wal_object_ids' => wal_object_ids
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/benchmark',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexBenchmarkData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/build
+    # @param dataset_name [String, nil] Optional dataset name carried into index provenance
+    # @param dataset_version [String, nil] Optional dataset version carried into index provenance
+    # @param input_object_id [String, nil] Object id containing input FASTA bytes
+    # @param input_path [String, nil] Input FASTA path
+    # @param kmer_size [Integer, nil] k-mer size used to build the seed posting lists; defaults to 9
+    # @param name [String] Logical seed index name, for example uniprot_swissprot_seed
+    # @param payload_block_size [Integer, nil] Maximum sequence payload records stored in one payload block; defaults to 1024
+    # @param payload_lite [Boolean, nil] When true, payload blocks omit full subject sequences and store only routing metadata; exact scoring must use an authoritative sequence store such as BLAST pack segments.
+    # @param posting_block_size [Integer, nil] Maximum postings stored in one posting-list block; defaults to 4096
+    # @param version [String] Immutable seed index version or source snapshot
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexBuildData]
+    def indexesSeedBuild(
+      name:,
+      version:,
+      dataset_name: nil,
+      dataset_version: nil,
+      input_object_id: nil,
+      input_path: nil,
+      kmer_size: nil,
+      payload_block_size: nil,
+      payload_lite: nil,
+      posting_block_size: nil,
+      request_options: {}
+    )
+      body = {
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'kmer_size' => kmer_size,
+        'name' => name,
+        'payload_block_size' => payload_block_size,
+        'payload_lite' => payload_lite,
+        'posting_block_size' => posting_block_size,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/compact
+    # @param base_index_id [String, nil] Published base sequence seed index id
+    # @param base_manifest_object_id [String, nil] Object id for the base sequence seed index manifest
+    # @param base_manifest_path [String, nil] Local path to the base sequence seed index manifest JSON file
+    # @param base_name [String, nil] Published base seed index name
+    # @param base_version [String, nil] Published base seed index version
+    # @param dataset_name [String, nil] Optional dataset name carried into compacted index provenance
+    # @param dataset_version [String, nil] Optional dataset version carried into compacted index provenance
+    # @param kmer_size [Integer, nil] Optional compacted k-mer size; defaults to the base index k-mer size
+    # @param name [String] Logical name for the compacted seed index
+    # @param payload_block_size [Integer, nil] Payload block size for the compacted index
+    # @param posting_block_size [Integer, nil] Posting block size for the compacted index
+    # @param version [String] Immutable version for the compacted seed index
+    # @param wal_object_ids [Array<String>, nil] WAL object ids to compact into the new immutable seed index
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexCompactData]
+    def indexesSeedCompact(
+      name:,
+      version:,
+      base_index_id: nil,
+      base_manifest_object_id: nil,
+      base_manifest_path: nil,
+      base_name: nil,
+      base_version: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      kmer_size: nil,
+      payload_block_size: nil,
+      posting_block_size: nil,
+      wal_object_ids: nil,
+      request_options: {}
+    )
+      body = {
+        'base_index_id' => base_index_id,
+        'base_manifest_object_id' => base_manifest_object_id,
+        'base_manifest_path' => base_manifest_path,
+        'base_name' => base_name,
+        'base_version' => base_version,
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'kmer_size' => kmer_size,
+        'name' => name,
+        'payload_block_size' => payload_block_size,
+        'posting_block_size' => posting_block_size,
+        'version' => version,
+        'wal_object_ids' => wal_object_ids
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/compact',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexCompactData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/describe
+    # @param index_id [String, nil] Published sequence seed index id
+    # @param manifest_object_id [String, nil] Object id for a sequence seed index manifest
+    # @param manifest_path [String, nil] Local path to a sequence seed index manifest JSON file
+    # @param name [String, nil] Published sequence seed index name
+    # @param version [String, nil] Published sequence seed index version
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexInspectData]
+    def indexesSeedDescribe(
+      index_id: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      name: nil,
+      version: nil,
+      request_options: {}
+    )
+      body = {
+        'index_id' => index_id,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'name' => name,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/describe',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexInspectData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # GET /v1/sequences/indexes/seed/list
+    # @param name [String, nil]
+    # @param version [String, nil]
+    # @param limit [Integer, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexListData]
+    def indexesSeedList(
+      name: nil,
+      version: nil,
+      limit: nil,
+      request_options: {}
+    )
+      params = {
+        'name' => name,
+        'version' => version,
+        'limit' => limit
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: '/v1/sequences/indexes/seed/list',
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexListData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/merge
+    # @param dataset_name [String, nil] Optional dataset name carried into aggregate index provenance
+    # @param dataset_version [String, nil] Optional dataset version carried into aggregate index provenance
+    # @param kmer_size [Integer, nil] Optional k-mer size guard; every segment must match when set
+    # @param name [String] Logical name for the aggregate seed index
+    # @param segment_manifest_object_ids [Array<String>, nil] Seed index manifest object ids to publish as immutable query segments
+    # @param version [String] Immutable version for the aggregate seed index
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexMergeData]
+    def indexesSeedMerge(
+      name:,
+      segment_manifest_object_ids:,
+      version:,
+      dataset_name: nil,
+      dataset_version: nil,
+      kmer_size: nil,
+      request_options: {}
+    )
+      body = {
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'kmer_size' => kmer_size,
+        'name' => name,
+        'segment_manifest_object_ids' => segment_manifest_object_ids,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/merge',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexMergeData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/plan
+    # @param index_id [String, nil] Published sequence seed index id
+    # @param kmer_size [Integer, nil] Optional query k-mer size; must match the index k-mer size when set
+    # @param manifest_object_id [String, nil] Object id for a sequence seed index manifest
+    # @param manifest_path [String, nil] Local path to a sequence seed index manifest JSON file
+    # @param max_object_bytes [Integer, nil] Optional object-byte budget checked against the plan
+    # @param max_object_reads [Integer, nil] Optional object-read budget checked against the plan
+    # @param name [String, nil] Published sequence seed index name
+    # @param query [String] Sequence ID or local FASTA path for query sequence
+    # @param require_zero_materialization [Boolean, nil] Require the planned object-native path to materialize zero database bytes
+    # @param version [String, nil] Published sequence seed index version
+    # @param wal_object_ids [Array<String>, nil] Optional WAL object ids included as a mutable overlay during planning
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexPlanData]
+    def indexesSeedPlan(
+      query:,
+      index_id: nil,
+      kmer_size: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      name: nil,
+      require_zero_materialization: nil,
+      version: nil,
+      wal_object_ids: nil,
+      request_options: {}
+    )
+      body = {
+        'index_id' => index_id,
+        'kmer_size' => kmer_size,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'name' => name,
+        'query' => query,
+        'require_zero_materialization' => require_zero_materialization,
+        'version' => version,
+        'wal_object_ids' => wal_object_ids
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/plan',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexPlanData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/publish
+    # @param benchmark_object_id [String, nil] Object id of a sequence seed-index benchmark artifact produced by sequences.indexes.seed.benchmark
+    # @param manifest_object_id [String, nil] Object id for a sequence seed index manifest
+    # @param manifest_path [String, nil] Local path to a sequence seed index manifest JSON file
+    # @param max_object_bytes_per_query [Integer, nil] Optional publish gate threshold for object bytes fetched per query
+    # @param max_object_reads_per_query [Integer, nil] Optional publish gate threshold for object reads per query
+    # @param min_mean_overlap_fraction [Float, nil] Optional publish gate threshold for mean hit-overlap fraction against the materialized FASTA baseline
+    # @param require_benchmark [Boolean, nil] Require a passing object-native seed-index benchmark artifact before publishing
+    # @param require_zero_materialization [Boolean, nil] Require benchmark evidence that the object-native path materialized zero database bytes
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexInspectData]
+    def indexesSeedPublish(
+      benchmark_object_id: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      min_mean_overlap_fraction: nil,
+      require_benchmark: nil,
+      require_zero_materialization: nil,
+      request_options: {}
+    )
+      body = {
+        'benchmark_object_id' => benchmark_object_id,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'min_mean_overlap_fraction' => min_mean_overlap_fraction,
+        'require_benchmark' => require_benchmark,
+        'require_zero_materialization' => require_zero_materialization
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/publish',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexInspectData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/verify
+    # @param check_blocks [Boolean, nil] When true, read every posting and payload block; otherwise verifies manifest and directory objects
+    # @param index_id [String, nil] Published sequence seed index id
+    # @param manifest_object_id [String, nil] Object id for a sequence seed index manifest
+    # @param manifest_path [String, nil] Local path to a sequence seed index manifest JSON file
+    # @param name [String, nil] Published sequence seed index name
+    # @param version [String, nil] Published sequence seed index version
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexVerifyData]
+    def indexesSeedVerify(
+      check_blocks: nil,
+      index_id: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      name: nil,
+      version: nil,
+      request_options: {}
+    )
+      body = {
+        'check_blocks' => check_blocks,
+        'index_id' => index_id,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'name' => name,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/verify',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexVerifyData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/seed/wal/append
+    # @param index_id [String, nil] Published base sequence seed index id
+    # @param input_object_id [String, nil] Optional FASTA object whose records become upsert WAL records
+    # @param input_path [String, nil] Optional FASTA file whose records become upsert WAL records
+    # @param manifest_object_id [String, nil] Object id for the base sequence seed index manifest
+    # @param manifest_path [String, nil] Local path to the base sequence seed index manifest JSON file
+    # @param name [String, nil] Published base seed index name or WAL name when no base locator is supplied
+    # @param records [Array<Rafflesia::SequenceSeedIndexWalRecord>, nil] Explicit WAL records
+    # @param version [String, nil] Published base seed index version or WAL version when no base locator is supplied
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSeedIndexWalAppendData]
+    def indexesSeedWalAppend(
+      index_id: nil,
+      input_object_id: nil,
+      input_path: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      name: nil,
+      records: nil,
+      version: nil,
+      request_options: {}
+    )
+      body = {
+        'index_id' => index_id,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'name' => name,
+        'records' => records,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/seed/wal/append',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSeedIndexWalAppendData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/segments/build
+    # @param algorithm [String] Algorithm family that owns this segment layout, for example blast, foldseek, or seed.
+    # @param block_size_bytes [Integer, nil] Maximum bytes per immutable block; defaults to 4 MiB.
+    # @param dataset_name [String, nil] Optional dataset name carried into segment provenance.
+    # @param dataset_version [String, nil] Optional dataset version carried into segment provenance.
+    # @param input_object_id [String, nil] Object id containing input bytes to split into immutable segment blocks.
+    # @param input_path [String, nil] Input file path whose bytes will be split into immutable segment blocks.
+    # @param key_mode [Rafflesia::Types::SearchSegmentBuildRequestKeyMode, nil] Sparse-index key mode; line uses the first non-empty line prefix in each block, byte_offset uses deterministic offsets. Defaults to line.
+    # @param name [String] Logical search segment name.
+    # @param tool_name [String, nil] Optional upstream tool name carried into the manifest.
+    # @param tool_version [String, nil] Optional upstream tool version carried into the manifest.
+    # @param version [String] Immutable segment version or source snapshot.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSearchSegmentBuildData]
+    def indexesSegmentsBuild(
+      algorithm:,
+      name:,
+      version:,
+      block_size_bytes: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      input_object_id: nil,
+      input_path: nil,
+      key_mode: nil,
+      tool_name: nil,
+      tool_version: nil,
+      request_options: {}
+    )
+      body = {
+        'algorithm' => algorithm,
+        'block_size_bytes' => block_size_bytes,
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'key_mode' => key_mode,
+        'name' => name,
+        'tool_name' => tool_name,
+        'tool_version' => tool_version,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/segments/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSearchSegmentBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/segments/describe
+    # @param manifest_object_id [String, nil] Object id for a search segment manifest.
+    # @param manifest_path [String, nil] Local path to a search segment manifest JSON file.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSearchSegmentDescribeData]
+    def indexesSegmentsDescribe(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/segments/describe',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSearchSegmentDescribeData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/segments/gc
+    # @param candidate_manifest_object_ids [Array<String>, nil] Older/candidate manifest object ids considered for garbage collection.
+    # @param candidate_manifest_paths [Array<String>, nil] Older/candidate manifest paths considered for garbage collection.
+    # @param dry_run [Boolean, nil] When true, compute unused object ids without deleting. Defaults to true because deletion is not exposed by the content-addressed store.
+    # @param keep_manifest_object_ids [Array<String>, nil] Manifest object ids whose block/root/source objects remain live.
+    # @param keep_manifest_paths [Array<String>, nil] Local manifest paths whose block/root/source objects remain live.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSearchSegmentGcData]
+    def indexesSegmentsGc(
+      candidate_manifest_object_ids: nil,
+      candidate_manifest_paths: nil,
+      dry_run: nil,
+      keep_manifest_object_ids: nil,
+      keep_manifest_paths: nil,
+      request_options: {}
+    )
+      body = {
+        'candidate_manifest_object_ids' => candidate_manifest_object_ids,
+        'candidate_manifest_paths' => candidate_manifest_paths,
+        'dry_run' => dry_run,
+        'keep_manifest_object_ids' => keep_manifest_object_ids,
+        'keep_manifest_paths' => keep_manifest_paths
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/segments/gc',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSearchSegmentGcData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/segments/plan
+    # @param manifest_object_id [String, nil] Object id for a search segment manifest.
+    # @param manifest_path [String, nil] Local path to a search segment manifest JSON file.
+    # @param max_blocks [Integer, nil] Optional hard budget for selected immutable blocks.
+    # @param max_materialized_bytes [Integer, nil] Optional hard budget for planned database/local materialization bytes.
+    # @param max_object_bytes [Integer, nil] Optional hard budget for planned object bytes.
+    # @param max_object_reads [Integer, nil] Optional hard budget for planned object reads.
+    # @param query_key [String, nil] Sparse-index key used to select block objects. Empty plans every block.
+    # @param require_zero_materialization [Boolean, nil] Require the plan to materialize zero database/local bytes.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSearchSegmentPlanData]
+    def indexesSegmentsPlan(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_blocks: nil,
+      max_materialized_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      query_key: nil,
+      require_zero_materialization: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_blocks' => max_blocks,
+        'max_materialized_bytes' => max_materialized_bytes,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'query_key' => query_key,
+        'require_zero_materialization' => require_zero_materialization
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/segments/plan',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSearchSegmentPlanData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/indexes/segments/prefetch
+    # @param manifest_object_id [String, nil] Object id for a search segment manifest.
+    # @param manifest_path [String, nil] Local path to a search segment manifest JSON file.
+    # @param max_materialized_bytes [Integer, nil] Optional hard budget for planned database/local materialization bytes.
+    # @param max_object_bytes [Integer, nil] Optional hard budget for planned object bytes.
+    # @param max_object_reads [Integer, nil] Optional hard budget for planned object reads.
+    # @param query_key [String, nil] Sparse-index key used to select block objects. Empty prefetches every block.
+    # @param require_zero_materialization [Boolean, nil] Require the prefetch path to materialize zero database/local bytes.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSearchSegmentPrefetchData]
+    def indexesSegmentsPrefetch(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_materialized_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      query_key: nil,
+      require_zero_materialization: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_materialized_bytes' => max_materialized_bytes,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'query_key' => query_key,
+        'require_zero_materialization' => require_zero_materialization
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/indexes/segments/prefetch',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSearchSegmentPrefetchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/msa/build
+    # @param backend [String, nil] MSA backend; defaults to mafft
+    # @param cache_mode [Rafflesia::Types::MsaBuildRequestCacheMode, nil] Artifact cache mode. use reuses matching cached artifacts, refresh recomputes and stores, off recomputes without storing.
+    # @param dry_run [Boolean, nil] Return the deterministic command without executing the backend
+    # @param extra_args [Array<String>, nil] Explicit additional backend arguments
+    # @param input_object_id [String, nil] Object id for an input multi-record FASTA artifact
+    # @param input_path [String, nil] Input multi-record FASTA path
+    # @param inputs [Array<String>, nil] Sequence ids or local FASTA paths to combine into the MSA input
+    # @param output_dir [String, nil] Directory for generated MSA run files
+    # @param strategy [Rafflesia::Types::MsaBuildRequestStrategy, nil] MAFFT strategy; defaults to auto
+    # @param threads [Integer, nil] MAFFT thread count; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeMsaBuildData]
+    def msaBuild(
+      backend: nil,
+      cache_mode: nil,
+      dry_run: nil,
+      extra_args: nil,
+      input_object_id: nil,
+      input_path: nil,
+      inputs: nil,
+      output_dir: nil,
+      strategy: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'backend' => backend,
+        'cache_mode' => cache_mode,
+        'dry_run' => dry_run,
+        'extra_args' => extra_args,
+        'input_object_id' => input_object_id,
+        'input_path' => input_path,
+        'inputs' => inputs,
+        'output_dir' => output_dir,
+        'strategy' => strategy,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/msa/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeMsaBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/msa/coevolution
+    # @param alignment_object_id [String, nil] Object id containing aligned FASTA to analyse
+    # @param alignment_path [String, nil] Aligned FASTA path to analyse
+    # @param max_gap_fraction [Float, nil] Drop columns whose gap fraction exceeds this; 0 selects the default 0.5
+    # @param max_sequences [Integer, nil] Cap on sequences used, evenly strided; 0 uses all
+    # @param method [Rafflesia::Types::CoevolutionRequestMethod, nil] Scoring method: dca (mean-field Direct Coupling Analysis, default) or mi (average-product-corrected mutual information, a weaker contact predictor shown for comparison)
+    # @param min_separation [Integer, nil] Minimum |i-j| in reference residue positions for a returned pair; 0 disables the separation filter
+    # @param pseudocount [Float, nil] DCA pseudocount fraction; 0 selects the default 0.5
+    # @param reference [String, nil] Header first-token of the numbering reference sequence; defaults to the first record
+    # @param reference_start [Integer, nil] Residue number of the first ungapped reference position; 0 selects 1
+    # @param reweight_identity [Float, nil] Sequence reweighting identity threshold in (0,1]; sequences sharing at least this fraction of columns share weight. 0 selects the default 0.8.
+    # @param top [Integer, nil] Number of highest-scoring pairs to return; 0 returns all scored pairs
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeCoevolutionData]
+    def msaCoevolution(
+      alignment_object_id: nil,
+      alignment_path: nil,
+      max_gap_fraction: nil,
+      max_sequences: nil,
+      method_: nil,
+      min_separation: nil,
+      pseudocount: nil,
+      reference: nil,
+      reference_start: nil,
+      reweight_identity: nil,
+      top: nil,
+      request_options: {}
+    )
+      body = {
+        'alignment_object_id' => alignment_object_id,
+        'alignment_path' => alignment_path,
+        'max_gap_fraction' => max_gap_fraction,
+        'max_sequences' => max_sequences,
+        'method' => method_,
+        'min_separation' => min_separation,
+        'pseudocount' => pseudocount,
+        'reference' => reference,
+        'reference_start' => reference_start,
+        'reweight_identity' => reweight_identity,
+        'top' => top
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/msa/coevolution',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeCoevolutionData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/msa/from-search
+    # @param cache_mode [Rafflesia::Types::MsaFromSearchRequestCacheMode, nil] Artifact cache mode passed through to the MSA build
+    # @param db [String, nil] FASTA database path searched before MSA construction; also used as the hit FASTA source when hit_fasta_path is omitted
+    # @param dry_run [Boolean, nil]
+    # @param extra_args [Array<String>, nil]
+    # @param hit_fasta_path [String, nil] FASTA file containing target sequences named by the selected search hits
+    # @param homology_search_id [String, nil] Completed retained hsrch_ resource whose ordered target accessions seed the MSA
+    # @param include_query [Boolean, nil] Include the query sequence in the MSA input; defaults to true
+    # @param kmer_size [Integer, nil]
+    # @param max_hits [Integer, nil] Maximum search hits to align; defaults to 20
+    # @param min_identity [Float, nil]
+    # @param output_dir [String, nil]
+    # @param query [String] Query sequence id or FASTA path
+    # @param search_backend [Rafflesia::Types::MsaFromSearchRequestSearchBackend, nil] Search result backend to materialize; defaults to homology when homology_search_id is supplied, otherwise builtin unless search_object_id is supplied
+    # @param search_object_id [String, nil] Object id containing a normalized search result envelope or data object
+    # @param sequence_catalog_object_id [String, nil] Versioned sequence catalog object used to resolve search-hit ids into FASTA records
+    # @param strategy [Rafflesia::Types::MsaFromSearchRequestStrategy, nil]
+    # @param threads [Integer, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeMsaFromSearchData]
+    def msaFromSearch(
+      query:,
+      cache_mode: nil,
+      db: nil,
+      dry_run: nil,
+      extra_args: nil,
+      hit_fasta_path: nil,
+      homology_search_id: nil,
+      include_query: nil,
+      kmer_size: nil,
+      max_hits: nil,
+      min_identity: nil,
+      output_dir: nil,
+      search_backend: nil,
+      search_object_id: nil,
+      sequence_catalog_object_id: nil,
+      strategy: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'cache_mode' => cache_mode,
+        'db' => db,
+        'dry_run' => dry_run,
+        'extra_args' => extra_args,
+        'hit_fasta_path' => hit_fasta_path,
+        'homology_search_id' => homology_search_id,
+        'include_query' => include_query,
+        'kmer_size' => kmer_size,
+        'max_hits' => max_hits,
+        'min_identity' => min_identity,
+        'output_dir' => output_dir,
+        'query' => query,
+        'search_backend' => search_backend,
+        'search_object_id' => search_object_id,
+        'sequence_catalog_object_id' => sequence_catalog_object_id,
+        'strategy' => strategy,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/msa/from-search',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeMsaFromSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/msa/inspect
+    # @param alignment_object_id [String, nil] Object id containing aligned FASTA to inspect
+    # @param alignment_path [String, nil] Aligned FASTA path to inspect
+    # @param database [String, nil] Database name published with the relation
+    # @param include_columns [Boolean, nil] Include per-column conservation summaries
+    # @param max_columns [Integer, nil] Maximum number of column summaries to return when include_columns is true; 0 means all columns
+    # @param output_format [Rafflesia::Types::MsaInspectRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeMsaInspectData]
+    def msaInspect(
+      alignment_object_id: nil,
+      alignment_path: nil,
+      database: nil,
+      include_columns: nil,
+      max_columns: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'alignment_object_id' => alignment_object_id,
+        'alignment_path' => alignment_path,
+        'database' => database,
+        'include_columns' => include_columns,
+        'max_columns' => max_columns,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/msa/inspect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeMsaInspectData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/profiles/build
+    # @param alignment_object_id [String, nil] Object id containing aligned FASTA/MSA bytes
+    # @param alignment_path [String, nil] Aligned FASTA/MSA path consumed by hmmbuild
+    # @param cache_mode [Rafflesia::Types::ProfileBuildRequestCacheMode, nil] Artifact cache mode. use reuses matching cached profiles, refresh recomputes and stores, off recomputes without storing.
+    # @param dry_run [Boolean, nil] Return the deterministic hmmbuild command without executing
+    # @param extra_args [Array<String>, nil] Explicit additional hmmbuild arguments
+    # @param name [String, nil] Optional profile name passed to hmmbuild -n
+    # @param output_dir [String, nil] Directory for generated profile-HMM files
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeProfileBuildData]
+    def profilesBuild(
+      alignment_object_id: nil,
+      alignment_path: nil,
+      cache_mode: nil,
+      dry_run: nil,
+      extra_args: nil,
+      name: nil,
+      output_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'alignment_object_id' => alignment_object_id,
+        'alignment_path' => alignment_path,
+        'cache_mode' => cache_mode,
+        'dry_run' => dry_run,
+        'extra_args' => extra_args,
+        'name' => name,
+        'output_dir' => output_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/profiles/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeProfileBuildData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/records/fetch
+    # @param allow_network [Boolean, nil]
+    # @param target_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceData]
+    def recordsFetch(
+      target_id:,
+      allow_network: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_network' => allow_network,
+        'target_id' => target_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/records/fetch',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/records/import
+    # @param path [String]
+    # @param target_id [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceImportData]
+    def recordsImport(
+      path:,
+      target_id: nil,
+      request_options: {}
+    )
+      body = {
+        'path' => path,
+        'target_id' => target_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/records/import',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceImportData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/records/inspect
+    # @param sequence_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceInspectData]
+    def recordsInspect(
+      sequence_id:,
+      request_options: {}
+    )
+      body = {
+        'sequence_id' => sequence_id
+      }
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/records/inspect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceInspectData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search
+    # @param database [String, nil] Database name published with the relation
+    # @param db [String, nil]
+    # @param kmer_size [Integer, nil]
+    # @param max_hits [Integer, nil]
+    # @param min_identity [Float, nil]
+    # @param output_format [Rafflesia::Types::SequenceSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param query [String]
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSearchData]
+    def search(
+      query:,
+      database: nil,
+      db: nil,
+      kmer_size: nil,
+      max_hits: nil,
+      min_identity: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'db' => db,
+        'kmer_size' => kmer_size,
+        'max_hits' => max_hits,
+        'min_identity' => min_identity,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/blast
+    # @param concurrency [Integer, nil] Maximum BLAST shard searches to execute concurrently when db_refs is set; defaults to 4.
+    # @param database [String, nil] Database name published with the relation
+    # @param db [String, nil] Published BLAST DB ref, manifest path, or materialized DB prefix
+    # @param db_refs [Array<String>, nil] Optional published BLAST DB refs to search as independent shards; when set, db is optional.
+    # @param dry_run [Boolean, nil] Return the deterministic command without executing BLAST
+    # @param evalue [String, nil] BLAST e-value threshold; passed through as text
+    # @param manifest_path [String, nil] Optional manifest path when db is not a published ref
+    # @param materialize [Boolean, nil] Whether to materialize DB artifacts before search; defaults to true for manifests/refs
+    # @param max_exact_shards [Integer, nil] Optional hard cap on exact BLAST shards searched after routing or explicit selection.
+    # @param max_materialized_bytes [Integer, nil] Optional hard cap on planned local bytes materialized before exact BLAST scoring.
+    # @param max_object_bytes [Integer, nil] Optional hard cap on planned object-store bytes read for routing or materialization.
+    # @param max_object_reads [Integer, nil] Optional hard cap on planned object-store reads for routing or materialization.
+    # @param max_target_seqs [Integer, nil] Maximum target sequences; defaults to 100
+    # @param min_bit_score [Float, nil] Optional client-visible hit filter applied after BLAST tabular parsing
+    # @param out_format [String, nil] BLAST outfmt value; defaults to deterministic tabular fields
+    # @param output_dir [String, nil] Directory for raw BLAST result artifacts
+    # @param output_format [Rafflesia::Types::BlastSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param pack_access_mode [Rafflesia::Types::BlastSearchRequestPackAccessMode, nil] For rafflesia_pack indexes, choose local materialization or direct object-store range reads; auto prefers remote_range when executable object URLs are available. object_native requires a routing seed index and scores selected payload records in-process without a BLAST DB.
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param profile [Boolean, nil] Include per-phase wall-clock timing (query resolve, DB materialize, BLAST search, normalized-output store) in the response.
+    # @param program [Rafflesia::Types::BlastSearchRequestProgram, nil] BLAST executable; defaults to blastp
+    # @param query [String] Query FASTA path or cached sequence id
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param require_routing [Boolean, nil] Require a routing index or candidate-pruned path instead of a full exact search over every selected shard.
+    # @param require_zero_materialization [Boolean, nil] Require the planned path to materialize zero local database bytes before exact BLAST scoring.
+    # @param routing_concurrency [Integer, nil] Maximum concurrent object reads for the routing seed index; defaults to 8.
+    # @param routing_index_id [String, nil] Published sequence seed-index id used to preselect BLAST candidate subjects.
+    # @param routing_kmer_size [Integer, nil] Optional query k-mer size for the routing seed index; must match the index k-mer size when set.
+    # @param routing_manifest_object_id [String, nil] Object id for an object-backed sequence seed index used to preselect BLAST candidate subjects before exact BLAST scoring.
+    # @param routing_manifest_path [String, nil] Local sequence seed-index manifest used to preselect BLAST candidate subjects before exact BLAST scoring.
+    # @param routing_max_candidates [Integer, nil] Maximum seed-index candidates selected for exact BLAST scoring; defaults to max_target_seqs.
+    # @param routing_min_identity [Float, nil] Minimum seed-index k-mer identity fraction for BLAST candidate preselection.
+    # @param routing_name [String, nil] Published sequence seed-index name used with routing_version to preselect BLAST candidate subjects.
+    # @param routing_rerank_alignment [Boolean, nil] When true, Needleman-Wunsch reranks seed-index candidates before exact BLAST scoring.
+    # @param routing_use_block_cache [Boolean, nil] Whether to use the process-local seed-index object block cache during routing; defaults to true.
+    # @param routing_version [String, nil] Published sequence seed-index version used with routing_name to preselect BLAST candidate subjects.
+    # @param routing_wal_object_ids [Array<String>, nil] Optional sequence seed-index WAL objects to overlay during BLAST candidate routing.
+    # @param shard_ids [Array<String>, nil] Optional shard ids corresponding to db_refs; defaults to the db ref value.
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param target_dir [String, nil] Local cache directory for materialized DB files
+    # @param task [String, nil] Optional BLAST task
+    # @param threads [Integer, nil] Number of BLAST threads; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastSearchData]
+    def searchBlast(
+      query:,
+      concurrency: nil,
+      database: nil,
+      db: nil,
+      db_refs: nil,
+      dry_run: nil,
+      evalue: nil,
+      manifest_path: nil,
+      materialize: nil,
+      max_exact_shards: nil,
+      max_materialized_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      max_target_seqs: nil,
+      min_bit_score: nil,
+      out_format: nil,
+      output_dir: nil,
+      output_format: nil,
+      output_relation: nil,
+      pack_access_mode: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      profile: nil,
+      program: nil,
+      relation: nil,
+      release: nil,
+      require_routing: nil,
+      require_zero_materialization: nil,
+      routing_concurrency: nil,
+      routing_index_id: nil,
+      routing_kmer_size: nil,
+      routing_manifest_object_id: nil,
+      routing_manifest_path: nil,
+      routing_max_candidates: nil,
+      routing_min_identity: nil,
+      routing_name: nil,
+      routing_rerank_alignment: nil,
+      routing_use_block_cache: nil,
+      routing_version: nil,
+      routing_wal_object_ids: nil,
+      shard_ids: nil,
+      sort_by: nil,
+      target_dir: nil,
+      task: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'concurrency' => concurrency,
+        'database' => database,
+        'db' => db,
+        'db_refs' => db_refs,
+        'dry_run' => dry_run,
+        'evalue' => evalue,
+        'manifest_path' => manifest_path,
+        'materialize' => materialize,
+        'max_exact_shards' => max_exact_shards,
+        'max_materialized_bytes' => max_materialized_bytes,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'max_target_seqs' => max_target_seqs,
+        'min_bit_score' => min_bit_score,
+        'out_format' => out_format,
+        'output_dir' => output_dir,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'pack_access_mode' => pack_access_mode,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'profile' => profile,
+        'program' => program,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'require_routing' => require_routing,
+        'require_zero_materialization' => require_zero_materialization,
+        'routing_concurrency' => routing_concurrency,
+        'routing_index_id' => routing_index_id,
+        'routing_kmer_size' => routing_kmer_size,
+        'routing_manifest_object_id' => routing_manifest_object_id,
+        'routing_manifest_path' => routing_manifest_path,
+        'routing_max_candidates' => routing_max_candidates,
+        'routing_min_identity' => routing_min_identity,
+        'routing_name' => routing_name,
+        'routing_rerank_alignment' => routing_rerank_alignment,
+        'routing_use_block_cache' => routing_use_block_cache,
+        'routing_version' => routing_version,
+        'routing_wal_object_ids' => routing_wal_object_ids,
+        'shard_ids' => shard_ids,
+        'sort_by' => sort_by,
+        'target_dir' => target_dir,
+        'task' => task,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/blast',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/blast-catalog
+    # @param catalog [String] Object key of the catalog JSON within the store
+    # @param concurrency [Integer, nil] Max shard searches in parallel; defaults to the coordinator default
+    # @param database [String, nil] Database name published with the relation
+    # @param evalue [String, nil] BLAST e-value threshold; passed through as text
+    # @param max_target_seqs [Integer, nil] Maximum target sequences; defaults to 100
+    # @param output_format [Rafflesia::Types::BlastCatalogSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param program [Rafflesia::Types::BlastCatalogSearchRequestProgram, nil] BLAST executable; defaults to blastp
+    # @param query [String] Query FASTA path or cached sequence id
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param store_root [String] Object-store root: a path/file:// for a local bucket, or s3://bucket/prefix
+    # @param threads [Integer, nil] BLAST threads per shard; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastSearchData]
+    def searchBlastCatalog(
+      catalog:,
+      query:,
+      store_root:,
+      concurrency: nil,
+      database: nil,
+      evalue: nil,
+      max_target_seqs: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      program: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog' => catalog,
+        'concurrency' => concurrency,
+        'database' => database,
+        'evalue' => evalue,
+        'max_target_seqs' => max_target_seqs,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'program' => program,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'store_root' => store_root,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/blast-catalog',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/blast/benchmark
+    # @param db [String, nil] Published BLAST DB ref, manifest path, or materialized DB prefix used by the materialized baseline search.
+    # @param evalue [String, nil] BLAST e-value threshold passed to the baseline search and recorded on object-native search.
+    # @param manifest_path [String, nil] Optional BLAST DB manifest path used by the materialized baseline search.
+    # @param max_local_control_bytes [Integer, nil] Optional hard pass threshold for object-native local control bytes.
+    # @param max_object_bytes [Integer, nil] Optional hard pass threshold for object-native object bytes fetched.
+    # @param max_object_reads [Integer, nil] Optional hard pass threshold for object-native object reads.
+    # @param max_target_seqs [Integer, nil] Maximum hits returned by each search; defaults to 100.
+    # @param min_bit_score [Float, nil] Optional visible hit filter applied to both search responses.
+    # @param min_byte_reduction_fraction [Float, nil] Optional pass threshold for object-native byte reduction versus materialized baseline bytes.
+    # @param min_hit_overlap_fraction [Float, nil] Optional pass threshold for full returned-hit overlap against the materialized baseline.
+    # @param min_recall_at_1 [Float, nil] Optional pass threshold for recall@1 against the materialized baseline.
+    # @param min_recall_at_10 [Float, nil] Optional pass threshold for recall@10 against the materialized baseline.
+    # @param output_dir [String, nil] Directory for raw baseline BLAST result artifacts.
+    # @param profile [Boolean, nil] Include per-search wall-clock profiles in the nested search responses.
+    # @param program [String, nil] BLAST executable family to benchmark; currently blastp.
+    # @param query [String] Query FASTA path or cached sequence id used for both baseline and object-native searches.
+    # @param require_exact_pack_reads [Boolean, nil] Require object-native exact scoring to read selected Rafflesia pack blocks from object storage.
+    # @param require_no_local_control_files [Boolean, nil] Require object-native exact scoring to avoid writing local candidate/control files.
+    # @param require_zero_materialization [Boolean, nil] Require object-native search to materialize zero database bytes.
+    # @param routing_concurrency [Integer, nil] Maximum concurrent object reads for object-native routing.
+    # @param routing_index_id [String, nil] Published sequence seed-index id used by object-native search.
+    # @param routing_kmer_size [Integer, nil] Optional query k-mer size for object-native routing.
+    # @param routing_manifest_object_id [String, nil] Object id for the sequence seed index used by object-native search.
+    # @param routing_manifest_path [String, nil] Local sequence seed-index manifest used by object-native search.
+    # @param routing_max_candidates [Integer, nil] Maximum seed-index candidates selected for object-native scoring; defaults to max_target_seqs.
+    # @param routing_min_identity [Float, nil] Minimum seed-index k-mer identity fraction for object-native candidate preselection.
+    # @param routing_name [String, nil] Published sequence seed-index name used with routing_version.
+    # @param routing_rerank_alignment [Boolean, nil] When true, Needleman-Wunsch reranks seed-index candidates before object-native scoring.
+    # @param routing_use_block_cache [Boolean, nil] Whether to use the process-local seed-index object block cache during object-native routing.
+    # @param routing_version [String, nil] Published sequence seed-index version used with routing_name.
+    # @param store_artifact [Boolean, nil] Store the benchmark JSON artifact in object storage; defaults to true.
+    # @param target_dir [String, nil] Local cache directory for the materialized baseline search.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastSearchBenchmarkData]
+    def searchBlastBenchmark(
+      query:,
+      db: nil,
+      evalue: nil,
+      manifest_path: nil,
+      max_local_control_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      max_target_seqs: nil,
+      min_bit_score: nil,
+      min_byte_reduction_fraction: nil,
+      min_hit_overlap_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      output_dir: nil,
+      profile: nil,
+      program: nil,
+      require_exact_pack_reads: nil,
+      require_no_local_control_files: nil,
+      require_zero_materialization: nil,
+      routing_concurrency: nil,
+      routing_index_id: nil,
+      routing_kmer_size: nil,
+      routing_manifest_object_id: nil,
+      routing_manifest_path: nil,
+      routing_max_candidates: nil,
+      routing_min_identity: nil,
+      routing_name: nil,
+      routing_rerank_alignment: nil,
+      routing_use_block_cache: nil,
+      routing_version: nil,
+      store_artifact: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'db' => db,
+        'evalue' => evalue,
+        'manifest_path' => manifest_path,
+        'max_local_control_bytes' => max_local_control_bytes,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'max_target_seqs' => max_target_seqs,
+        'min_bit_score' => min_bit_score,
+        'min_byte_reduction_fraction' => min_byte_reduction_fraction,
+        'min_hit_overlap_fraction' => min_hit_overlap_fraction,
+        'min_recall_at_1' => min_recall_at_1,
+        'min_recall_at_10' => min_recall_at_10,
+        'output_dir' => output_dir,
+        'profile' => profile,
+        'program' => program,
+        'query' => query,
+        'require_exact_pack_reads' => require_exact_pack_reads,
+        'require_no_local_control_files' => require_no_local_control_files,
+        'require_zero_materialization' => require_zero_materialization,
+        'routing_concurrency' => routing_concurrency,
+        'routing_index_id' => routing_index_id,
+        'routing_kmer_size' => routing_kmer_size,
+        'routing_manifest_object_id' => routing_manifest_object_id,
+        'routing_manifest_path' => routing_manifest_path,
+        'routing_max_candidates' => routing_max_candidates,
+        'routing_min_identity' => routing_min_identity,
+        'routing_name' => routing_name,
+        'routing_rerank_alignment' => routing_rerank_alignment,
+        'routing_use_block_cache' => routing_use_block_cache,
+        'routing_version' => routing_version,
+        'store_artifact' => store_artifact,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/blast/benchmark',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastSearchBenchmarkData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/blast/explain
+    # @param search [Rafflesia::BlastSearchRequest]
+    # @param workload_profile [String, nil] Optional workload profile name such as blast-small or blast-large.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBlastSearchExplainData]
+    def searchBlastExplain(
+      search:,
+      workload_profile: nil,
+      request_options: {}
+    )
+      body = {
+        'search' => search,
+        'workload_profile' => workload_profile
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/blast/explain',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBlastSearchExplainData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/candidates
+    # @param max_hits [Integer, nil] Maximum number of hits returned; defaults to 10.
+    # @param max_object_bytes [Integer, nil] Optional hard budget checked against observed object bytes.
+    # @param max_object_reads [Integer, nil] Optional hard budget checked against observed object reads.
+    # @param namespace [String] Sequence candidate namespace to search.
+    # @param query [String] Query sequence ID, literal sequence, or local FASTA path.
+    # @param query_mode [Rafflesia::Types::SequenceCandidateSearchRequestQueryMode, nil] Candidate serving mode. bounded_fast avoids full payload fallback; exact_safe may scan payload shards to certify top-k.
+    # @param require_zero_materialization [Boolean, nil] Require the object-native path to materialize zero local database bytes.
+    # @param timeout_ms [Integer, nil] Hard deadline for this search in milliseconds; defaults to the sequence candidate search timeout.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceCandidateSearchData]
+    def searchCandidates(
+      namespace:,
+      query:,
+      max_hits: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      query_mode: nil,
+      require_zero_materialization: nil,
+      timeout_ms: nil,
+      request_options: {}
+    )
+      body = {
+        'max_hits' => max_hits,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'namespace' => namespace,
+        'query' => query,
+        'query_mode' => query_mode,
+        'require_zero_materialization' => require_zero_materialization,
+        'timeout_ms' => timeout_ms
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/candidates',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceCandidateSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/diamond
+    # @param database [String, nil] Database name published with the relation
+    # @param db [String, nil] Published DIAMOND DB ref, manifest path, or materialized database prefix/path
+    # @param dry_run [Boolean, nil] Return the deterministic command without executing DIAMOND
+    # @param evalue [String, nil] DIAMOND E-value threshold; passed through as text
+    # @param extra_args [Array<String>, nil] Explicit additional DIAMOND search arguments
+    # @param manifest_path [String, nil] Optional manifest path when db is not a published ref
+    # @param materialize [Boolean, nil] Whether to materialize DB artifacts before search; defaults to true for manifests/refs
+    # @param max_target_seqs [Integer, nil] Maximum target sequences; defaults to 100
+    # @param min_bit_score [Float, nil] Optional client-visible hit filter applied after parsing
+    # @param out_format [String, nil] DIAMOND outfmt value; defaults to deterministic tabular fields
+    # @param output_dir [String, nil] Directory for raw DIAMOND result artifacts
+    # @param output_format [Rafflesia::Types::DiamondSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param program [Rafflesia::Types::DiamondSearchRequestProgram, nil] DIAMOND executable mode; defaults to blastp
+    # @param query [String] Query FASTA path or cached sequence id
+    # @param query_gencode [Integer, nil] Optional query genetic code for translated search
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param target_dir [String, nil] Local cache directory for materialized DIAMOND DB files
+    # @param threads [Integer, nil] Number of DIAMOND threads; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondSearchData]
+    def searchDiamond(
+      query:,
+      database: nil,
+      db: nil,
+      dry_run: nil,
+      evalue: nil,
+      extra_args: nil,
+      manifest_path: nil,
+      materialize: nil,
+      max_target_seqs: nil,
+      min_bit_score: nil,
+      out_format: nil,
+      output_dir: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      program: nil,
+      query_gencode: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      target_dir: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'db' => db,
+        'dry_run' => dry_run,
+        'evalue' => evalue,
+        'extra_args' => extra_args,
+        'manifest_path' => manifest_path,
+        'materialize' => materialize,
+        'max_target_seqs' => max_target_seqs,
+        'min_bit_score' => min_bit_score,
+        'out_format' => out_format,
+        'output_dir' => output_dir,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'program' => program,
+        'query' => query,
+        'query_gencode' => query_gencode,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'target_dir' => target_dir,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/diamond',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/diamond-catalog
+    # @param catalog [String] Object key of the catalog JSON within the store
+    # @param concurrency [Integer, nil] Max shard searches in parallel; defaults to the coordinator default
+    # @param database [String, nil] Database name published with the relation
+    # @param evalue [String, nil] DIAMOND e-value threshold; passed through as text
+    # @param max_target_seqs [Integer, nil] Maximum target sequences; defaults to 100
+    # @param output_format [Rafflesia::Types::DiamondCatalogSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param program [Rafflesia::Types::DiamondCatalogSearchRequestProgram, nil] DIAMOND mode; defaults to blastp
+    # @param query [String] Query FASTA path or cached sequence id
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param store_root [String] Object-store root: a path/file:// for a local bucket, or s3://bucket/prefix
+    # @param threads [Integer, nil] DIAMOND threads per shard; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDiamondSearchData]
+    def searchDiamondCatalog(
+      catalog:,
+      query:,
+      store_root:,
+      concurrency: nil,
+      database: nil,
+      evalue: nil,
+      max_target_seqs: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      program: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog' => catalog,
+        'concurrency' => concurrency,
+        'database' => database,
+        'evalue' => evalue,
+        'max_target_seqs' => max_target_seqs,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'program' => program,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'store_root' => store_root,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/diamond-catalog',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDiamondSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/hmmer
+    # @param database [String, nil] Database name published with the relation
+    # @param db [String, nil] Target database path; optional when manifest contains an hmmer_db artifact
+    # @param domains [Boolean, nil] Use --domtblout and return per-domain hits
+    # @param dry_run [Boolean, nil] Return the deterministic command without executing HMMER
+    # @param evalue [String, nil] HMMER E-value threshold; passed through as text
+    # @param extra_args [Array<String>, nil] Explicit additional HMMER arguments
+    # @param manifest_object_id [String, nil] Optional neutral object-artifact manifest object id
+    # @param manifest_path [String, nil] Optional neutral object-artifact manifest path containing hmmer_db and optional query artifacts
+    # @param output_dir [String, nil] Directory for raw HMMER result artifacts
+    # @param output_format [Rafflesia::Types::HmmerSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param program [Rafflesia::Types::HmmerSearchRequestProgram, nil] HMMER executable; defaults to hmmsearch
+    # @param query [String, nil] Query profile/sequence path or cached sequence id; optional when manifest contains a query artifact
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param shards [Array<String>, nil] Optional shard ids to materialize from the manifest
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param target_dir [String, nil] Local cache root for materialized HMMER artifacts
+    # @param threads [Integer, nil] Number of HMMER CPU threads; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeHmmerSearchData]
+    def searchHmmer(
+      database: nil,
+      db: nil,
+      domains: nil,
+      dry_run: nil,
+      evalue: nil,
+      extra_args: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      output_dir: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      program: nil,
+      query: nil,
+      relation: nil,
+      release: nil,
+      shards: nil,
+      sort_by: nil,
+      target_dir: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'db' => db,
+        'domains' => domains,
+        'dry_run' => dry_run,
+        'evalue' => evalue,
+        'extra_args' => extra_args,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'output_dir' => output_dir,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'program' => program,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'shards' => shards,
+        'sort_by' => sort_by,
+        'target_dir' => target_dir,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/hmmer',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeHmmerSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/hmmer-catalog
+    # @param catalog [String] Object key of the catalog JSON within the store
+    # @param concurrency [Integer, nil] Max shard searches in parallel; defaults to the coordinator default
+    # @param database [String, nil] Database name published with the relation
+    # @param evalue [String, nil] HMMER E-value threshold; passed through as text
+    # @param limit [Integer, nil] Maximum merged hits; defaults to 50
+    # @param output_format [Rafflesia::Types::HmmerCatalogSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param program [Rafflesia::Types::HmmerCatalogSearchRequestProgram, nil] HMMER executable; defaults to hmmsearch
+    # @param query [String] Query profile/sequence path or cached sequence id
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param store_root [String] Object-store root: a path/file:// for a local bucket, or s3://bucket/prefix
+    # @param threads [Integer, nil] HMMER threads per shard; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeHmmerSearchData]
+    def searchHmmerCatalog(
+      catalog:,
+      query:,
+      store_root:,
+      concurrency: nil,
+      database: nil,
+      evalue: nil,
+      limit: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      program: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog' => catalog,
+        'concurrency' => concurrency,
+        'database' => database,
+        'evalue' => evalue,
+        'limit' => limit,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'program' => program,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'store_root' => store_root,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/hmmer-catalog',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeHmmerSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/mmseqs
+    # @param database [String, nil] Database name published with the relation
+    # @param dry_run [Boolean, nil] Return the deterministic command without executing MMseqs2
+    # @param extra_args [Array<String>, nil] Explicit additional MMseqs2 arguments
+    # @param manifest_object_id [String, nil] Optional neutral object-artifact manifest object id
+    # @param manifest_path [String, nil] Optional neutral object-artifact manifest path containing mmseqs_db_base artifacts
+    # @param max_seqs [Integer, nil] Maximum sequences per query; defaults to 300
+    # @param min_bits [Float, nil] Optional client-visible hit filter applied after parsing
+    # @param output_dir [String, nil] Directory for raw MMseqs2 result artifacts
+    # @param output_format [Rafflesia::Types::MmseqSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param query [String] Query FASTA path or cached sequence id
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sensitivity [String, nil] Optional MMseqs2 -s sensitivity value
+    # @param shards [Array<String>, nil] Optional shard ids to materialize from the manifest
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param target [String, nil] MMseqs2 target database or FASTA path; optional when manifest contains a mmseqs_db_base artifact
+    # @param target_dir [String, nil] Local cache root for materialized MMseqs2 artifacts
+    # @param threads [Integer, nil] Number of MMseqs2 threads; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeMmseqsSearchData]
+    def searchMmseqs(
+      query:,
+      database: nil,
+      dry_run: nil,
+      extra_args: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_seqs: nil,
+      min_bits: nil,
+      output_dir: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sensitivity: nil,
+      shards: nil,
+      sort_by: nil,
+      target: nil,
+      target_dir: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'dry_run' => dry_run,
+        'extra_args' => extra_args,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_seqs' => max_seqs,
+        'min_bits' => min_bits,
+        'output_dir' => output_dir,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'sensitivity' => sensitivity,
+        'shards' => shards,
+        'sort_by' => sort_by,
+        'target' => target,
+        'target_dir' => target_dir,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/mmseqs',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeMmseqsSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/mmseqs-catalog
+    # @param catalog [String] Object key of the catalog JSON within the store
+    # @param concurrency [Integer, nil] Max shard searches in parallel; defaults to the coordinator default
+    # @param database [String, nil] Database name published with the relation
+    # @param max_seqs [Integer, nil] Maximum sequences per query; defaults to 300
+    # @param output_format [Rafflesia::Types::MmseqCatalogSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param query [String] Query FASTA path or cached sequence id
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param sensitivity [String, nil] Optional MMseqs2 -s sensitivity value
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param store_root [String] Object-store root: a path/file:// for a local bucket, or s3://bucket/prefix
+    # @param threads [Integer, nil] MMseqs2 threads per shard; defaults to 1
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeMmseqsSearchData]
+    def searchMmseqsCatalog(
+      catalog:,
+      query:,
+      store_root:,
+      concurrency: nil,
+      database: nil,
+      max_seqs: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sensitivity: nil,
+      sort_by: nil,
+      threads: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog' => catalog,
+        'concurrency' => concurrency,
+        'database' => database,
+        'max_seqs' => max_seqs,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'sensitivity' => sensitivity,
+        'sort_by' => sort_by,
+        'store_root' => store_root,
+        'threads' => threads
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/mmseqs-catalog',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeMmseqsSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # POST /v1/sequences/search/seed-index
+    # @param concurrency [Integer, nil] Maximum concurrent object block reads; defaults to 8
+    # @param database [String, nil] Database name published with the relation
+    # @param index_id [String, nil] Published sequence seed index id
+    # @param kmer_size [Integer, nil] Optional query k-mer size; must match the index k-mer size when set
+    # @param manifest_object_id [String, nil] Object id for a sequence seed index manifest
+    # @param manifest_path [String, nil] Local path to a sequence seed index manifest JSON file
+    # @param max_hits [Integer, nil] Maximum number of candidate subjects returned; defaults to 100
+    # @param max_object_bytes [Integer, nil] Optional hard execution budget for object bytes. Search fails before fetching blocks when the budget would be exceeded.
+    # @param max_object_reads [Integer, nil] Optional hard execution budget for object reads. Search fails before fetching blocks when the budget would be exceeded.
+    # @param min_identity [Float, nil] Minimum fraction of distinct query k-mers present in a subject
+    # @param name [String, nil] Published sequence seed index name
+    # @param output_format [Rafflesia::Types::SequenceSeedIndexSearchRequestOutputFormat, nil] Requested durable relation format; parquet is the initial physical format
+    # @param output_relation [String, nil] Local output path or alias for a durable relation artifact
+    # @param partition_by [Array<String>, nil] Requested physical partition columns
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param query [String] Sequence ID or local FASTA path for query sequence
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param require_zero_materialization [Boolean, nil] Require the object-native execution path to materialize zero database bytes
+    # @param rerank_alignment [Boolean, nil] When true, run deterministic Needleman-Wunsch alignment over returned candidates and sort by alignment identity
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param use_block_cache [Boolean, nil] Whether to use the process-local seed-index object block cache; defaults to true in the server
+    # @param version [String, nil] Published sequence seed index version
+    # @param wal_object_ids [Array<String>, nil] Optional sequence seed-index WAL objects to overlay on the immutable index before compaction
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSequenceSearchData]
+    def searchSeedIndex(
+      query:,
+      concurrency: nil,
+      database: nil,
+      index_id: nil,
+      kmer_size: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_hits: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      min_identity: nil,
+      name: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      require_zero_materialization: nil,
+      rerank_alignment: nil,
+      sort_by: nil,
+      use_block_cache: nil,
+      version: nil,
+      wal_object_ids: nil,
+      request_options: {}
+    )
+      body = {
+        'concurrency' => concurrency,
+        'database' => database,
+        'index_id' => index_id,
+        'kmer_size' => kmer_size,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_hits' => max_hits,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'min_identity' => min_identity,
+        'name' => name,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'query' => query,
+        'relation' => relation,
+        'release' => release,
+        'require_zero_materialization' => require_zero_materialization,
+        'rerank_alignment' => rerank_alignment,
+        'sort_by' => sort_by,
+        'use_block_cache' => use_block_cache,
+        'version' => version,
+        'wal_object_ids' => wal_object_ids
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/sequences/search/seed-index',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSequenceSearchData.new(response.body)
+      result.last_response = Rafflesia::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+  end
+end