rafflesia 0.1.0

data/lib/rafflesia/proteins.rb

@@ -0,0 +1,3992 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+require 'json'
+
+module Rafflesia
+  class Proteins
+    def initialize(client)
+      @client = client
+    end
+
+    # POST /v1/proteins/aromatic-stacking/detect
+    # @param max_centroid [Float, nil]
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeAromaticStackingDetectData]
+    def aromaticStackingDetect(
+      structure_id:,
+      max_centroid: nil,
+      request_options: {}
+    )
+      body = {
+        'max_centroid' => max_centroid,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/aromatic-stacking/detect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeAromaticStackingDetectData.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/proteins/cation-pi/detect
+    # @param max_angle [Float, nil]
+    # @param max_distance [Float, nil]
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeCationPiDetectData]
+    def cationPiDetect(
+      structure_id:,
+      max_angle: nil,
+      max_distance: nil,
+      request_options: {}
+    )
+      body = {
+        'max_angle' => max_angle,
+        'max_distance' => max_distance,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/cation-pi/detect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeCationPiDetectData.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/proteins/complexes/import
+    # @param path [String]
+    # @param source [String, nil]
+    # @param target_id [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeComplexImportData]
+    def complexesImport(
+      path:,
+      source: nil,
+      target_id: nil,
+      request_options: {}
+    )
+      body = {
+        'path' => path,
+        'source' => source,
+        'target_id' => target_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/complexes/import',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeComplexImportData.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/proteins/confidence/summary
+    # @param chain [String, nil]
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::ConfidenceSummaryRequestOutputFormat, 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 structure_id [String]
+    # @param threshold [Float, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeConfidenceSummaryData]
+    def confidenceSummary(
+      structure_id:,
+      chain: nil,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      threshold: nil,
+      request_options: {}
+    )
+      body = {
+        'chain' => chain,
+        'database' => database,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id,
+        'threshold' => threshold
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/confidence/summary',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeConfidenceSummaryData.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/proteins/disulfides/detect
+    # @param max_distance [Float, nil] maximum Sγ-Sγ distance in Å treated as a bond (default 2.5)
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDisulfideDetectData]
+    def disulfidesDetect(
+      structure_id:,
+      max_distance: nil,
+      request_options: {}
+    )
+      body = {
+        'max_distance' => max_distance,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/disulfides/detect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDisulfideDetectData.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/proteins/dynamics/anm
+    # @param chain [String, nil] restrict the network to a single chain id; empty uses every protein chain
+    # @param cutoff [Float, nil] Cα–Cα contact cutoff in Å (default 13)
+    # @param modes [Integer, nil] number of slowest non-trivial modes to return (default 6)
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeAnmFluctuationsData]
+    def dynamicsAnm(
+      structure_id:,
+      chain: nil,
+      cutoff: nil,
+      modes: nil,
+      request_options: {}
+    )
+      body = {
+        'chain' => chain,
+        'cutoff' => cutoff,
+        'modes' => modes,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/dynamics/anm',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeAnmFluctuationsData.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/proteins/dynamics/gnm
+    # @param chain [String, nil] restrict the network to a single chain id; empty uses every protein chain
+    # @param cutoff [Float, nil] Cα–Cα contact cutoff in Å (default 7.3)
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeGnmFluctuationsData]
+    def dynamicsGnm(
+      structure_id:,
+      chain: nil,
+      cutoff: nil,
+      request_options: {}
+    )
+      body = {
+        'chain' => chain,
+        'cutoff' => cutoff,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/dynamics/gnm',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeGnmFluctuationsData.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/proteins/folds/align
+    # @param backend [String, nil]
+    # @param query_id [String]
+    # @param target_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldAlignData]
+    def foldsAlign(
+      query_id:,
+      target_id:,
+      backend: nil,
+      request_options: {}
+    )
+      body = {
+        'backend' => backend,
+        'query_id' => query_id,
+        'target_id' => target_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/align',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldAlignData.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/proteins/folds/candidates/build
+    # @param build_policy [Rafflesia::Types::ProteinFoldCandidateBuildRequestBuildPolicy, 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 JSON array of structure records.
+    # @param input_path [String, nil] JSON file containing an array of structure records.
+    # @param kmer_size [Integer, nil] Structural token k-mer size; defaults to 3.
+    # @param min_shared_tokens [Integer, nil] Candidate threshold on shared structural tokens; defaults to 1.
+    # @param name [String, nil] Logical structure index name carried into provenance and namespace derivation.
+    # @param namespace [String, nil] Explicit structure candidate namespace. Defaults to a deterministic namespace derived from name and version.
+    # @param timeout_ms [Integer, nil] Hard deadline for this build operation in milliseconds; defaults to the structure candidate build timeout.
+    # @param version [String, nil] Immutable structure index version carried into provenance and namespace derivation.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeProteinFoldCandidateBuildData]
+    def foldsCandidatesBuild(
+      build_policy: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      input_object_id: nil,
+      input_path: nil,
+      kmer_size: nil,
+      min_shared_tokens: nil,
+      name: nil,
+      namespace: 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,
+        'min_shared_tokens' => min_shared_tokens,
+        'name' => name,
+        'namespace' => namespace,
+        'timeout_ms' => timeout_ms,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/candidates/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeProteinFoldCandidateBuildData.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/proteins/folds/candidates/search
+    # @param kmer_size [Integer, nil] Structural token k-mer size; defaults to the build/query family default.
+    # @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 min_shared_tokens [Integer, nil] Candidate threshold on shared structural tokens; defaults to 1.
+    # @param namespace [String] Structure candidate namespace to search.
+    # @param query_object_id [String, nil] Object id containing one query structure record.
+    # @param query_path [String, nil] JSON file containing one query structure record.
+    # @param query_structure [Rafflesia::ProteinFoldCandidateRecord, nil] Inline query structure record.
+    # @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 structure candidate search timeout.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeProteinFoldCandidateSearchData]
+    def foldsCandidatesSearch(
+      namespace:,
+      kmer_size: nil,
+      max_hits: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      min_shared_tokens: nil,
+      query_object_id: nil,
+      query_path: nil,
+      query_structure: nil,
+      require_zero_materialization: nil,
+      timeout_ms: nil,
+      request_options: {}
+    )
+      body = {
+        'kmer_size' => kmer_size,
+        'max_hits' => max_hits,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'min_shared_tokens' => min_shared_tokens,
+        'namespace' => namespace,
+        'query_object_id' => query_object_id,
+        'query_path' => query_path,
+        'query_structure' => query_structure,
+        'require_zero_materialization' => require_zero_materialization,
+        'timeout_ms' => timeout_ms
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/candidates/search',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeProteinFoldCandidateSearchData.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/proteins/folds/collections/benchmark
+    # @param exact_limit [Integer, nil] Maximum routed candidates to verify exactly per segment; defaults to limit when exact_verify is true.
+    # @param exact_verify [Boolean, nil] Run candidate-only TM-align verification for routed collection search before measuring recall.
+    # @param limit [Integer, nil] Per-query hit limit; defaults to 100.
+    # @param max_blocks_per_query [Integer, nil] Optional per-query cap on selected routed feature blocks across the collection.
+    # @param max_object_bytes_per_query [Integer, nil] Optional per-query cap on routed collection object bytes read.
+    # @param max_object_reads_per_query [Integer, nil] Optional per-query cap on routed collection object reads.
+    # @param max_segments [Integer, nil] Maximum routed collection segments to search per query; defaults to a bounded planner value.
+    # @param max_segments_per_query [Integer, nil] Optional per-query cap on routed collection segments searched.
+    # @param min_byte_reduction_fraction [Float, nil] Optional pass threshold for object byte reduction against exhaustive collection scan.
+    # @param min_recall_at_1 [Float, nil] Optional pass threshold for recall_at_1.
+    # @param min_recall_at_10 [Float, nil] Optional pass threshold for recall_at_10.
+    # @param min_recall_at_100 [Float, nil] Optional pass threshold for recall_at_100.
+    # @param min_routing_score_coverage [Float, nil] Optional pass threshold for selected routing score coverage across benchmark queries.
+    # @param min_segment_reduction_fraction [Float, nil] Optional pass threshold for routed segment fanout reduction against exhaustive collection scan.
+    # @param nprobe [Integer, nil] Routed object feature block count per segment; defaults to 1.
+    # @param query_ids [Array<String>, nil] Explicit query structure ids or paths to benchmark.
+    # @param recall_at [Array<Integer>, nil] Recall cutoffs to compute against exhaustive collection scan; defaults to 1,10,100.
+    # @param ref [String, nil] Published fold collection ref or immutable snapshot ref.
+    # @param require_adaptive_routing [Boolean, nil] Require routed benchmark searches to use adaptive routing fanout.
+    # @param require_exact_verification [Boolean, nil] Require every routed collection query to report exact candidate verification.
+    # @param require_routing [Boolean, nil] Require routed search to use the collection routing directory instead of exhaustive fanout.
+    # @param require_zero_materialization [Boolean, nil] Require the object-native collection path to materialize zero local database bytes.
+    # @param routing_mode [Rafflesia::Types::FoldCollectionBenchmarkRequestRoutingMode, nil] Collection fanout mode for routed benchmark searches.
+    # @param segment_refs [Array<String>, nil] Explicit published fold segment refs to benchmark without resolving a collection ref.
+    # @param store_artifact [Boolean, nil] Whether to store the benchmark JSON artifact in the object store; defaults to true.
+    # @param store_calibration [Boolean, nil] Whether to store the derived routing calibration profile in the object store; defaults to store_artifact.
+    # @param target_score_coverage [Float, nil] Adaptive routing score-coverage target for routed benchmark searches.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldCollectionBenchmarkData]
+    def foldsCollectionsBenchmark(
+      query_ids:,
+      exact_limit: nil,
+      exact_verify: nil,
+      limit: nil,
+      max_blocks_per_query: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      max_segments: nil,
+      max_segments_per_query: nil,
+      min_byte_reduction_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      min_recall_at_100: nil,
+      min_routing_score_coverage: nil,
+      min_segment_reduction_fraction: nil,
+      nprobe: nil,
+      recall_at: nil,
+      ref: nil,
+      require_adaptive_routing: nil,
+      require_exact_verification: nil,
+      require_routing: nil,
+      require_zero_materialization: nil,
+      routing_mode: nil,
+      segment_refs: nil,
+      store_artifact: nil,
+      store_calibration: nil,
+      target_score_coverage: nil,
+      request_options: {}
+    )
+      body = {
+        'exact_limit' => exact_limit,
+        'exact_verify' => exact_verify,
+        'limit' => limit,
+        'max_blocks_per_query' => max_blocks_per_query,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'max_segments' => max_segments,
+        'max_segments_per_query' => max_segments_per_query,
+        'min_byte_reduction_fraction' => min_byte_reduction_fraction,
+        'min_recall_at_1' => min_recall_at_1,
+        'min_recall_at_10' => min_recall_at_10,
+        'min_recall_at_100' => min_recall_at_100,
+        'min_routing_score_coverage' => min_routing_score_coverage,
+        'min_segment_reduction_fraction' => min_segment_reduction_fraction,
+        'nprobe' => nprobe,
+        'query_ids' => query_ids,
+        'recall_at' => recall_at,
+        'ref' => ref,
+        'require_adaptive_routing' => require_adaptive_routing,
+        'require_exact_verification' => require_exact_verification,
+        'require_routing' => require_routing,
+        'require_zero_materialization' => require_zero_materialization,
+        'routing_mode' => routing_mode,
+        'segment_refs' => segment_refs,
+        'store_artifact' => store_artifact,
+        'store_calibration' => store_calibration,
+        'target_score_coverage' => target_score_coverage
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/collections/benchmark',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldCollectionBenchmarkData.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/proteins/folds/collections/calibrate
+    # @param allow_regression [Boolean, nil] Allow promotion even when the candidate regresses against the current calibration comparison.
+    # @param current_calibration_object_id [String, nil] Explicit current calibration profile object id to compare against; defaults to the collection's current calibration.
+    # @param exact_limit [Integer, nil] Maximum routed candidates to verify exactly per segment; defaults to limit when exact_verify is true.
+    # @param exact_verify [Boolean, nil] Run candidate-only TM-align verification before measuring recall.
+    # @param limit [Integer, nil] Per-query hit limit; defaults to 100.
+    # @param max_blocks_per_query [Integer, nil] Optional per-query cap on selected routed feature blocks across the collection.
+    # @param max_object_bytes_per_query [Integer, nil] Optional per-query cap on routed collection object bytes read.
+    # @param max_object_reads_per_query [Integer, nil] Optional per-query cap on routed collection object reads.
+    # @param max_segments [Integer, nil] Maximum routed collection segments to search per query; defaults to a bounded planner value.
+    # @param max_segments_per_query [Integer, nil] Optional per-query cap on routed collection segments searched.
+    # @param min_byte_reduction_fraction [Float, nil] Optional pass threshold for object byte reduction against exhaustive collection scan.
+    # @param min_object_read_reduction_improvement [Float, nil] Minimum candidate planned object-read reduction improvement over the current calibration before promotion.
+    # @param min_recall_at_1 [Float, nil] Optional pass threshold for recall_at_1.
+    # @param min_recall_at_10 [Float, nil] Optional pass threshold for recall_at_10.
+    # @param min_recall_at_100 [Float, nil] Optional pass threshold for recall_at_100.
+    # @param min_recall_at_1_improvement [Float, nil] Minimum candidate recall_at_1 improvement over the current calibration before promotion.
+    # @param min_routing_score_coverage [Float, nil] Optional pass threshold for selected routing score coverage across calibration queries.
+    # @param min_segment_reduction_fraction [Float, nil] Optional pass threshold for routed segment fanout reduction against exhaustive collection scan.
+    # @param min_segment_reduction_improvement [Float, nil] Minimum candidate segment reduction improvement over the current calibration before promotion.
+    # @param nprobe [Integer, nil] Routed object feature block count per segment; defaults to 1.
+    # @param promote [Boolean, nil] Promote the candidate calibration to the collection's mutable ref when promotion gates pass.
+    # @param query_ids [Array<String>, nil] Explicit query structure ids or paths to use as the calibration sample.
+    # @param recall_at [Array<Integer>, nil] Recall cutoffs to compute against exhaustive collection scan; defaults to 1,10,100.
+    # @param ref [String, nil] Published fold collection ref or immutable snapshot ref.
+    # @param require_adaptive_routing [Boolean, nil] Require routed calibration searches to use adaptive routing fanout.
+    # @param require_exact_verification [Boolean, nil] Require every routed collection query to report exact candidate verification.
+    # @param require_routing [Boolean, nil] Require routed search to use the collection routing directory instead of exhaustive fanout.
+    # @param require_zero_materialization [Boolean, nil] Require the object-native collection path to materialize zero local database bytes.
+    # @param routing_mode [Rafflesia::Types::FoldCollectionCalibrateRequestRoutingMode, nil] Collection fanout mode for candidate calibration searches.
+    # @param segment_refs [Array<String>, nil] Explicit published fold segment refs to calibrate without resolving a collection ref.
+    # @param store_artifact [Boolean, nil] Whether to store the benchmark JSON artifact in the object store; defaults to true.
+    # @param store_calibration [Boolean, nil] Whether to store the derived routing calibration profile in the object store; defaults to true.
+    # @param store_telemetry [Boolean, nil] Whether to store per-query calibration telemetry in the object store; defaults to true.
+    # @param target_score_coverage [Float, nil] Adaptive routing score-coverage target for candidate calibration searches.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldCollectionCalibrateData]
+    def foldsCollectionsCalibrate(
+      query_ids:,
+      allow_regression: nil,
+      current_calibration_object_id: nil,
+      exact_limit: nil,
+      exact_verify: nil,
+      limit: nil,
+      max_blocks_per_query: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      max_segments: nil,
+      max_segments_per_query: nil,
+      min_byte_reduction_fraction: nil,
+      min_object_read_reduction_improvement: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      min_recall_at_100: nil,
+      min_recall_at_1_improvement: nil,
+      min_routing_score_coverage: nil,
+      min_segment_reduction_fraction: nil,
+      min_segment_reduction_improvement: nil,
+      nprobe: nil,
+      promote: nil,
+      recall_at: nil,
+      ref: nil,
+      require_adaptive_routing: nil,
+      require_exact_verification: nil,
+      require_routing: nil,
+      require_zero_materialization: nil,
+      routing_mode: nil,
+      segment_refs: nil,
+      store_artifact: nil,
+      store_calibration: nil,
+      store_telemetry: nil,
+      target_score_coverage: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_regression' => allow_regression,
+        'current_calibration_object_id' => current_calibration_object_id,
+        'exact_limit' => exact_limit,
+        'exact_verify' => exact_verify,
+        'limit' => limit,
+        'max_blocks_per_query' => max_blocks_per_query,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'max_segments' => max_segments,
+        'max_segments_per_query' => max_segments_per_query,
+        'min_byte_reduction_fraction' => min_byte_reduction_fraction,
+        'min_object_read_reduction_improvement' => min_object_read_reduction_improvement,
+        'min_recall_at_1' => min_recall_at_1,
+        'min_recall_at_10' => min_recall_at_10,
+        'min_recall_at_100' => min_recall_at_100,
+        'min_recall_at_1_improvement' => min_recall_at_1_improvement,
+        'min_routing_score_coverage' => min_routing_score_coverage,
+        'min_segment_reduction_fraction' => min_segment_reduction_fraction,
+        'min_segment_reduction_improvement' => min_segment_reduction_improvement,
+        'nprobe' => nprobe,
+        'promote' => promote,
+        'query_ids' => query_ids,
+        'recall_at' => recall_at,
+        'ref' => ref,
+        'require_adaptive_routing' => require_adaptive_routing,
+        'require_exact_verification' => require_exact_verification,
+        'require_routing' => require_routing,
+        'require_zero_materialization' => require_zero_materialization,
+        'routing_mode' => routing_mode,
+        'segment_refs' => segment_refs,
+        'store_artifact' => store_artifact,
+        'store_calibration' => store_calibration,
+        'store_telemetry' => store_telemetry,
+        'target_score_coverage' => target_score_coverage
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/collections/calibrate',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldCollectionCalibrateData.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/proteins/folds/collections/gc
+    # @param candidate_refs [Array<String>, nil] Published fold collection refs considered for collection; repeatable.
+    # @param candidate_segment_refs [Array<String>, nil] Additional candidate published fold segment refs; repeatable.
+    # @param dry_run [Boolean, nil] Whether to only report unused objects; defaults to true.
+    # @param keep_refs [Array<String>, nil] Published fold collection refs that remain live; repeatable.
+    # @param keep_segment_refs [Array<String>, nil] Additional live published fold segment refs; repeatable.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldCollectionGcData]
+    def foldsCollectionsGc(
+      candidate_refs: nil,
+      candidate_segment_refs: nil,
+      dry_run: nil,
+      keep_refs: nil,
+      keep_segment_refs: nil,
+      request_options: {}
+    )
+      body = {
+        'candidate_refs' => candidate_refs,
+        'candidate_segment_refs' => candidate_segment_refs,
+        'dry_run' => dry_run,
+        'keep_refs' => keep_refs,
+        'keep_segment_refs' => keep_segment_refs
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/collections/gc',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldCollectionGcData.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/proteins/folds/collections/publish
+    # @param benchmark_object_id [String, nil] Object id produced by proteins.folds.collections.benchmark.
+    # @param calibration_object_id [String, nil] Object id for a collection routing calibration profile produced by proteins.folds.collections.benchmark.
+    # @param compaction_generation [Integer, nil] Monotonic compaction generation represented by this snapshot.
+    # @param generation [Integer, nil] Monotonic collection generation supplied by the caller.
+    # @param max_blocks_per_query [Integer, nil] Maximum selected routed feature blocks per benchmark query.
+    # @param max_object_bytes_per_query [Integer, nil] Maximum planned routed object bytes per benchmark query.
+    # @param max_object_reads_per_query [Integer, nil] Maximum planned routed object reads per benchmark query.
+    # @param max_segments_per_query [Integer, nil] Maximum routed collection segments searched per benchmark query.
+    # @param min_byte_reduction_fraction [Float, nil] Publish gate threshold for planned object byte reduction.
+    # @param min_recall_at_1 [Float, nil] Publish gate threshold for collection recall_at_1.
+    # @param min_recall_at_10 [Float, nil] Publish gate threshold for collection recall_at_10.
+    # @param min_recall_at_100 [Float, nil] Publish gate threshold for collection recall_at_100.
+    # @param min_routing_score_coverage [Float, nil] Publish gate threshold for routed collection score coverage selected by the planner.
+    # @param min_segment_reduction_fraction [Float, nil] Publish gate threshold for routed segment fanout reduction against exhaustive collection scan.
+    # @param name [String] Logical fold collection name.
+    # @param ref [String, nil] Mutable collection alias to publish atomically, for example afdb:active; defaults to snapshot_ref.
+    # @param require_adaptive_routing [Boolean, nil] Require benchmark evidence that collection search used adaptive routing fanout.
+    # @param require_benchmark [Boolean, nil] Require a passing fold collection benchmark artifact before publishing.
+    # @param require_calibration [Boolean, nil] Require a benchmark-derived collection routing calibration profile before publishing.
+    # @param require_exact_verification [Boolean, nil] Require benchmark evidence that routed collection search exactly verified candidates.
+    # @param require_routing [Boolean, nil] Require benchmark evidence that collection search used the routing directory instead of exhaustive fanout.
+    # @param require_zero_materialization [Boolean, nil] Require benchmark evidence that routed collection search materialized zero local database bytes.
+    # @param segment_refs [Array<String>, nil] Published fold segment refs active in this collection snapshot.
+    # @param snapshot_ref [String, nil] Immutable collection snapshot ref; defaults to name:version.
+    # @param version [String] Immutable collection snapshot version.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldCollectionPublishData]
+    def foldsCollectionsPublish(
+      name:,
+      segment_refs:,
+      version:,
+      benchmark_object_id: nil,
+      calibration_object_id: nil,
+      compaction_generation: nil,
+      generation: nil,
+      max_blocks_per_query: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      max_segments_per_query: nil,
+      min_byte_reduction_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      min_recall_at_100: nil,
+      min_routing_score_coverage: nil,
+      min_segment_reduction_fraction: nil,
+      ref: nil,
+      require_adaptive_routing: nil,
+      require_benchmark: nil,
+      require_calibration: nil,
+      require_exact_verification: nil,
+      require_routing: nil,
+      require_zero_materialization: nil,
+      snapshot_ref: nil,
+      request_options: {}
+    )
+      body = {
+        'benchmark_object_id' => benchmark_object_id,
+        'calibration_object_id' => calibration_object_id,
+        'compaction_generation' => compaction_generation,
+        'generation' => generation,
+        'max_blocks_per_query' => max_blocks_per_query,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'max_segments_per_query' => max_segments_per_query,
+        'min_byte_reduction_fraction' => min_byte_reduction_fraction,
+        'min_recall_at_1' => min_recall_at_1,
+        'min_recall_at_10' => min_recall_at_10,
+        'min_recall_at_100' => min_recall_at_100,
+        'min_routing_score_coverage' => min_routing_score_coverage,
+        'min_segment_reduction_fraction' => min_segment_reduction_fraction,
+        'name' => name,
+        'ref' => ref,
+        'require_adaptive_routing' => require_adaptive_routing,
+        'require_benchmark' => require_benchmark,
+        'require_calibration' => require_calibration,
+        'require_exact_verification' => require_exact_verification,
+        'require_routing' => require_routing,
+        'require_zero_materialization' => require_zero_materialization,
+        'segment_refs' => segment_refs,
+        'snapshot_ref' => snapshot_ref,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/collections/publish',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldCollectionPublishData.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/proteins/folds/collections/search
+    # @param calibration_object_id [String, nil] Explicit collection routing calibration profile object id to use for planning.
+    # @param distributed [Boolean, nil] Execute selected segment searches as deterministic worker tasks before merging results.
+    # @param dry_run [Boolean, nil] Return the deterministic read plan without fetching feature blocks.
+    # @param exact_limit [Integer, nil] Maximum routed candidates to verify exactly per segment; defaults to limit when exact_verify is true.
+    # @param exact_verify [Boolean, nil] Run candidate-only TM-align verification inside each searched segment before merging hits.
+    # @param limit [Integer, nil] Maximum merged fold feature hits to return; defaults to 50.
+    # @param max_blocks [Integer, nil] Optional hard budget for total selected feature blocks across the collection.
+    # @param max_materialized_bytes [Integer, nil] Optional hard budget for total local database materialization bytes.
+    # @param max_object_bytes [Integer, nil] Optional hard budget for total planned collection object bytes.
+    # @param max_object_reads [Integer, nil] Optional hard budget for total planned collection object reads.
+    # @param max_segments [Integer, nil] Maximum routed collection segments to search; defaults to a bounded planner value when a routing directory is available.
+    # @param max_workers [Integer, nil] Maximum concurrent collection segment worker tasks when distributed execution is enabled.
+    # @param nprobe [Integer, nil] Number of adjacent feature blocks to probe per segment; defaults to 1.
+    # @param query_id [String] Stored structure id or local PDB/mmCIF path used as the query.
+    # @param ref [String, nil] Published fold collection ref or immutable snapshot ref.
+    # @param require_complete [Boolean, nil] Whether distributed collection search must fail if any selected segment worker fails; defaults to true.
+    # @param require_routing [Boolean, nil] Require collection-level routing to choose a bounded segment subset.
+    # @param require_zero_materialization [Boolean, nil] Require the collection search path to materialize zero local database bytes.
+    # @param routing_mode [Rafflesia::Types::FoldCollectionSearchRequestRoutingMode, nil] Collection fanout mode. auto selects adaptive fanout unless max_segments is explicitly set; fixed uses max_segments/default cap.
+    # @param segment_refs [Array<String>, nil] Explicit published fold segment refs to search without resolving a collection ref.
+    # @param store_plan [Boolean, nil] Whether to store the deterministic distributed collection search plan artifact; defaults to distributed.
+    # @param target_score_coverage [Float, nil] Adaptive routing target for cumulative positive routing-score coverage. Defaults to a conservative planner target.
+    # @param use_calibration [Boolean, nil] Use the collection's benchmark-derived routing calibration profile to fill unset routing parameters.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldCollectionSearchData]
+    def foldsCollectionsSearch(
+      query_id:,
+      calibration_object_id: nil,
+      distributed: nil,
+      dry_run: nil,
+      exact_limit: nil,
+      exact_verify: nil,
+      limit: nil,
+      max_blocks: nil,
+      max_materialized_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      max_segments: nil,
+      max_workers: nil,
+      nprobe: nil,
+      ref: nil,
+      require_complete: nil,
+      require_routing: nil,
+      require_zero_materialization: nil,
+      routing_mode: nil,
+      segment_refs: nil,
+      store_plan: nil,
+      target_score_coverage: nil,
+      use_calibration: nil,
+      request_options: {}
+    )
+      body = {
+        'calibration_object_id' => calibration_object_id,
+        'distributed' => distributed,
+        'dry_run' => dry_run,
+        'exact_limit' => exact_limit,
+        'exact_verify' => exact_verify,
+        'limit' => limit,
+        'max_blocks' => max_blocks,
+        'max_materialized_bytes' => max_materialized_bytes,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'max_segments' => max_segments,
+        'max_workers' => max_workers,
+        'nprobe' => nprobe,
+        'query_id' => query_id,
+        'ref' => ref,
+        'require_complete' => require_complete,
+        'require_routing' => require_routing,
+        'require_zero_materialization' => require_zero_materialization,
+        'routing_mode' => routing_mode,
+        'segment_refs' => segment_refs,
+        'store_plan' => store_plan,
+        'target_score_coverage' => target_score_coverage,
+        'use_calibration' => use_calibration
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/collections/search',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldCollectionSearchData.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/proteins/folds/datasets/gc
+    # @param dataset_id [String] Foldsearch control-plane dataset id to collect.
+    # @param dry_run [Boolean, nil] When true, compute and return the plan without marking or deleting storage.
+    # @param max_deletes [Integer, nil] Maximum versions to delete in one pass; 0 means no limit.
+    # @param min_age_seconds [Integer, nil] Grace period in seconds before a superseded version may be deleted.
+    # @param min_versions_to_keep [Integer, nil] Minimum number of newest dataset versions to retain; the server floors this to current plus one predecessor.
+    # @param protected_versions [Array<Integer>, nil] Explicit dataset versions pinned by active readers or an operator; protected versions are neither marked nor deleted this pass.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldDatasetGcData]
+    def foldsDatasetsGc(
+      dataset_id:,
+      dry_run: nil,
+      max_deletes: nil,
+      min_age_seconds: nil,
+      min_versions_to_keep: nil,
+      protected_versions: nil,
+      request_options: {}
+    )
+      body = {
+        'dataset_id' => dataset_id,
+        'dry_run' => dry_run,
+        'max_deletes' => max_deletes,
+        'min_age_seconds' => min_age_seconds,
+        'min_versions_to_keep' => min_versions_to_keep,
+        'protected_versions' => protected_versions
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/datasets/gc',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldDatasetGcData.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/proteins/folds/index/benchmark
+    # @param concurrency [Integer, nil] Maximum shard searches to execute concurrently
+    # @param limit [Integer, nil] Per-query hit limit; defaults to 100
+    # @param manifest_object_id [String, nil] Object id for a Foldseek index manifest
+    # @param manifest_path [String, nil] Local Foldseek index manifest path
+    # @param min_byte_reduction_fraction [Float, nil] Optional pass threshold for materialized byte reduction
+    # @param min_recall_at_1 [Float, nil] Optional pass threshold for recall_at_1
+    # @param min_recall_at_10 [Float, nil] Optional pass threshold for recall_at_10
+    # @param min_recall_at_100 [Float, nil] Optional pass threshold for recall_at_100
+    # @param nprobe [Integer, nil] Routed candidate shard cap; defaults to planner policy
+    # @param query_ids [Array<String>, nil] Explicit query structure ids or paths to benchmark
+    # @param recall_at [Array<Integer>, nil] Recall cutoffs to compute against full scan hits; defaults to 1,10,100
+    # @param ref [String, nil] Published Foldseek index ref such as name:version
+    # @param store_artifact [Boolean, nil] Whether to store the benchmark JSON artifact in the object store; defaults to true
+    # @param target_dir [String, nil] Benchmark cache root; full_scan and routed runs use separate subdirectories
+    # @param verify_index [Boolean, nil] Verify materialized index artifacts by SHA-256
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexBenchmarkData]
+    def foldsIndexBenchmark(
+      query_ids:,
+      concurrency: nil,
+      limit: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      min_byte_reduction_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      min_recall_at_100: nil,
+      nprobe: nil,
+      recall_at: nil,
+      ref: nil,
+      store_artifact: nil,
+      target_dir: nil,
+      verify_index: nil,
+      request_options: {}
+    )
+      body = {
+        'concurrency' => concurrency,
+        'limit' => limit,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'min_byte_reduction_fraction' => min_byte_reduction_fraction,
+        'min_recall_at_1' => min_recall_at_1,
+        'min_recall_at_10' => min_recall_at_10,
+        'min_recall_at_100' => min_recall_at_100,
+        'nprobe' => nprobe,
+        'query_ids' => query_ids,
+        'recall_at' => recall_at,
+        'ref' => ref,
+        'store_artifact' => store_artifact,
+        'target_dir' => target_dir,
+        'verify_index' => verify_index
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/index/benchmark',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexBenchmarkData.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/proteins/folds/index/build
+    # @param create_index [Boolean, nil] Run foldseek createindex after createdb and store the generated .idx artifacts
+    # @param dry_run [Boolean, nil] Return the deterministic plan without executing foldseek createdb
+    # @param name [String] Logical Foldseek index name, for example afdb50
+    # @param output_dir [String, nil] Directory for generated Foldseek DB files and index manifest
+    # @param publish [Boolean, nil] Whether to publish the built manifest into the local Foldseek index registry
+    # @param routing_representatives_per_shard [Integer, nil] Number of deterministic source representatives per non-empty shard to put in the routing segment; defaults to 1
+    # @param shard_count [Integer, nil] Number of deterministic Foldseek shards; defaults to 1
+    # @param source_manifest_object_id [String, nil] Object id of a JSON source manifest listing structure objects
+    # @param store_artifacts [Boolean, nil] Whether to store generated artifacts in the object store; defaults to true
+    # @param structure_ids [Array<String>, nil] Stored structure record ids to index
+    # @param structure_object_ids [Array<String>, nil] Structure object ids to index directly
+    # @param version [String] Immutable logical index version
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexBuildData]
+    def foldsIndexBuild(
+      name:,
+      version:,
+      create_index: nil,
+      dry_run: nil,
+      output_dir: nil,
+      publish: nil,
+      routing_representatives_per_shard: nil,
+      shard_count: nil,
+      source_manifest_object_id: nil,
+      store_artifacts: nil,
+      structure_ids: nil,
+      structure_object_ids: nil,
+      request_options: {}
+    )
+      body = {
+        'create_index' => create_index,
+        'dry_run' => dry_run,
+        'name' => name,
+        'output_dir' => output_dir,
+        'publish' => publish,
+        'routing_representatives_per_shard' => routing_representatives_per_shard,
+        'shard_count' => shard_count,
+        'source_manifest_object_id' => source_manifest_object_id,
+        'store_artifacts' => store_artifacts,
+        'structure_ids' => structure_ids,
+        'structure_object_ids' => structure_object_ids,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/index/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexBuildData.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/proteins/folds/index/describe
+    # @param manifest_object_id [String, nil] Manifest object id
+    # @param manifest_path [String, nil] Local manifest path
+    # @param ref [String, nil] Published index ref such as name:version or manifest object id
+    # @param target_dir [String, nil] Optional local cache directory to inspect
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexDescribeData]
+    def foldsIndexDescribe(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      ref: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'ref' => ref,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/index/describe',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexDescribeData.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/proteins/folds/index/evict
+    # @param dry_run [Boolean, nil]
+    # @param manifest_object_id [String, 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 segment_roles [Array<String>, nil]
+    # @param shards [Array<String>, nil]
+    # @param target_dir [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexEvictData]
+    def foldsIndexEvict(
+      dry_run: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_bytes: nil,
+      policy: nil,
+      ref: nil,
+      segment_roles: nil,
+      shards: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'dry_run' => dry_run,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_bytes' => max_bytes,
+        'policy' => policy,
+        'ref' => ref,
+        'segment_roles' => segment_roles,
+        'shards' => shards,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/index/evict',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexEvictData.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/proteins/folds/index/list
+    # @param limit [Integer, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexListData]
+    def foldsIndexList(
+      limit: nil,
+      request_options: {}
+    )
+      params = {
+        'limit' => limit
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: '/v1/proteins/folds/index/list',
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexListData.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/proteins/folds/index/materialize
+    # @param manifest_object_id [String, nil] Manifest object id
+    # @param manifest_path [String, nil] Local manifest path
+    # @param ref [String, nil] Published index ref such as name:version or manifest object id
+    # @param segment_roles [Array<String>, nil] Optional Foldseek segment roles to materialize: search_index, routing_index. Empty materializes every segment.
+    # @param shards [Array<String>, nil] Optional shard ids to materialize; empty materializes every shard with artifacts
+    # @param target_dir [String, nil] Directory used as the local Foldseek index cache
+    # @param verify [Boolean, nil] Verify materialized files by SHA-256
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexMaterializeData]
+    def foldsIndexMaterialize(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      ref: nil,
+      segment_roles: nil,
+      shards: nil,
+      target_dir: nil,
+      verify: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'ref' => ref,
+        'segment_roles' => segment_roles,
+        'shards' => shards,
+        'target_dir' => target_dir,
+        'verify' => verify
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/index/materialize',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexMaterializeData.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/proteins/folds/index/publish
+    # @param manifest_object_id [String, nil] Manifest object id
+    # @param manifest_path [String, nil] Local manifest path
+    # @param min_routing_byte_reduction_fraction [Float, nil] Optional publish gate threshold for materialized byte reduction from routed search
+    # @param min_routing_recall_at_1 [Float, nil] Optional publish gate threshold for routed recall_at_1
+    # @param min_routing_recall_at_10 [Float, nil] Optional publish gate threshold for routed recall_at_10
+    # @param min_routing_recall_at_100 [Float, nil] Optional publish gate threshold for routed recall_at_100
+    # @param ref [String, nil] Published index ref override
+    # @param require_routing_benchmark [Boolean, nil] Require a passing routing benchmark artifact before publishing a routable index
+    # @param routing_benchmark_object_id [String, nil] Object id of a Foldseek routing benchmark artifact produced by proteins.folds.index.benchmark
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexPublishData]
+    def foldsIndexPublish(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      min_routing_byte_reduction_fraction: nil,
+      min_routing_recall_at_1: nil,
+      min_routing_recall_at_10: nil,
+      min_routing_recall_at_100: nil,
+      ref: nil,
+      require_routing_benchmark: nil,
+      routing_benchmark_object_id: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'min_routing_byte_reduction_fraction' => min_routing_byte_reduction_fraction,
+        'min_routing_recall_at_1' => min_routing_recall_at_1,
+        'min_routing_recall_at_10' => min_routing_recall_at_10,
+        'min_routing_recall_at_100' => min_routing_recall_at_100,
+        'ref' => ref,
+        'require_routing_benchmark' => require_routing_benchmark,
+        'routing_benchmark_object_id' => routing_benchmark_object_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/index/publish',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexPublishData.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/proteins/folds/index/verify
+    # @param manifest_object_id [String, nil]
+    # @param manifest_path [String, nil]
+    # @param ref [String, nil]
+    # @param segment_roles [Array<String>, nil]
+    # @param shards [Array<String>, nil]
+    # @param target_dir [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldIndexVerifyData]
+    def foldsIndexVerify(
+      manifest_object_id: nil,
+      manifest_path: nil,
+      ref: nil,
+      segment_roles: nil,
+      shards: nil,
+      target_dir: nil,
+      request_options: {}
+    )
+      body = {
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'ref' => ref,
+        'segment_roles' => segment_roles,
+        'shards' => shards,
+        'target_dir' => target_dir
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/index/verify',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldIndexVerifyData.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/proteins/folds/search
+    # @param concurrency [Integer, nil] Maximum object-backed Foldseek shards to execute concurrently; defaults to 4.
+    # @param database [String, nil] Database name published with the relation
+    # @param dry_run [Boolean, nil] Return the deterministic physical plan without materializing the index or running Foldseek.
+    # @param exact_rerank [Boolean, nil] When true against the current structure release, rerank returned candidates with a pairwise structure aligner.
+    # @param exact_rerank_backend [Rafflesia::Types::FoldSearchRequestExactRerankBackend, nil] Pairwise backend used by exact_rerank. Defaults to tmalign.
+    # @param exact_rerank_rank_key [Rafflesia::Types::FoldSearchRequestExactRerankRankKey, nil] Measurement used to order exact_rerank hits. Defaults to the backend's measured primary structural score.
+    # @param foldseek_alignment_type [String, nil] Optional Foldseek --alignment-type value. Numeric values are passed through to the installed binary.
+    # @param foldseek_binary_path [String, nil] Optional absolute Foldseek binary path used for raw-structure token extraction.
+    # @param foldseek_exhaustive_search [Boolean, nil] When true, pass --exhaustive-search 1 to Foldseek. Intended for calibration and diagnostics.
+    # @param foldseek_gpu [Boolean, nil] Optional Foldseek --gpu value. Omit to use the installed binary default.
+    # @param foldseek_kmer_size [Integer, nil] Optional Foldseek k-mer size passed as -k.
+    # @param foldseek_lddt_threshold [Float, nil] Optional Foldseek --lddt-threshold value.
+    # @param foldseek_prefilter_mode [String, nil] Optional Foldseek --prefilter-mode value. Numeric values are passed through to the installed binary.
+    # @param foldseek_result_order [Rafflesia::Types::FoldSearchRequestFoldseekResultOrder, nil] How the adapter orders parsed Foldseek hits. Defaults to deterministic descending TM-score order; foldseek_order explicitly preserves the backend's emitted order.
+    # @param foldseek_sensitivity [Float, nil] Optional Foldseek easy-search sensitivity passed as -s.
+    # @param foldseek_sort_by_structure_bits [Boolean, nil] Optional Foldseek --sort-by-structure-bits value. Omit to use the installed binary default.
+    # @param foldseek_threads [Integer, nil] Optional Foldseek --threads value.
+    # @param foldseek_tmscore_threshold [Float, nil] Optional Foldseek --tmscore-threshold value.
+    # @param force_full_scan [Boolean, nil] Search every selected shard even when a routing segment is available.
+    # @param index_ref [String, nil] Published object-backed Foldseek index ref such as name:version
+    # @param limit [Integer, nil]
+    # @param manifest_object_id [String, nil] Object id for a Foldseek index manifest
+    # @param manifest_path [String, nil] Local Foldseek index manifest path
+    # @param max_candidates [Integer, nil] Optional cap on ranked current-release candidates before limit.
+    # @param max_exact_shards [Integer, nil] Optional hard cap on exact Foldseek shards searched after routing or explicit selection.
+    # @param max_materialized_bytes [Integer, nil] Optional hard cap on planned local bytes materialized before exact Foldseek shard search.
+    # @param max_object_bytes [Integer, nil] Optional hard cap on planned object-store bytes read for routing and search-index materialization.
+    # @param max_object_reads [Integer, nil] Optional hard cap on planned object-store reads for routing and search-index materialization.
+    # @param nprobe [Integer, nil] Candidate shard cap when a routing segment is available; defaults to planner policy.
+    # @param object_store_root [String, nil] Optional local current-release object-store root. Defaults to the API server's release data root.
+    # @param output_format [Rafflesia::Types::FoldSearchRequestOutputFormat, 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 profile [Boolean, nil] Include per-phase wall-clock timing (index resolve, index materialize, query resolve, shard search, normalized-output store) in the response.
+    # @param query_id [String]
+    # @param query_mode [Rafflesia::Types::FoldSearchRequestQueryMode, nil] Current-release query mode. Defaults to candidate_only.
+    # @param query_structure_file_name [String, nil] Stable filename used when staging query_structure_object_id for structure-token extraction.
+    # @param query_structure_object_id [String, nil] Optional raw PDB/mmCIF query object id for the current structure release. The server derives structure tokens before querying.
+    # @param query_structure_path [String, nil] Optional raw PDB/mmCIF query path for the current structure release. The server derives structure tokens before querying.
+    # @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 segment and routed shard selection instead of full-scan Foldseek search.
+    # @param require_zero_materialization [Boolean, nil] Require the planned object-backed Foldseek path to materialize zero local database bytes.
+    # @param rerank_limit [Integer, nil] Maximum returned candidates to exact-rerank. Defaults to limit.
+    # @param shards [Array<String>, nil] Optional shard ids to search; empty searches every shard with artifacts
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param target_dir [String, nil] Directory used as the local Foldseek index cache
+    # @param target_structure_objects [Hash{String => Rafflesia::CorpuReleaseStructureInputObject}, nil] Optional hit id to raw PDB/mmCIF object map used by exact_rerank.
+    # @param target_structure_paths [Hash{String => String}, nil] Optional hit id to local PDB/mmCIF path map used by exact_rerank.
+    # @param tmalign_binary_path [String, nil] Optional absolute TM-align binary path used for exact_rerank.
+    # @param verify_index [Boolean, nil] Require SHA-256 metadata while materializing index artifacts
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSearchData]
+    def foldsSearch(
+      query_id:,
+      concurrency: nil,
+      database: nil,
+      dry_run: nil,
+      exact_rerank: nil,
+      exact_rerank_backend: nil,
+      exact_rerank_rank_key: nil,
+      foldseek_alignment_type: nil,
+      foldseek_binary_path: nil,
+      foldseek_exhaustive_search: nil,
+      foldseek_gpu: nil,
+      foldseek_kmer_size: nil,
+      foldseek_lddt_threshold: nil,
+      foldseek_prefilter_mode: nil,
+      foldseek_result_order: nil,
+      foldseek_sensitivity: nil,
+      foldseek_sort_by_structure_bits: nil,
+      foldseek_threads: nil,
+      foldseek_tmscore_threshold: nil,
+      force_full_scan: nil,
+      index_ref: nil,
+      limit: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_candidates: nil,
+      max_exact_shards: nil,
+      max_materialized_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      nprobe: nil,
+      object_store_root: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      profile: nil,
+      query_mode: nil,
+      query_structure_file_name: nil,
+      query_structure_object_id: nil,
+      query_structure_path: nil,
+      relation: nil,
+      release: nil,
+      require_routing: nil,
+      require_zero_materialization: nil,
+      rerank_limit: nil,
+      shards: nil,
+      sort_by: nil,
+      target_dir: nil,
+      target_structure_objects: nil,
+      target_structure_paths: nil,
+      tmalign_binary_path: nil,
+      verify_index: nil,
+      request_options: {}
+    )
+      body = {
+        'concurrency' => concurrency,
+        'database' => database,
+        'dry_run' => dry_run,
+        'exact_rerank' => exact_rerank,
+        'exact_rerank_backend' => exact_rerank_backend,
+        'exact_rerank_rank_key' => exact_rerank_rank_key,
+        'foldseek_alignment_type' => foldseek_alignment_type,
+        'foldseek_binary_path' => foldseek_binary_path,
+        'foldseek_exhaustive_search' => foldseek_exhaustive_search,
+        'foldseek_gpu' => foldseek_gpu,
+        'foldseek_kmer_size' => foldseek_kmer_size,
+        'foldseek_lddt_threshold' => foldseek_lddt_threshold,
+        'foldseek_prefilter_mode' => foldseek_prefilter_mode,
+        'foldseek_result_order' => foldseek_result_order,
+        'foldseek_sensitivity' => foldseek_sensitivity,
+        'foldseek_sort_by_structure_bits' => foldseek_sort_by_structure_bits,
+        'foldseek_threads' => foldseek_threads,
+        'foldseek_tmscore_threshold' => foldseek_tmscore_threshold,
+        'force_full_scan' => force_full_scan,
+        'index_ref' => index_ref,
+        'limit' => limit,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_candidates' => max_candidates,
+        'max_exact_shards' => max_exact_shards,
+        'max_materialized_bytes' => max_materialized_bytes,
+        'max_object_bytes' => max_object_bytes,
+        'max_object_reads' => max_object_reads,
+        'nprobe' => nprobe,
+        'object_store_root' => object_store_root,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'profile' => profile,
+        'query_id' => query_id,
+        'query_mode' => query_mode,
+        'query_structure_file_name' => query_structure_file_name,
+        'query_structure_object_id' => query_structure_object_id,
+        'query_structure_path' => query_structure_path,
+        'relation' => relation,
+        'release' => release,
+        'require_routing' => require_routing,
+        'require_zero_materialization' => require_zero_materialization,
+        'rerank_limit' => rerank_limit,
+        'shards' => shards,
+        'sort_by' => sort_by,
+        'target_dir' => target_dir,
+        'target_structure_objects' => target_structure_objects,
+        'target_structure_paths' => target_structure_paths,
+        'tmalign_binary_path' => tmalign_binary_path,
+        'verify_index' => verify_index
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/search',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSearchData.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/proteins/folds/search-catalog
+    # @param catalog [String]
+    # @param limit [Integer, nil]
+    # @param query_id [String]
+    # @param store_root [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSearchData]
+    def foldsSearchCatalog(
+      catalog:,
+      query_id:,
+      store_root:,
+      limit: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog' => catalog,
+        'limit' => limit,
+        'query_id' => query_id,
+        'store_root' => store_root
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/search-catalog',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSearchData.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/proteins/folds/search-routed
+    # @param catalog [String]
+    # @param limit [Integer, nil]
+    # @param nprobe [Integer, nil] Cap on candidate shards the router selects; omit or 0 for no cap
+    # @param query_id [String]
+    # @param routing_db [String]
+    # @param store_root [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSearchData]
+    def foldsSearchRouted(
+      catalog:,
+      query_id:,
+      routing_db:,
+      store_root:,
+      limit: nil,
+      nprobe: nil,
+      request_options: {}
+    )
+      body = {
+        'catalog' => catalog,
+        'limit' => limit,
+        'nprobe' => nprobe,
+        'query_id' => query_id,
+        'routing_db' => routing_db,
+        'store_root' => store_root
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/search-routed',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSearchData.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/proteins/folds/search/benchmark
+    # @param concurrency [Integer, nil] Maximum baseline Foldseek shards to search concurrently.
+    # @param exact_limit [Integer, nil] Maximum object-native candidates to verify exactly; defaults to limit when exact_verify is true.
+    # @param exact_verify [Boolean, nil] Run candidate-only TM-align verification on object-native routed candidates before comparing to the Foldseek baseline.
+    # @param index_ref [String, nil] Published Foldseek index ref used by the materialized baseline search.
+    # @param limit [Integer, nil] Per-query hit limit; defaults to 100.
+    # @param manifest_object_id [String, nil] Foldseek index manifest object id used by the materialized baseline search.
+    # @param manifest_path [String, nil] Local Foldseek index manifest path used by the materialized baseline search.
+    # @param max_blocks_per_query [Integer, nil] Optional per-query cap on selected object-native feature blocks.
+    # @param max_object_bytes_per_query [Integer, nil] Optional per-query cap on object-native object bytes fetched.
+    # @param max_object_reads_per_query [Integer, nil] Optional per-query cap on object-native object reads.
+    # @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_at_1.
+    # @param min_recall_at_10 [Float, nil] Optional pass threshold for recall_at_10.
+    # @param min_recall_at_100 [Float, nil] Optional pass threshold for recall_at_100.
+    # @param nprobe [Integer, nil] Object-native feature block probe count; defaults to 1.
+    # @param profile [Boolean, nil] Include baseline Foldseek per-phase profile timings in nested search responses.
+    # @param query_ids [Array<String>, nil] Explicit query structure ids or paths to benchmark.
+    # @param recall_at [Array<Integer>, nil] Recall cutoffs to compute against materialized baseline hits; defaults to 1,10,100.
+    # @param require_exact_verification [Boolean, nil] Require every object-native query result to report exact candidate verification.
+    # @param require_zero_materialization [Boolean, nil] Require object-native search to materialize zero local database bytes.
+    # @param segment_manifest_object_id [String, nil] Object-native fold segment manifest object id.
+    # @param segment_manifest_path [String, nil] Local object-native fold segment manifest path.
+    # @param segment_ref [String, nil] Published object-native fold segment ref for the object-native search path.
+    # @param store_artifact [Boolean, nil] Store the benchmark JSON artifact in object storage; defaults to true.
+    # @param target_dir [String, nil] Benchmark cache root; baseline runs materialize under a deterministic subdirectory.
+    # @param verify_index [Boolean, nil] Verify materialized baseline Foldseek index artifacts by SHA-256.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSearchBenchmarkData]
+    def foldsSearchBenchmark(
+      query_ids:,
+      concurrency: nil,
+      exact_limit: nil,
+      exact_verify: nil,
+      index_ref: nil,
+      limit: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_blocks_per_query: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      min_byte_reduction_fraction: nil,
+      min_hit_overlap_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      min_recall_at_100: nil,
+      nprobe: nil,
+      profile: nil,
+      recall_at: nil,
+      require_exact_verification: nil,
+      require_zero_materialization: nil,
+      segment_manifest_object_id: nil,
+      segment_manifest_path: nil,
+      segment_ref: nil,
+      store_artifact: nil,
+      target_dir: nil,
+      verify_index: nil,
+      request_options: {}
+    )
+      body = {
+        'concurrency' => concurrency,
+        'exact_limit' => exact_limit,
+        'exact_verify' => exact_verify,
+        'index_ref' => index_ref,
+        'limit' => limit,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_blocks_per_query' => max_blocks_per_query,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        '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,
+        'min_recall_at_100' => min_recall_at_100,
+        'nprobe' => nprobe,
+        'profile' => profile,
+        'query_ids' => query_ids,
+        'recall_at' => recall_at,
+        'require_exact_verification' => require_exact_verification,
+        'require_zero_materialization' => require_zero_materialization,
+        'segment_manifest_object_id' => segment_manifest_object_id,
+        'segment_manifest_path' => segment_manifest_path,
+        'segment_ref' => segment_ref,
+        'store_artifact' => store_artifact,
+        'target_dir' => target_dir,
+        'verify_index' => verify_index
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/search/benchmark',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSearchBenchmarkData.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/proteins/folds/segments/benchmark
+    # @param limit [Integer, nil] Per-query hit limit; defaults to 100.
+    # @param manifest_object_id [String, nil] Object id for an object-native fold feature segment manifest.
+    # @param manifest_path [String, nil] Local path to an object-native fold feature segment manifest JSON file.
+    # @param max_blocks_per_query [Integer, nil] Optional per-query cap on selected routed feature blocks.
+    # @param max_object_bytes_per_query [Integer, nil] Optional per-query cap on routed object bytes read.
+    # @param max_object_reads_per_query [Integer, nil] Optional per-query cap on routed root plus feature block object reads.
+    # @param min_byte_reduction_fraction [Float, nil] Optional pass threshold for object byte reduction against exhaustive scan.
+    # @param min_recall_at_1 [Float, nil] Optional pass threshold for recall_at_1.
+    # @param min_recall_at_10 [Float, nil] Optional pass threshold for recall_at_10.
+    # @param min_recall_at_100 [Float, nil] Optional pass threshold for recall_at_100.
+    # @param nprobe [Integer, nil] Routed object feature block count; defaults to 1.
+    # @param query_ids [Array<String>, nil] Explicit query structure ids or paths to benchmark.
+    # @param recall_at [Array<Integer>, nil] Recall cutoffs to compute against exhaustive segment scan; defaults to 1,10,100.
+    # @param ref [String, nil] Published object-native fold segment ref such as name:version.
+    # @param require_exact_verification [Boolean, nil] Require every routed segment query to exactly verify candidate hits.
+    # @param require_zero_materialization [Boolean, nil] Require the object-native path to materialize zero local database bytes.
+    # @param store_artifact [Boolean, nil] Whether to store the benchmark JSON artifact in the object store; defaults to true.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentBenchmarkData]
+    def foldsSegmentsBenchmark(
+      query_ids:,
+      limit: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_blocks_per_query: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      min_byte_reduction_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      min_recall_at_100: nil,
+      nprobe: nil,
+      recall_at: nil,
+      ref: nil,
+      require_exact_verification: nil,
+      require_zero_materialization: nil,
+      store_artifact: nil,
+      request_options: {}
+    )
+      body = {
+        'limit' => limit,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_blocks_per_query' => max_blocks_per_query,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        'min_byte_reduction_fraction' => min_byte_reduction_fraction,
+        'min_recall_at_1' => min_recall_at_1,
+        'min_recall_at_10' => min_recall_at_10,
+        'min_recall_at_100' => min_recall_at_100,
+        'nprobe' => nprobe,
+        'query_ids' => query_ids,
+        'recall_at' => recall_at,
+        'ref' => ref,
+        'require_exact_verification' => require_exact_verification,
+        'require_zero_materialization' => require_zero_materialization,
+        'store_artifact' => store_artifact
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/benchmark',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentBenchmarkData.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/proteins/folds/segments/build
+    # @param block_size_bytes [Integer, nil] Maximum bytes per immutable feature block; defaults to the search segment default.
+    # @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 name [String] Logical object-native fold segment name.
+    # @param publish [Boolean, nil] Publish this immutable fold segment ref into the control plane after build.
+    # @param ref [String, nil] Optional published ref override, for example afdb-features:2026-06-30.
+    # @param store_feature_object [Boolean, nil] Whether to expose the intermediate JSONL feature object in the response.
+    # @param structure_ids [Array<String>, nil] Stored structure record ids to inspect into fold feature rows.
+    # @param structure_paths [Array<String>, nil] Local PDB/mmCIF paths to inspect into fold feature rows.
+    # @param version [String] Immutable segment version or source snapshot.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentBuildData]
+    def foldsSegmentsBuild(
+      name:,
+      version:,
+      block_size_bytes: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      publish: nil,
+      ref: nil,
+      store_feature_object: nil,
+      structure_ids: nil,
+      structure_paths: nil,
+      request_options: {}
+    )
+      body = {
+        'block_size_bytes' => block_size_bytes,
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'name' => name,
+        'publish' => publish,
+        'ref' => ref,
+        'store_feature_object' => store_feature_object,
+        'structure_ids' => structure_ids,
+        'structure_paths' => structure_paths,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/build',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentBuildData.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/proteins/folds/segments/compact
+    # @param block_size_bytes [Integer, nil] Maximum bytes per compacted immutable feature block.
+    # @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 name [String] Logical compacted fold segment name.
+    # @param publish [Boolean, nil] Publish the compacted segment ref after build.
+    # @param ref [String, nil] Published ref override when publish=true.
+    # @param source_manifest_object_ids [Array<String>, nil] Source fold segment manifest object ids to compact; repeatable.
+    # @param source_manifest_paths [Array<String>, nil] Source fold segment manifest paths to compact; repeatable.
+    # @param source_refs [Array<String>, nil] Published fold segment refs to compact; repeatable.
+    # @param store_feature_object [Boolean, nil] Whether to expose the compacted intermediate JSONL feature object.
+    # @param version [String] Immutable compacted segment version.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentCompactData]
+    def foldsSegmentsCompact(
+      name:,
+      version:,
+      block_size_bytes: nil,
+      dataset_name: nil,
+      dataset_version: nil,
+      publish: nil,
+      ref: nil,
+      source_manifest_object_ids: nil,
+      source_manifest_paths: nil,
+      source_refs: nil,
+      store_feature_object: nil,
+      request_options: {}
+    )
+      body = {
+        'block_size_bytes' => block_size_bytes,
+        'dataset_name' => dataset_name,
+        'dataset_version' => dataset_version,
+        'name' => name,
+        'publish' => publish,
+        'ref' => ref,
+        'source_manifest_object_ids' => source_manifest_object_ids,
+        'source_manifest_paths' => source_manifest_paths,
+        'source_refs' => source_refs,
+        'store_feature_object' => store_feature_object,
+        'version' => version
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/compact',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentCompactData.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/proteins/folds/segments/explain
+    # @param limit [Integer, nil] Maximum fold feature hits the corresponding search would return.
+    # @param manifest_object_id [String, nil] Object id for an object-native fold feature segment manifest.
+    # @param manifest_path [String, nil] Local path to an object-native fold feature segment manifest JSON file.
+    # @param max_blocks [Integer, nil] Optional hard budget for selected feature blocks.
+    # @param max_materialized_bytes [Integer, nil] Optional hard budget for local database materialization bytes.
+    # @param max_object_bytes [Integer, nil] Optional hard budget for object bytes read.
+    # @param max_object_reads [Integer, nil] Optional hard budget for root plus selected feature block object reads.
+    # @param nprobe [Integer, nil] Number of adjacent feature blocks to probe from the sparse routing root.
+    # @param query_id [String] Stored structure id or local PDB/mmCIF path used as the query.
+    # @param ref [String, nil] Published object-native fold segment ref such as name:version, or a logical name with an active generation.
+    # @param require_zero_materialization [Boolean, nil] Require the object-native path to materialize zero local database bytes.
+    # @param workload_profile [String, nil] Optional workload profile name such as foldseek-local or foldseek-remote-object-store.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentExplainData]
+    def foldsSegmentsExplain(
+      query_id:,
+      limit: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_blocks: nil,
+      max_materialized_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      nprobe: nil,
+      ref: nil,
+      require_zero_materialization: nil,
+      workload_profile: nil,
+      request_options: {}
+    )
+      body = {
+        'limit' => limit,
+        '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,
+        'nprobe' => nprobe,
+        'query_id' => query_id,
+        'ref' => ref,
+        'require_zero_materialization' => require_zero_materialization,
+        'workload_profile' => workload_profile
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/explain',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentExplainData.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/proteins/folds/segments/gc
+    # @param candidate_manifest_object_ids [Array<String>, nil] Candidate fold segment manifest object ids; repeatable.
+    # @param candidate_manifest_paths [Array<String>, nil] Candidate fold segment manifest paths; repeatable.
+    # @param candidate_refs [Array<String>, nil] Published fold segment refs considered for collection; repeatable.
+    # @param dry_run [Boolean, nil] Whether to only report unused objects; defaults to true.
+    # @param keep_manifest_object_ids [Array<String>, nil] Live fold segment manifest object ids; repeatable.
+    # @param keep_manifest_paths [Array<String>, nil] Live fold segment manifest paths; repeatable.
+    # @param keep_refs [Array<String>, nil] Published fold segment refs that remain live; repeatable.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentGcData]
+    def foldsSegmentsGc(
+      candidate_manifest_object_ids: nil,
+      candidate_manifest_paths: nil,
+      candidate_refs: nil,
+      dry_run: nil,
+      keep_manifest_object_ids: nil,
+      keep_manifest_paths: nil,
+      keep_refs: nil,
+      request_options: {}
+    )
+      body = {
+        'candidate_manifest_object_ids' => candidate_manifest_object_ids,
+        'candidate_manifest_paths' => candidate_manifest_paths,
+        'candidate_refs' => candidate_refs,
+        'dry_run' => dry_run,
+        'keep_manifest_object_ids' => keep_manifest_object_ids,
+        'keep_manifest_paths' => keep_manifest_paths,
+        'keep_refs' => keep_refs
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/gc',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentGcData.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/proteins/folds/segments/generations/activate
+    # @param reason [String, nil] Optional operator-visible reason for the state transition.
+    # @param ref [String] Published immutable fold segment ref to mark active.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentGenerationData]
+    def foldsSegmentsGenerationsActivate(
+      ref:,
+      reason: nil,
+      request_options: {}
+    )
+      body = {
+        'reason' => reason,
+        'ref' => ref
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/generations/activate',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentGenerationData.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/proteins/folds/segments/generations/list
+    # @param include_retired [Boolean, nil] Include retired generations. Defaults to true for complete lifecycle evidence.
+    # @param name [String, nil] Optional logical fold segment name filter.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentGenerationListData]
+    def foldsSegmentsGenerationsList(
+      include_retired: nil,
+      name: nil,
+      request_options: {}
+    )
+      body = {
+        'include_retired' => include_retired,
+        'name' => name
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/generations/list',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentGenerationListData.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/proteins/folds/segments/generations/rollback
+    # @param name [String, nil] Logical fold segment name to roll back when to_ref is not provided.
+    # @param reason [String, nil] Optional operator-visible reason for the rollback.
+    # @param to_ref [String, nil] Published immutable ref to mark active. When empty, the most recently retired generation for name is selected.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentGenerationData]
+    def foldsSegmentsGenerationsRollback(
+      name: nil,
+      reason: nil,
+      to_ref: nil,
+      request_options: {}
+    )
+      body = {
+        'name' => name,
+        'reason' => reason,
+        'to_ref' => to_ref
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/generations/rollback',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentGenerationData.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/proteins/folds/segments/publish
+    # @param activate [Boolean, nil] Mark this published generation active for its logical name after publish.
+    # @param benchmark_object_id [String, nil] Object id produced by proteins.folds.segments.benchmark.
+    # @param manifest_object_id [String, nil] Object id for an object-native fold feature segment manifest.
+    # @param manifest_path [String, nil] Local path to an object-native fold feature segment manifest JSON file.
+    # @param max_blocks_per_query [Integer, nil] Maximum routed feature blocks selected per benchmark query.
+    # @param max_object_bytes_per_query [Integer, nil] Maximum planned routed object bytes per benchmark query.
+    # @param max_object_reads_per_query [Integer, nil] Maximum planned routed object reads per benchmark query.
+    # @param min_byte_reduction_fraction [Float, nil] Publish gate threshold for planned object byte reduction.
+    # @param min_hit_overlap_fraction [Float, nil] Publish gate threshold for Foldseek-vs-object-native hit overlap.
+    # @param min_recall_at_1 [Float, nil] Publish gate threshold for recall_at_1.
+    # @param min_recall_at_10 [Float, nil] Publish gate threshold for recall_at_10.
+    # @param min_recall_at_100 [Float, nil] Publish gate threshold for recall_at_100.
+    # @param policy [Rafflesia::ServerlessPublishPolicy, nil] Optional normalized publish policy; top-level gate fields remain supported.
+    # @param ref [String, nil] Published fold segment ref override; defaults to manifest name:version.
+    # @param require_benchmark [Boolean, nil] Require a passing fold segment benchmark artifact before publishing.
+    # @param require_exact_verification [Boolean, nil] Require search benchmark evidence that object-native candidates were exactly verified.
+    # @param require_search_benchmark [Boolean, nil] Require a passing materialized-Foldseek-vs-object-native benchmark artifact before publishing.
+    # @param require_zero_materialization [Boolean, nil] Require benchmark evidence that routed search materialized zero local database bytes.
+    # @param search_benchmark_object_id [String, nil] Object id produced by proteins.folds.search.benchmark.
+    # @param workload_profile [String, nil] Optional workload profile name used to fill unset policy gates.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentPublishData]
+    def foldsSegmentsPublish(
+      activate: nil,
+      benchmark_object_id: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_blocks_per_query: nil,
+      max_object_bytes_per_query: nil,
+      max_object_reads_per_query: nil,
+      min_byte_reduction_fraction: nil,
+      min_hit_overlap_fraction: nil,
+      min_recall_at_1: nil,
+      min_recall_at_10: nil,
+      min_recall_at_100: nil,
+      policy: nil,
+      ref: nil,
+      require_benchmark: nil,
+      require_exact_verification: nil,
+      require_search_benchmark: nil,
+      require_zero_materialization: nil,
+      search_benchmark_object_id: nil,
+      workload_profile: nil,
+      request_options: {}
+    )
+      body = {
+        'activate' => activate,
+        'benchmark_object_id' => benchmark_object_id,
+        'manifest_object_id' => manifest_object_id,
+        'manifest_path' => manifest_path,
+        'max_blocks_per_query' => max_blocks_per_query,
+        'max_object_bytes_per_query' => max_object_bytes_per_query,
+        'max_object_reads_per_query' => max_object_reads_per_query,
+        '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,
+        'min_recall_at_100' => min_recall_at_100,
+        'policy' => policy,
+        'ref' => ref,
+        'require_benchmark' => require_benchmark,
+        'require_exact_verification' => require_exact_verification,
+        'require_search_benchmark' => require_search_benchmark,
+        'require_zero_materialization' => require_zero_materialization,
+        'search_benchmark_object_id' => search_benchmark_object_id,
+        'workload_profile' => workload_profile
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/publish',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentPublishData.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/proteins/folds/segments/search
+    # @param database [String, nil] Database name published with the relation
+    # @param dry_run [Boolean, nil] Return the deterministic read plan without fetching feature blocks.
+    # @param exact_limit [Integer, nil] Maximum routed candidates to verify exactly; defaults to limit when exact_verify is true.
+    # @param exact_verify [Boolean, nil] Run candidate-only TM-align verification over the routed feature hits before returning them.
+    # @param limit [Integer, nil] Maximum fold feature hits to return; defaults to 50.
+    # @param manifest_object_id [String, nil] Object id for an object-native fold feature segment manifest.
+    # @param manifest_path [String, nil] Local path to an object-native fold feature segment manifest JSON file.
+    # @param max_blocks [Integer, nil] Optional hard budget for selected feature blocks.
+    # @param max_materialized_bytes [Integer, nil] Optional hard budget for local database materialization bytes.
+    # @param max_object_bytes [Integer, nil] Optional hard budget for object bytes read.
+    # @param max_object_reads [Integer, nil] Optional hard budget for root plus selected feature block object reads.
+    # @param nprobe [Integer, nil] Number of adjacent feature blocks to probe from the sparse routing root; defaults to 1.
+    # @param output_format [Rafflesia::Types::FoldSegmentSearchRequestOutputFormat, 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_id [String] Stored structure id or local PDB/mmCIF path used as the query.
+    # @param ref [String, nil] Published object-native fold segment ref such as name:version.
+    # @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 path to materialize zero local database bytes.
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeFoldSegmentSearchData]
+    def foldsSegmentsSearch(
+      query_id:,
+      database: nil,
+      dry_run: nil,
+      exact_limit: nil,
+      exact_verify: nil,
+      limit: nil,
+      manifest_object_id: nil,
+      manifest_path: nil,
+      max_blocks: nil,
+      max_materialized_bytes: nil,
+      max_object_bytes: nil,
+      max_object_reads: nil,
+      nprobe: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      ref: nil,
+      relation: nil,
+      release: nil,
+      require_zero_materialization: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'dry_run' => dry_run,
+        'exact_limit' => exact_limit,
+        'exact_verify' => exact_verify,
+        'limit' => limit,
+        '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,
+        'nprobe' => nprobe,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'query_id' => query_id,
+        'ref' => ref,
+        'relation' => relation,
+        'release' => release,
+        'require_zero_materialization' => require_zero_materialization,
+        'sort_by' => sort_by
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/folds/segments/search',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeFoldSegmentSearchData.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/proteins/helices/hydrophobic-moment
+    # @param angle_degrees [Float, nil] per-residue angle in degrees (default 100, the ideal alpha-helix)
+    # @param chain [String, nil] restrict to a single chain id
+    # @param min_length [Integer, nil] skip helices shorter than this many residues (default 7)
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeHelixHydrophobicMomentData]
+    def helicesHydrophobicMoment(
+      structure_id:,
+      angle_degrees: nil,
+      chain: nil,
+      min_length: nil,
+      request_options: {}
+    )
+      body = {
+        'angle_degrees' => angle_degrees,
+        'chain' => chain,
+        'min_length' => min_length,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/helices/hydrophobic-moment',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeHelixHydrophobicMomentData.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/proteins/interfaces/burial
+    # @param min_delta_sasa [Float, nil]
+    # @param partners [String, nil]
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeInterfaceBurialData]
+    def interfacesBurial(
+      structure_id:,
+      min_delta_sasa: nil,
+      partners: nil,
+      request_options: {}
+    )
+      body = {
+        'min_delta_sasa' => min_delta_sasa,
+        'partners' => partners,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/interfaces/burial',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeInterfaceBurialData.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/proteins/interfaces/detect
+    # @param database [String, nil] Database name published with the relation
+    # @param include_pairs [Boolean, nil]
+    # @param include_residue_contacts [Boolean, nil] Include a per-residue contact rollup (residue_contacts_a/b) built from the full contact set before any max_pairs cap.
+    # @param include_same_chain [Boolean, nil]
+    # @param include_waters [Boolean, nil] Include water (HOH/WAT/DOD) residues; by default solvent is excluded so an interface reflects polymer-polymer contacts.
+    # @param max_interfaces [Integer, nil]
+    # @param max_pairs [Integer, nil]
+    # @param method [String, nil]
+    # @param min_sequence_separation [Integer, nil] For same-chain contacts, drop pairs whose residues are fewer than N positions apart (|pos_a - pos_b| < N). Removes trivial sequence-adjacent contacts. Cross-chain contacts are unaffected.
+    # @param output_format [Rafflesia::Types::InterfaceDetectRequestOutputFormat, 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 radius [Float, nil]
+    # @param relation [String, nil] Requested logical relation name
+    # @param release [String, nil] Immutable database release published with the relation
+    # @param residues [Array<String>, nil] Restrict contacts to those where at least one partner is a named residue. Each entry is CHAIN/POSITION (e.g. A/57) or a bare POSITION (e.g. 57, any chain); comma-separated lists are also accepted. Scopes every derived field (residue lists, counts, rollups, distances), not just contact_pairs.
+    # @param residues_require_both [Boolean, nil] With residues set, keep a contact only when BOTH partners are named (instead of the default: either partner). Use to measure geometry among a specific residue set (e.g. a catalytic triad's internal H-bonds) rather than everything those residues touch.
+    # @param sort_by [Array<String>, nil] Requested physical sort columns
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeInterfaceDetectData]
+    def interfacesDetect(
+      structure_id:,
+      database: nil,
+      include_pairs: nil,
+      include_residue_contacts: nil,
+      include_same_chain: nil,
+      include_waters: nil,
+      max_interfaces: nil,
+      max_pairs: nil,
+      method_: nil,
+      min_sequence_separation: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      radius: nil,
+      relation: nil,
+      release: nil,
+      residues: nil,
+      residues_require_both: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'include_pairs' => include_pairs,
+        'include_residue_contacts' => include_residue_contacts,
+        'include_same_chain' => include_same_chain,
+        'include_waters' => include_waters,
+        'max_interfaces' => max_interfaces,
+        'max_pairs' => max_pairs,
+        'method' => method_,
+        'min_sequence_separation' => min_sequence_separation,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'radius' => radius,
+        'relation' => relation,
+        'release' => release,
+        'residues' => residues,
+        'residues_require_both' => residues_require_both,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/interfaces/detect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeInterfaceDetectData.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/proteins/interfaces/features
+    # @param chain_a [String, nil] If set with chain_b, restrict to this chain pair (order-insensitive).
+    # @param chain_b [String, nil] If set with chain_a, restrict to this chain pair (order-insensitive).
+    # @param compute_buried_surface_area [Boolean, nil] Compute buried surface area (deterministic Shrake–Rupley SASA: ΔSASA over the two participant chains, in Angstrom^2).
+    # @param compute_pae [Boolean, nil] Compute mean PAE over contact pairs (requires a PAE matrix).
+    # @param compute_plddt [Boolean, nil] Compute mean pLDDT over participant residues.
+    # @param compute_region_ids [Boolean, nil] Attach interface region ids when available.
+    # @param include_pairs [Boolean, nil] Include contact residue pairs per interface.
+    # @param include_residue_contacts [Boolean, nil] Include a per-residue contact rollup (residue_contacts_a/b) built from the full contact set before any max_pairs cap. When compute_plddt is set, each rollup entry also carries residue_plddt.
+    # @param include_same_chain [Boolean, nil]
+    # @param interface_id [String, nil] If set, compute features only for this interface.
+    # @param max_interfaces [Integer, nil]
+    # @param max_pairs [Integer, nil]
+    # @param method [String, nil] Interface method: atom_min_distance or representative_residue_distance.
+    # @param radius [Float, nil]
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeInterfaceFeaturesData]
+    def interfacesFeatures(
+      structure_id:,
+      chain_a: nil,
+      chain_b: nil,
+      compute_buried_surface_area: nil,
+      compute_pae: nil,
+      compute_plddt: nil,
+      compute_region_ids: nil,
+      include_pairs: nil,
+      include_residue_contacts: nil,
+      include_same_chain: nil,
+      interface_id: nil,
+      max_interfaces: nil,
+      max_pairs: nil,
+      method_: nil,
+      radius: nil,
+      request_options: {}
+    )
+      body = {
+        'chain_a' => chain_a,
+        'chain_b' => chain_b,
+        'compute_buried_surface_area' => compute_buried_surface_area,
+        'compute_pae' => compute_pae,
+        'compute_plddt' => compute_plddt,
+        'compute_region_ids' => compute_region_ids,
+        'include_pairs' => include_pairs,
+        'include_residue_contacts' => include_residue_contacts,
+        'include_same_chain' => include_same_chain,
+        'interface_id' => interface_id,
+        'max_interfaces' => max_interfaces,
+        'max_pairs' => max_pairs,
+        'method' => method_,
+        'radius' => radius,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/interfaces/features',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeInterfaceFeaturesData.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/proteins/ligands/neighbors
+    # @param database [String, nil] Database name published with the relation
+    # @param include_waters [Boolean, nil]
+    # @param ligands [Array<String>, nil] Restrict measurement to the named ligand(s); each selector matches a residue name (e.g. MOV), a full ligand_id, or CHAIN:POSITION
+    # @param max_neighbors [Integer, nil]
+    # @param output_format [Rafflesia::Types::LigandNeighborsRequestOutputFormat, 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 radius [Float, nil]
+    # @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 structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeLigandNeighborsData]
+    def ligandsNeighbors(
+      structure_id:,
+      database: nil,
+      include_waters: nil,
+      ligands: nil,
+      max_neighbors: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      radius: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'include_waters' => include_waters,
+        'ligands' => ligands,
+        'max_neighbors' => max_neighbors,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'radius' => radius,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/ligands/neighbors',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeLigandNeighborsData.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/proteins/metals/detect
+    # @param max_distance [Float, nil] metal-donor first-shell distance cutoff in Å (default 2.8)
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeMetalDetectData]
+    def metalsDetect(
+      structure_id:,
+      max_distance: nil,
+      request_options: {}
+    )
+      body = {
+        'max_distance' => max_distance,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/metals/detect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeMetalDetectData.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/proteins/peptide-bonds/omega
+    # @param cis_cutoff [Float, nil]
+    # @param include_all_bonds [Boolean, nil]
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopePeptideBondOmegaData]
+    def peptideBondsOmega(
+      structure_id:,
+      cis_cutoff: nil,
+      include_all_bonds: nil,
+      request_options: {}
+    )
+      body = {
+        'cis_cutoff' => cis_cutoff,
+        'include_all_bonds' => include_all_bonds,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/peptide-bonds/omega',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopePeptideBondOmegaData.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/proteins/pockets/detect
+    # @param backend [Rafflesia::Types::PocketDetectRequestBackend, nil]
+    # @param cache_mode [Rafflesia::Types::PocketDetectRequestCacheMode, nil] Pocket cache mode. use reuses matching cached pockets, refresh recomputes and stores, off recomputes without storing.
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::PocketDetectRequestOutputFormat, 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 structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopePocketDetectData]
+    def pocketsDetect(
+      structure_id:,
+      backend: nil,
+      cache_mode: nil,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'backend' => backend,
+        'cache_mode' => cache_mode,
+        'database' => database,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/pockets/detect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopePocketDetectData.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/proteins/pockets/features
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::PocketFeaturesRequestOutputFormat, 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 pocket_id [String]
+    # @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::EnvelopePocketFeaturesData]
+    def pocketsFeatures(
+      pocket_id:,
+      database: 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,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'pocket_id' => pocket_id,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/pockets/features',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopePocketFeaturesData.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/proteins/pockets/ligand-distances
+    # @param database [String, nil] Database name published with the relation
+    # @param distance_threshold_angstrom [Float, nil]
+    # @param include_waters [Boolean, nil]
+    # @param ligand_grouping [Rafflesia::Types::PocketLigandDistancesRequestLigandGrouping, nil] Optional grouping for denominator-sensitive measurements. residue_name groups selected ligand instances by residue name within the structure.
+    # @param ligands [Array<String>, nil] Restrict measurement to the named ligand(s); each selector matches a residue name, ligand_id, or CHAIN:POSITION.
+    # @param max_pairs [Integer, nil]
+    # @param output_format [Rafflesia::Types::PocketLigandDistancesRequestOutputFormat, 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 pockets [Array<Rafflesia::Pocket>, nil] Optional inline pocket candidates; used when prediction_path is empty.
+    # @param prediction_format [String, nil] Prediction file format. p2rank_csv reads P2Rank *_predictions.csv files.
+    # @param prediction_method [String, nil] Method label attached to parsed pocket candidates, for example p2rank.
+    # @param prediction_path [String, nil] Local path to pocket candidate predictions, for example a P2Rank *_predictions.csv file.
+    # @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 structure_id [String]
+    # @param top_extra [Integer, nil]
+    # @param top_n_reference [Rafflesia::Types::PocketLigandDistancesRequestTopNReference, nil] Determines n for Top-n measurements. ligand_instance uses selected ligand instance count; ligand_group uses ligand_grouping group count.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopePocketLigandDistancesData]
+    def pocketsLigandDistances(
+      structure_id:,
+      database: nil,
+      distance_threshold_angstrom: nil,
+      include_waters: nil,
+      ligand_grouping: nil,
+      ligands: nil,
+      max_pairs: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      pockets: nil,
+      prediction_format: nil,
+      prediction_method: nil,
+      prediction_path: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      top_extra: nil,
+      top_n_reference: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'distance_threshold_angstrom' => distance_threshold_angstrom,
+        'include_waters' => include_waters,
+        'ligand_grouping' => ligand_grouping,
+        'ligands' => ligands,
+        'max_pairs' => max_pairs,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'pockets' => pockets,
+        'prediction_format' => prediction_format,
+        'prediction_method' => prediction_method,
+        'prediction_path' => prediction_path,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id,
+        'top_extra' => top_extra,
+        'top_n_reference' => top_n_reference
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/pockets/ligand-distances',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopePocketLigandDistancesData.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/proteins/regions/split
+    # @param chain [String, nil]
+    # @param database [String, nil] Database name published with the relation
+    # @param include_low_confidence [Boolean, nil] Also emit the complementary below-threshold segments (type low_confidence_segment) so the split is a full partition of the chain; ignored for the pae method.
+    # @param method [Rafflesia::Types::RegionSplitRequestMethod, nil]
+    # @param min_length [Integer, nil]
+    # @param output_format [Rafflesia::Types::RegionSplitRequestOutputFormat, 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 structure_id [String]
+    # @param threshold [Float, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeRegionSplitData]
+    def regionsSplit(
+      structure_id:,
+      chain: nil,
+      database: nil,
+      include_low_confidence: nil,
+      method_: nil,
+      min_length: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      threshold: nil,
+      request_options: {}
+    )
+      body = {
+        'chain' => chain,
+        'database' => database,
+        'include_low_confidence' => include_low_confidence,
+        'method' => method_,
+        'min_length' => min_length,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id,
+        'threshold' => threshold
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/regions/split',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeRegionSplitData.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/proteins/residues/features
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::ResidueFeaturesRequestOutputFormat, 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 radius [Float, nil]
+    # @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 structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeResidueFeaturesData]
+    def residuesFeatures(
+      structure_id:,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      radius: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'radius' => radius,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/residues/features',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeResidueFeaturesData.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/proteins/residues/rotamers
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeResidueRotamersData]
+    def residuesRotamers(
+      structure_id:,
+      request_options: {}
+    )
+      body = {
+        'structure_id' => structure_id
+      }
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/residues/rotamers',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeResidueRotamersData.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/proteins/secondary-structure/assign
+    # @param chain [String, nil] restrict assignment to a single chain id
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::SecondaryStructureRequestOutputFormat, 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 structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeSecondaryStructureData]
+    def secondaryStructureAssign(
+      structure_id:,
+      chain: nil,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'chain' => chain,
+        'database' => database,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/secondary-structure/assign',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeSecondaryStructureData.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/proteins/structure/align
+    # @param allow_network [Boolean, nil] Fetch either structure from its source (PDB/AlphaFold) when it is not already cached, mirroring proteins structures fetch --allow-network.
+    # @param multimer_mode [Integer, nil] Optional US-align -mm multimer alignment mode; omitted leaves the US-align default.
+    # @param query_id [String] Query structure id, chain-scoped id (<parent>:CHAIN:<chainID>), or local path (normalized as Structure_1).
+    # @param target_id [String] Target structure id, chain-scoped id (<parent>:CHAIN:<chainID>), or local path (normalized as Structure_2).
+    # @param terminus_mode [Integer, nil] Optional US-align -ter chain/terminus handling mode; omitted leaves the US-align default.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureAlignData]
+    def structureAlign(
+      query_id:,
+      target_id:,
+      allow_network: nil,
+      multimer_mode: nil,
+      terminus_mode: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_network' => allow_network,
+        'multimer_mode' => multimer_mode,
+        'query_id' => query_id,
+        'target_id' => target_id,
+        'terminus_mode' => terminus_mode
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structure/align',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureAlignData.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/proteins/structure/align-matrix
+    # @param allow_network [Boolean, nil] Fetch any structure from its source (PDB/AlphaFold) when it is not already cached.
+    # @param database [String, nil] Database name published with the relation
+    # @param multimer_mode [Integer, nil] Optional US-align -mm multimer alignment mode; omitted leaves the US-align default.
+    # @param output_format [Rafflesia::Types::StructureAlignMatrixRequestOutputFormat, 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 structure_ids [Array<String>, nil] Structure ids to align all-vs-all (unordered pairs); 2-32 entries.
+    # @param terminus_mode [Integer, nil] Optional US-align -ter chain/terminus handling mode; omitted leaves the US-align default.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureAlignMatrixData]
+    def structureAlignMatrix(
+      structure_ids:,
+      allow_network: nil,
+      database: nil,
+      multimer_mode: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      terminus_mode: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_network' => allow_network,
+        'database' => database,
+        'multimer_mode' => multimer_mode,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_ids' => structure_ids,
+        'terminus_mode' => terminus_mode
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structure/align-matrix',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureAlignMatrixData.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/proteins/structures/axis-profile
+    # @param axis_direction [Array<Float>, nil] Axis direction vector [x,y,z]; defaults to [0,0,1]. Normalized internally.
+    # @param axis_point [Array<Float>, nil] Point on the axis [x,y,z] in angstrom; defaults to the (filtered) atom centroid.
+    # @param bins [Integer, nil] Number of axial bins for the radial profile; defaults to 24.
+    # @param chain_ids [Array<String>, nil] Restrict measurement to these chain ids; empty means all chains.
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::StructureAxisProfileRequestOutputFormat, 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 radius_percentiles [Array<Float>, nil] Per-bin radius percentiles to report, in [0,100]; defaults to 5,10.
+    # @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 structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureAxisProfileData]
+    def structuresAxisProfile(
+      structure_id:,
+      axis_direction: nil,
+      axis_point: nil,
+      bins: nil,
+      chain_ids: nil,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      radius_percentiles: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'axis_direction' => axis_direction,
+        'axis_point' => axis_point,
+        'bins' => bins,
+        'chain_ids' => chain_ids,
+        'database' => database,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'radius_percentiles' => radius_percentiles,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/axis-profile',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureAxisProfileData.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/proteins/structures/chains
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::StructureChainsRequestOutputFormat, 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 structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureChainsData]
+    def structuresChains(
+      structure_id:,
+      database: 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,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/chains',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureChainsData.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/proteins/structures/extract-chain
+    # @param chain_id [String]
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureChainExtractData]
+    def structuresExtractChain(
+      chain_id:,
+      structure_id:,
+      request_options: {}
+    )
+      body = {
+        'chain_id' => chain_id,
+        'structure_id' => structure_id
+      }
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/extract-chain',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureChainExtractData.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/proteins/structures/fetch
+    # @param allow_network [Boolean, nil]
+    # @param source [Rafflesia::Types::StructureFetchRequestSource, nil]
+    # @param target_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureData]
+    def structuresFetch(
+      target_id:,
+      allow_network: nil,
+      source: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_network' => allow_network,
+        'source' => source,
+        'target_id' => target_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/fetch',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureData.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/proteins/structures/import
+    # @param path [String]
+    # @param source [String, nil]
+    # @param target_id [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureData]
+    def structuresImport(
+      path:,
+      source: nil,
+      target_id: nil,
+      request_options: {}
+    )
+      body = {
+        'path' => path,
+        'source' => source,
+        'target_id' => target_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/import',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureData.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/proteins/structures/inspect
+    # @param structure_id [String]
+    # @param timeout_ms [Integer, nil] Maximum time to spend reading and parsing the structure before returning a partial inspect response. Zero uses the server default.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureInspectData]
+    def structuresInspect(
+      structure_id:,
+      timeout_ms: nil,
+      request_options: {}
+    )
+      body = {
+        'structure_id' => structure_id,
+        'timeout_ms' => timeout_ms
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/inspect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureInspectData.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/proteins/structures/metadata
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureMetadataData]
+    def structuresMetadata(
+      structure_id:,
+      request_options: {}
+    )
+      body = {
+        'structure_id' => structure_id
+      }
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/metadata',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureMetadataData.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/proteins/structures/predict
+    # @param affinity_binder_id [String, nil] Ligand entity id used by an affinity-capable backend.
+    # @param constraints [Object, nil] Backend-native constraint object; unsupported mappings fail explicitly.
+    # @param entities [Array<Rafflesia::StructurePredictionEntity>, nil]
+    # @param idempotency_key [String, nil]
+    # @param max_retries [Integer, nil]
+    # @param max_template_date [String, nil] Template cutoff in YYYY-MM-DD format.
+    # @param metadata [Hash{String => String}, nil]
+    # @param model [String, nil] Inference backend: esmfold2-fast, esmfold2, protenix-v2, boltz-2, alphafold2, rf3, or chai-1.
+    # @param model_type [String, nil] AlphaFold2 model type; auto chooses monomer or multimer.
+    # @param msa_inputs [Array<Rafflesia::StructurePredictionMsaInput>, nil] Per-protein Rafflesia alignment object references.
+    # @param msa_mode [Rafflesia::Types::StructurePredictionRequestMsaMode, nil]
+    # @param msa_server_url [String, nil] HTTPS ColabFold-compatible MSA service URL for explicit mmseqs2 modes.
+    # @param num_diffusion_samples [Integer, nil]
+    # @param num_loops [Integer, nil]
+    # @param num_models [Integer, nil]
+    # @param num_recycles [Integer, nil]
+    # @param num_sampling_steps [Integer, nil]
+    # @param num_seeds [Integer, nil]
+    # @param pair_mode [Rafflesia::Types::StructurePredictionRequestPairMode, nil]
+    # @param predict_affinity [Boolean, nil]
+    # @param random_seed [Integer, nil]
+    # @param relax_top_n [Integer, nil]
+    # @param templates [Boolean, nil]
+    # @param timeout_ms [Integer, nil] Durable worker deadline in milliseconds.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructurePredictionSubmitData]
+    def structuresPredict(
+      entities:,
+      affinity_binder_id: nil,
+      constraints: nil,
+      idempotency_key: nil,
+      max_retries: nil,
+      max_template_date: nil,
+      metadata: nil,
+      model: nil,
+      model_type: nil,
+      msa_inputs: nil,
+      msa_mode: nil,
+      msa_server_url: nil,
+      num_diffusion_samples: nil,
+      num_loops: nil,
+      num_models: nil,
+      num_recycles: nil,
+      num_sampling_steps: nil,
+      num_seeds: nil,
+      pair_mode: nil,
+      predict_affinity: nil,
+      random_seed: nil,
+      relax_top_n: nil,
+      templates: nil,
+      timeout_ms: nil,
+      request_options: {}
+    )
+      body = {
+        'affinity_binder_id' => affinity_binder_id,
+        'constraints' => constraints,
+        'entities' => entities,
+        'idempotency_key' => idempotency_key,
+        'max_retries' => max_retries,
+        'max_template_date' => max_template_date,
+        'metadata' => metadata,
+        'model' => model,
+        'model_type' => model_type,
+        'msa_inputs' => msa_inputs,
+        'msa_mode' => msa_mode,
+        'msa_server_url' => msa_server_url,
+        'num_diffusion_samples' => num_diffusion_samples,
+        'num_loops' => num_loops,
+        'num_models' => num_models,
+        'num_recycles' => num_recycles,
+        'num_sampling_steps' => num_sampling_steps,
+        'num_seeds' => num_seeds,
+        'pair_mode' => pair_mode,
+        'predict_affinity' => predict_affinity,
+        'random_seed' => random_seed,
+        'relax_top_n' => relax_top_n,
+        'templates' => templates,
+        'timeout_ms' => timeout_ms
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/predict',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructurePredictionSubmitData.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/proteins/structures/prediction-capabilities
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructurePredictionCapabilitiesData]
+    def structuresPredictionCapabilities(request_options: {})
+      response = @client.request(
+        method: :get,
+        path: '/v1/proteins/structures/prediction-capabilities',
+        auth: true,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructurePredictionCapabilitiesData.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/proteins/structures/prepare
+    # @param encoding [String, nil] Prepared artifact encoding: gzip or none. Defaults to gzip.
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructurePrepareData]
+    def structuresPrepare(
+      structure_id:,
+      encoding: nil,
+      request_options: {}
+    )
+      body = {
+        'encoding' => encoding,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/prepare',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructurePrepareData.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/proteins/structures/prepared/inspect
+    # @param encoding [String, nil] Prepared artifact encoding to inspect: gzip or none. Defaults to gzip.
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructurePreparedInspectData]
+    def structuresPreparedInspect(
+      structure_id:,
+      encoding: nil,
+      request_options: {}
+    )
+      body = {
+        'encoding' => encoding,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/prepared/inspect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructurePreparedInspectData.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/proteins/structures/principal-axes
+    # @param chain_ids [Array<String>, nil] Restrict to these chain ids; empty means all chains.
+    # @param database [String, nil] Database name published with the relation
+    # @param output_format [Rafflesia::Types::StructurePrincipalAxesRequestOutputFormat, 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 structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructurePrincipalAxesData]
+    def structuresPrincipalAxes(
+      structure_id:,
+      chain_ids: nil,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'chain_ids' => chain_ids,
+        'database' => database,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/principal-axes',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructurePrincipalAxesData.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/proteins/structures/status
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureStatusData]
+    def structuresStatus(
+      structure_id:,
+      request_options: {}
+    )
+      body = {
+        'structure_id' => structure_id
+      }
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/structures/status',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureStatusData.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/proteins/turns/detect
+    # @param max_ca_distance [Float, nil]
+    # @param structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeBetaTurnDetectData]
+    def turnsDetect(
+      structure_id:,
+      max_ca_distance: nil,
+      request_options: {}
+    )
+      body = {
+        'max_ca_distance' => max_ca_distance,
+        'structure_id' => structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/turns/detect',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeBetaTurnDetectData.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/proteins/validation/alphafold-chain
+    # @param allow_network [Boolean, nil]
+    # @param chain_id [String]
+    # @param method [String, nil]
+    # @param structure_id [String]
+    # @param uniprot_id [String, nil]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeAlphaFoldChainCompareData]
+    def validationAlphafoldChain(
+      chain_id:,
+      structure_id:,
+      allow_network: nil,
+      method_: nil,
+      uniprot_id: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_network' => allow_network,
+        'chain_id' => chain_id,
+        'method' => method_,
+        'structure_id' => structure_id,
+        'uniprot_id' => uniprot_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/alphafold-chain',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeAlphaFoldChainCompareData.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/proteins/validation/alphafold-chain-comparisons/export
+    # @param allow_network [Boolean, nil]
+    # @param backend [String, nil]
+    # @param chain_ids [Array<String>, nil]
+    # @param database [String, nil] Database name published with the relation
+    # @param foldseek_binary_path [String, nil] Optional absolute foldseek binary path used by the server for this export.
+    # @param output_format [Rafflesia::Types::AlphaFoldChainComparisonsExportRequestOutputFormat, 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 structure_id [String]
+    # @param tmalign_binary_path [String, nil] Optional absolute TM-align binary path used by the server for this export.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeTableExportData]
+    def validationAlphafoldChainComparisonsExport(
+      structure_id:,
+      allow_network: nil,
+      backend: nil,
+      chain_ids: nil,
+      database: nil,
+      foldseek_binary_path: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      tmalign_binary_path: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_network' => allow_network,
+        'backend' => backend,
+        'chain_ids' => chain_ids,
+        'database' => database,
+        'foldseek_binary_path' => foldseek_binary_path,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id,
+        'tmalign_binary_path' => tmalign_binary_path
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/alphafold-chain-comparisons/export',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeTableExportData.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/proteins/validation/dockq
+    # @param dockq_binary_path [String, nil] Optional absolute DockQ binary path used by the server for this measurement.
+    # @param model_chain_mapping [String, nil] Optional DockQ model chain mapping string; passed through only when a DockQ backend is integrated.
+    # @param native_chain_mapping [String, nil] Optional DockQ native chain mapping string; passed through only when a DockQ backend is integrated.
+    # @param query_structure_id [String]
+    # @param target_structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeDockQData]
+    def validationDockq(
+      query_structure_id:,
+      target_structure_id:,
+      dockq_binary_path: nil,
+      model_chain_mapping: nil,
+      native_chain_mapping: nil,
+      request_options: {}
+    )
+      body = {
+        'dockq_binary_path' => dockq_binary_path,
+        'model_chain_mapping' => model_chain_mapping,
+        'native_chain_mapping' => native_chain_mapping,
+        'query_structure_id' => query_structure_id,
+        'target_structure_id' => target_structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/dockq',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeDockQData.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/proteins/validation/dockq/export
+    # @param database [String, nil] Database name published with the relation
+    # @param dockq_binary_path [String, nil] Optional absolute DockQ binary path used by the server for this export.
+    # @param max_comparisons [Integer, nil]
+    # @param model_chain_mapping [String, nil] Optional DockQ model chain mapping string.
+    # @param native_chain_mapping [String, nil] Optional DockQ native chain mapping string.
+    # @param output_format [Rafflesia::Types::DockQMeasurementsExportRequestOutputFormat, 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 pairs [Array<Rafflesia::StructureComparisonPair>, nil]
+    # @param pairs_path [String, nil] Local CSV/TSV file containing measurement pairs. Columns: query_structure_id,target_structure_id, optional comparison_id,sample_id.
+    # @param pairs_table_object_id [String, nil] Content-addressed archive_member_pairs parquet object id.
+    # @param pairs_table_path [String, nil] Local archive_member_pairs parquet table path containing query_structure_id,target_structure_id columns.
+    # @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::EnvelopeTableExportData]
+    def validationDockqExport(
+      database: nil,
+      dockq_binary_path: nil,
+      max_comparisons: nil,
+      model_chain_mapping: nil,
+      native_chain_mapping: nil,
+      output_format: nil,
+      output_relation: nil,
+      pairs: nil,
+      pairs_path: nil,
+      pairs_table_object_id: nil,
+      pairs_table_path: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'dockq_binary_path' => dockq_binary_path,
+        'max_comparisons' => max_comparisons,
+        'model_chain_mapping' => model_chain_mapping,
+        'native_chain_mapping' => native_chain_mapping,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'pairs' => pairs,
+        'pairs_path' => pairs_path,
+        'pairs_table_object_id' => pairs_table_object_id,
+        'pairs_table_path' => pairs_table_path,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/dockq/export',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeTableExportData.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/proteins/validation/lddt
+    # @param cutoff_angstrom [Float, nil]
+    # @param query_structure_id [String]
+    # @param target_structure_id [String]
+    # @param thresholds [Array<Float>, nil] Distance-difference thresholds in angstroms; defaults to 0.5,1,2,4.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeLocalDistanceDifferenceData]
+    def validationLddt(
+      query_structure_id:,
+      target_structure_id:,
+      cutoff_angstrom: nil,
+      thresholds: nil,
+      request_options: {}
+    )
+      body = {
+        'cutoff_angstrom' => cutoff_angstrom,
+        'query_structure_id' => query_structure_id,
+        'target_structure_id' => target_structure_id,
+        'thresholds' => thresholds
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/lddt',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeLocalDistanceDifferenceData.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/proteins/validation/lddt/export
+    # @param cutoff_angstrom [Float, nil]
+    # @param database [String, nil] Database name published with the relation
+    # @param max_comparisons [Integer, nil]
+    # @param output_format [Rafflesia::Types::LocalDistanceDifferenceExportRequestOutputFormat, 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 pairs [Array<Rafflesia::StructureComparisonPair>, nil]
+    # @param pairs_path [String, nil] Local CSV/TSV file containing measurement pairs. Columns: query_structure_id,target_structure_id, optional comparison_id,sample_id.
+    # @param pairs_table_object_id [String, nil] Content-addressed archive_member_pairs parquet object id.
+    # @param pairs_table_path [String, nil] Local archive_member_pairs parquet table path containing query_structure_id,target_structure_id columns.
+    # @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 thresholds [Array<Float>, nil] Distance-difference thresholds in angstroms; defaults to 0.5,1,2,4.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeTableExportData]
+    def validationLddtExport(
+      cutoff_angstrom: nil,
+      database: nil,
+      max_comparisons: nil,
+      output_format: nil,
+      output_relation: nil,
+      pairs: nil,
+      pairs_path: nil,
+      pairs_table_object_id: nil,
+      pairs_table_path: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      thresholds: nil,
+      request_options: {}
+    )
+      body = {
+        'cutoff_angstrom' => cutoff_angstrom,
+        'database' => database,
+        'max_comparisons' => max_comparisons,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'pairs' => pairs,
+        'pairs_path' => pairs_path,
+        'pairs_table_object_id' => pairs_table_object_id,
+        'pairs_table_path' => pairs_table_path,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'thresholds' => thresholds
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/lddt/export',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeTableExportData.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/proteins/validation/ligand-compare
+    # @param include_waters [Boolean, nil]
+    # @param query_ligands [Array<String>, nil] Restrict query measurement to ligand selectors; each selector matches residue name, ligand_id, or CHAIN:POSITION.
+    # @param query_structure_id [String]
+    # @param radius [Float, nil]
+    # @param target_ligands [Array<String>, nil] Restrict target measurement to ligand selectors; each selector matches residue name, ligand_id, or CHAIN:POSITION.
+    # @param target_structure_id [String]
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeLigandCompareData]
+    def validationLigandCompare(
+      query_structure_id:,
+      target_structure_id:,
+      include_waters: nil,
+      query_ligands: nil,
+      radius: nil,
+      target_ligands: nil,
+      request_options: {}
+    )
+      body = {
+        'include_waters' => include_waters,
+        'query_ligands' => query_ligands,
+        'query_structure_id' => query_structure_id,
+        'radius' => radius,
+        'target_ligands' => target_ligands,
+        'target_structure_id' => target_structure_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/ligand-compare',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeLigandCompareData.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/proteins/validation/ligand-compare/export
+    # @param database [String, nil] Database name published with the relation
+    # @param include_waters [Boolean, nil]
+    # @param max_comparisons [Integer, nil]
+    # @param output_format [Rafflesia::Types::LigandComparisonsExportRequestOutputFormat, 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 pairs [Array<Rafflesia::StructureComparisonPair>, nil]
+    # @param pairs_path [String, nil] Local CSV/TSV file containing comparison pairs. Columns: query_structure_id,target_structure_id, optional comparison_id,sample_id.
+    # @param pairs_table_object_id [String, nil] Content-addressed archive_member_pairs parquet object id.
+    # @param pairs_table_path [String, nil] Local archive_member_pairs parquet table path containing query_structure_id,target_structure_id columns.
+    # @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_ligands [Array<String>, nil] Restrict query measurement to ligand selectors; each selector matches residue name, ligand_id, or CHAIN:POSITION.
+    # @param radius [Float, nil]
+    # @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_ligands [Array<String>, nil] Restrict target measurement to ligand selectors; each selector matches residue name, ligand_id, or CHAIN:POSITION.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeTableExportData]
+    def validationLigandCompareExport(
+      database: nil,
+      include_waters: nil,
+      max_comparisons: nil,
+      output_format: nil,
+      output_relation: nil,
+      pairs: nil,
+      pairs_path: nil,
+      pairs_table_object_id: nil,
+      pairs_table_path: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      query_ligands: nil,
+      radius: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      target_ligands: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'include_waters' => include_waters,
+        'max_comparisons' => max_comparisons,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'pairs' => pairs,
+        'pairs_path' => pairs_path,
+        'pairs_table_object_id' => pairs_table_object_id,
+        'pairs_table_path' => pairs_table_path,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'query_ligands' => query_ligands,
+        'radius' => radius,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'target_ligands' => target_ligands
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/ligand-compare/export',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeTableExportData.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/proteins/validation/structure-compare
+    # @param foldseek_binary_path [String, nil] Optional absolute foldseek binary path used by the server for this comparison.
+    # @param method [String, nil]
+    # @param query_structure_id [String]
+    # @param target_structure_id [String]
+    # @param tmalign_binary_path [String, nil] Optional absolute TM-align binary path used by the server for this comparison.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeStructureCompareData]
+    def validationStructureCompare(
+      query_structure_id:,
+      target_structure_id:,
+      foldseek_binary_path: nil,
+      method_: nil,
+      tmalign_binary_path: nil,
+      request_options: {}
+    )
+      body = {
+        'foldseek_binary_path' => foldseek_binary_path,
+        'method' => method_,
+        'query_structure_id' => query_structure_id,
+        'target_structure_id' => target_structure_id,
+        'tmalign_binary_path' => tmalign_binary_path
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/structure-compare',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeStructureCompareData.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/proteins/validation/structure-comparisons/export
+    # @param database [String, nil] Database name published with the relation
+    # @param foldseek_binary_path [String, nil] Optional absolute foldseek binary path used by the server for this export.
+    # @param max_comparisons [Integer, nil]
+    # @param method [String, nil]
+    # @param output_format [Rafflesia::Types::StructureComparisonsExportRequestOutputFormat, 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 pairs [Array<Rafflesia::StructureComparisonPair>, nil]
+    # @param pairs_path [String, nil] Local CSV/TSV/JSON file containing comparison pairs. CSV/TSV columns: query_structure_id,target_structure_id, optional comparison_id,sample_id,method.
+    # @param pairs_table_object_id [String, nil] Content-addressed archive_member_pairs parquet object id.
+    # @param pairs_table_path [String, nil] Local archive_member_pairs parquet table path containing query_structure_id,target_structure_id columns.
+    # @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 tmalign_binary_path [String, nil] Optional absolute TM-align binary path used by the server for this export.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeTableExportData]
+    def validationStructureComparisonsExport(
+      database: nil,
+      foldseek_binary_path: nil,
+      max_comparisons: nil,
+      method_: nil,
+      output_format: nil,
+      output_relation: nil,
+      pairs: nil,
+      pairs_path: nil,
+      pairs_table_object_id: nil,
+      pairs_table_path: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      tmalign_binary_path: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'foldseek_binary_path' => foldseek_binary_path,
+        'max_comparisons' => max_comparisons,
+        'method' => method_,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'pairs' => pairs,
+        'pairs_path' => pairs_path,
+        'pairs_table_object_id' => pairs_table_object_id,
+        'pairs_table_path' => pairs_table_path,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'tmalign_binary_path' => tmalign_binary_path
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/validation/structure-comparisons/export',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeTableExportData.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/proteins/variants/features
+    # @param database [String, nil] Database name published with the relation
+    # @param features [Array<String>, nil] Requested feature codes: plddt, burial, pocket_distance, interface_distance.
+    # @param output_format [Rafflesia::Types::VariantFeaturesRequestOutputFormat, 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 pockets [Array<Rafflesia::Pocket>, nil] Optional caller-provided pockets used for pocket_distance; a warning is emitted when pocket_distance is requested and none are available.
+    # @param preview_limit [Integer, nil] When output_relation is requested, include at most this many rows as a non-pageable preview
+    # @param radius [Float, nil] Neighbor radius in Angstroms for burial (default 8).
+    # @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 structure_id [String] Structure identifier providing residue coordinates.
+    # @param variants [Array<Rafflesia::MappedVariant>, nil] Mapped variants, typically from /v1/proteins/variants/map output.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeVariantFeaturesData]
+    def variantsFeatures(
+      features:,
+      structure_id:,
+      variants:,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      pockets: nil,
+      preview_limit: nil,
+      radius: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'database' => database,
+        'features' => features,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'pockets' => pockets,
+        'preview_limit' => preview_limit,
+        'radius' => radius,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id,
+        'variants' => variants
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/variants/features',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeVariantFeaturesData.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/proteins/variants/map
+    # @param allow_network [Boolean, nil] Allow network fetch of the target sequence when not cached.
+    # @param chain [String, nil] Structure chain id to map onto. When omitted and the target sequence is available, the chain whose residues best match the target sequence is selected automatically; otherwise the first chain is used.
+    # @param database [String, nil] Database name published with the relation
+    # @param mutations [Array<String>, nil] Mutation strings in parse format.
+    # @param output_format [Rafflesia::Types::VariantMapRequestOutputFormat, 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 structure_id [String] Structure identifier to map onto.
+    # @param target_id [String] Target identifier, e.g. uniprot:P38398.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeVariantMapData]
+    def variantsMap(
+      mutations:,
+      structure_id:,
+      target_id:,
+      allow_network: nil,
+      chain: nil,
+      database: nil,
+      output_format: nil,
+      output_relation: nil,
+      partition_by: nil,
+      preview_limit: nil,
+      relation: nil,
+      release: nil,
+      sort_by: nil,
+      request_options: {}
+    )
+      body = {
+        'allow_network' => allow_network,
+        'chain' => chain,
+        'database' => database,
+        'mutations' => mutations,
+        'output_format' => output_format,
+        'output_relation' => output_relation,
+        'partition_by' => partition_by,
+        'preview_limit' => preview_limit,
+        'relation' => relation,
+        'release' => release,
+        'sort_by' => sort_by,
+        'structure_id' => structure_id,
+        'target_id' => target_id
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/variants/map',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeVariantMapData.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/proteins/variants/parse
+    # @param mutations [Array<String>, nil] Mutation strings in the form WILDTYPE_AA + POSITION (1-based) + MUTANT_AA, e.g. M1775R or Y1853X. X (or *) as the mutant denotes a stop/nonsense change.
+    # @param request_options [Hash] (see Rafflesia::Types::RequestOptions)
+    # @return [Rafflesia::EnvelopeVariantParseData]
+    def variantsParse(
+      mutations:,
+      request_options: {}
+    )
+      body = {
+        'mutations' => mutations
+      }
+      response = @client.request(
+        method: :post,
+        path: '/v1/proteins/variants/parse',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Rafflesia::EnvelopeVariantParseData.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