retab 0.1.3 → 0.1.5

data/rbi/retab/parse_workflow_artifact.rbi

@@ -51,6 +51,18 @@ module Retab
     sig { params(value: Retab::ParseOutput).returns(Retab::ParseOutput) }
     def output=(value); end
 
+    sig { returns(T.nilable(String)) }
+    def status; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def status=(value); end
+
+    sig { returns(T.nilable(Retab::PrimitiveError)) }
+    def error; end
+
+    sig { params(value: T.nilable(Retab::PrimitiveError)).returns(T.nilable(Retab::PrimitiveError)) }
+    def error=(value); end
+
     sig { returns(T.nilable(Retab::RetabUsage)) }
     def usage; end
 

data/rbi/retab/parses.rbi

@@ -31,18 +31,20 @@ module Retab
         image_resolution_dpi: T.nilable(Integer),
         instructions: T.nilable(String),
         bust_cache: T.nilable(T::Boolean),
+        background: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Parse)
     end
-    def create(document:, model:, table_parsing_format:, image_resolution_dpi:, instructions:, bust_cache:, request_options:); end
+    def create(document:, model:, table_parsing_format:, image_resolution_dpi:, instructions:, bust_cache:, background:, request_options:); end
 
     sig do
       params(
         parse_id: String,
+        include_output: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Parse)
     end
-    def get(parse_id:, request_options:); end
+    def get(parse_id:, include_output:, request_options:); end
 
     sig do
       params(
@@ -52,5 +54,13 @@ module Retab
     end
     def delete(parse_id:, request_options:); end
 
+    sig do
+      params(
+        parse_id: String,
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::Parse)
+    end
+    def cancel(parse_id:, request_options:); end
+
   end
 end

data/rbi/retab/partition.rbi

@@ -57,6 +57,18 @@ module Retab
     sig { params(value: T.nilable(T::Array[Retab::PartitionChunk])).returns(T.nilable(T::Array[Retab::PartitionChunk])) }
     def output=(value); end
 
+    sig { returns(T.nilable(String)) }
+    def status; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def status=(value); end
+
+    sig { returns(T.nilable(Retab::PrimitiveError)) }
+    def error; end
+
+    sig { params(value: T.nilable(Retab::PrimitiveError)).returns(T.nilable(Retab::PrimitiveError)) }
+    def error=(value); end
+
     sig { returns(T.nilable(Retab::PartitionConsensus)) }
     def consensus; end
 

data/rbi/retab/partition_request.rbi

@@ -51,6 +51,12 @@ module Retab
     sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
     def bust_cache=(value); end
 
+    sig { returns(T.nilable(T::Boolean)) }
+    def background; end
+
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def background=(value); end
+
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end
 

data/rbi/retab/partition_workflow_artifact.rbi

@@ -57,6 +57,18 @@ module Retab
     sig { params(value: T.nilable(T::Array[Retab::PartitionChunk])).returns(T.nilable(T::Array[Retab::PartitionChunk])) }
     def output=(value); end
 
+    sig { returns(T.nilable(String)) }
+    def status; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def status=(value); end
+
+    sig { returns(T.nilable(Retab::PrimitiveError)) }
+    def error; end
+
+    sig { params(value: T.nilable(Retab::PrimitiveError)).returns(T.nilable(Retab::PrimitiveError)) }
+    def error=(value); end
+
     sig { returns(T.nilable(Retab::PartitionConsensus)) }
     def consensus; end
 
@@ -69,10 +81,10 @@ module Retab
     sig { params(value: T.nilable(Retab::RetabUsage)).returns(T.nilable(Retab::RetabUsage)) }
     def usage=(value); end
 
-    sig { returns(String) }
+    sig { returns(T.nilable(String)) }
     def created_at; end
 
-    sig { params(value: String).returns(String) }
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def created_at=(value); end
 
     sig { returns(T.nilable(String)) }

data/rbi/retab/partitions.rbi

@@ -16,12 +16,13 @@ module Retab
         limit: T.nilable(Integer),
         order: T.nilable(String),
         filename: T.nilable(String),
+        status: T.nilable(String),
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::PaginatedList[Retab::Partition])
     end
-    def list(before:, after:, limit:, order:, filename:, from_date:, to_date:, request_options:); end
+    def list(before:, after:, limit:, order:, filename:, status:, from_date:, to_date:, request_options:); end
 
     sig do
       params(
@@ -32,18 +33,20 @@ module Retab
         n_consensus: T.nilable(Integer),
         allow_overlap: T.nilable(T::Boolean),
         bust_cache: T.nilable(T::Boolean),
+        background: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Partition)
     end
-    def create(document:, key:, instructions:, model:, n_consensus:, allow_overlap:, bust_cache:, request_options:); end
+    def create(document:, key:, instructions:, model:, n_consensus:, allow_overlap:, bust_cache:, background:, request_options:); end
 
     sig do
       params(
         partition_id: String,
+        include_output: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Partition)
     end
-    def get(partition_id:, request_options:); end
+    def get(partition_id:, include_output:, request_options:); end
 
     sig do
       params(
@@ -53,5 +56,13 @@ module Retab
     end
     def delete(partition_id:, request_options:); end
 
+    sig do
+      params(
+        partition_id: String,
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::Partition)
+    end
+    def create_partition_cancel(partition_id:, request_options:); end
+
   end
 end

data/rbi/retab/{job_warning.rbi → primitive_error.rbi}

@@ -5,7 +5,7 @@
 # typed: strong
 
 module Retab
-  class JobWarning
+  class PrimitiveError
     sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
     def initialize(json); end
 

data/rbi/retab/review.rbi

@@ -28,10 +28,10 @@ module Retab
     def workflow_version_id=(value); end
 
     sig { returns(String) }
-    def workflow_run_id; end
+    def run_id; end
 
     sig { params(value: String).returns(String) }
-    def workflow_run_id=(value); end
+    def run_id=(value); end
 
     sig { returns(String) }
     def block_id; end

data/rbi/retab/review_decision.rbi

@@ -27,11 +27,11 @@ module Retab
     sig { params(value: Retab::Actor).returns(Retab::Actor) }
     def author=(value); end
 
-    sig { returns(T.nilable(String)) }
-    def decided_at; end
+    sig { returns(String) }
+    def created_at; end
 
-    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
-    def decided_at=(value); end
+    sig { params(value: String).returns(String) }
+    def created_at=(value); end
 
     sig { returns(T.nilable(String)) }
     def reason; end

data/rbi/retab/review_evaluation.rbi

@@ -22,10 +22,10 @@ module Retab
     def id=(value); end
 
     sig { returns(String) }
-    def workflow_run_id; end
+    def run_id; end
 
     sig { params(value: String).returns(String) }
-    def workflow_run_id=(value); end
+    def run_id=(value); end
 
     sig { returns(String) }
     def step_id; end

data/rbi/retab/run_timing.rbi

@@ -27,24 +27,6 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def completed_at=(value); end
 
-    sig { returns(T.nilable(String)) }
-    def review_waiting_started_at; end
-
-    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
-    def review_waiting_started_at=(value); end
-
-    sig { returns(T.nilable(Integer)) }
-    def accumulated_review_waiting_ms; end
-
-    sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def accumulated_review_waiting_ms=(value); end
-
-    sig { returns(T.nilable(Integer)) }
-    def duration_ms; end
-
-    sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
-    def duration_ms=(value); end
-
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end
 

data/rbi/retab/schemas.rbi

@@ -13,14 +13,13 @@ module Retab
       params(
         documents: T::Array[T.any(Retab::MimeData, Pathname, IO, String, T::Hash[Symbol, T.untyped])],
         model: T.nilable(String),
-        reasoning_effort: T.nilable(String),
         instructions: T.nilable(String),
         image_resolution_dpi: T.nilable(Integer),
         stream: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::PartialSchema)
     end
-    def generate(documents:, model:, reasoning_effort:, instructions:, image_resolution_dpi:, stream:, request_options:); end
+    def generate(documents:, model:, instructions:, image_resolution_dpi:, stream:, request_options:); end
 
   end
 end

data/rbi/retab/split.rbi

@@ -45,12 +45,24 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def instructions=(value); end
 
-    sig { returns(T::Array[Retab::SplitResult]) }
+    sig { returns(T.nilable(T::Array[Retab::SplitResult])) }
     def output; end
 
-    sig { params(value: T::Array[Retab::SplitResult]).returns(T::Array[Retab::SplitResult]) }
+    sig { params(value: T.nilable(T::Array[Retab::SplitResult])).returns(T.nilable(T::Array[Retab::SplitResult])) }
     def output=(value); end
 
+    sig { returns(T.nilable(String)) }
+    def status; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def status=(value); end
+
+    sig { returns(T.nilable(Retab::PrimitiveError)) }
+    def error; end
+
+    sig { params(value: T.nilable(Retab::PrimitiveError)).returns(T.nilable(Retab::PrimitiveError)) }
+    def error=(value); end
+
     sig { returns(T.nilable(Retab::SplitConsensus)) }
     def consensus; end
 

data/rbi/retab/split_request.rbi

@@ -45,6 +45,12 @@ module Retab
     sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
     def bust_cache=(value); end
 
+    sig { returns(T.nilable(T::Boolean)) }
+    def background; end
+
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def background=(value); end
+
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end
 

data/rbi/retab/split_workflow_artifact.rbi

@@ -45,12 +45,24 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def instructions=(value); end
 
-    sig { returns(T::Array[Retab::SplitResult]) }
+    sig { returns(T.nilable(T::Array[Retab::SplitResult])) }
     def output; end
 
-    sig { params(value: T::Array[Retab::SplitResult]).returns(T::Array[Retab::SplitResult]) }
+    sig { params(value: T.nilable(T::Array[Retab::SplitResult])).returns(T.nilable(T::Array[Retab::SplitResult])) }
     def output=(value); end
 
+    sig { returns(T.nilable(String)) }
+    def status; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def status=(value); end
+
+    sig { returns(T.nilable(Retab::PrimitiveError)) }
+    def error; end
+
+    sig { params(value: T.nilable(Retab::PrimitiveError)).returns(T.nilable(Retab::PrimitiveError)) }
+    def error=(value); end
+
     sig { returns(T.nilable(Retab::SplitConsensus)) }
     def consensus; end
 

data/rbi/retab/splits.rbi

@@ -16,12 +16,13 @@ module Retab
         limit: T.nilable(Integer),
         order: T.nilable(String),
         filename: T.nilable(String),
+        status: T.nilable(String),
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::PaginatedList[Retab::Split])
     end
-    def list(before:, after:, limit:, order:, filename:, from_date:, to_date:, request_options:); end
+    def list(before:, after:, limit:, order:, filename:, status:, from_date:, to_date:, request_options:); end
 
     sig do
       params(
@@ -31,18 +32,20 @@ module Retab
         instructions: T.nilable(String),
         n_consensus: T.nilable(Integer),
         bust_cache: T.nilable(T::Boolean),
+        background: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Split)
     end
-    def create(document:, subdocuments:, model:, instructions:, n_consensus:, bust_cache:, request_options:); end
+    def create(document:, subdocuments:, model:, instructions:, n_consensus:, bust_cache:, background:, request_options:); end
 
     sig do
       params(
         split_id: String,
+        include_output: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Split)
     end
-    def get(split_id:, request_options:); end
+    def get(split_id:, include_output:, request_options:); end
 
     sig do
       params(
@@ -52,5 +55,13 @@ module Retab
     end
     def delete(split_id:, request_options:); end
 
+    sig do
+      params(
+        split_id: String,
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::Split)
+    end
+    def create_split_cancel(split_id:, request_options:); end
+
   end
 end

data/rbi/retab/stored_block_execution.rbi

@@ -64,10 +64,10 @@ module Retab
     def handle_outputs=(value); end
 
     sig { returns(T.nilable(T::Array[String])) }
-    def routing_decision; end
+    def routing_decisions; end
 
     sig { params(value: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
-    def routing_decision=(value); end
+    def routing_decisions=(value); end
 
     sig { returns(T.nilable(Float)) }
     def duration_ms; end

data/rbi/retab/{schedule_trigger.rbi → trigger_info.rbi}

@@ -5,21 +5,15 @@
 # typed: strong
 
 module Retab
-  class ScheduleTrigger
+  class TriggerInfo
     sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
     def initialize(json); end
 
-    sig { returns(T.nilable(String)) }
-    def type; end
-
-    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
-    def type=(value); end
-
     sig { returns(String) }
-    def schedule_id; end
+    def type; end
 
     sig { params(value: String).returns(String) }
-    def schedule_id=(value); end
+    def type=(value); end
 
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end

data/rbi/retab/verdict_summary.rbi

@@ -10,10 +10,10 @@ module Retab
     def initialize(json); end
 
     sig { returns(T::Boolean) }
-    def result; end
+    def passed; end
 
     sig { params(value: T::Boolean).returns(T::Boolean) }
-    def result=(value); end
+    def passed=(value); end
 
     sig { returns(T.nilable(Integer)) }
     def assertions_passed; end

data/rbi/retab/while_loop_termination.rbi

@@ -22,10 +22,10 @@ module Retab
     def id=(value); end
 
     sig { returns(String) }
-    def workflow_run_id; end
+    def run_id; end
 
     sig { params(value: String).returns(String) }
-    def workflow_run_id=(value); end
+    def run_id=(value); end
 
     sig { returns(String) }
     def step_id; end

data/rbi/retab/workflow_artifacts.rbi

@@ -9,14 +9,6 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
-    sig do
-      params(
-        artifact_id: String,
-        request_options: T::Hash[Symbol, T.untyped]
-      ).returns(T.any(Retab::ExtractionWorkflowArtifact, Retab::SplitWorkflowArtifact, Retab::ClassificationWorkflowArtifact, Retab::ParseWorkflowArtifact, Retab::EditWorkflowArtifact, Retab::PartitionWorkflowArtifact, Retab::ConditionalEvaluation, Retab::ReviewEvaluation, Retab::WhileLoopTermination, Retab::ApiCallInvocation, Retab::FunctionInvocation))
-    end
-    def get(artifact_id:, request_options:); end
-
     sig do
       params(
         run_id: T.nilable(String),
@@ -31,5 +23,13 @@ module Retab
     end
     def list(run_id:, operation:, block_id:, step_id:, before:, after:, limit:, request_options:); end
 
+    sig do
+      params(
+        artifact_id: String,
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(T.any(Retab::ExtractionWorkflowArtifact, Retab::SplitWorkflowArtifact, Retab::ClassificationWorkflowArtifact, Retab::ParseWorkflowArtifact, Retab::EditWorkflowArtifact, Retab::PartitionWorkflowArtifact, Retab::ConditionalEvaluation, Retab::ReviewEvaluation, Retab::WhileLoopTermination, Retab::ApiCallInvocation, Retab::FunctionInvocation))
+    end
+    def get(artifact_id:, request_options:); end
+
   end
 end

data/rbi/retab/workflow_export_payload_request.rbi

@@ -63,11 +63,11 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def to_date=(value); end
 
-    sig { returns(T.nilable(T::Array[String])) }
-    def trigger_types; end
+    sig { returns(T.nilable(String)) }
+    def trigger_type; end
 
-    sig { params(value: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
-    def trigger_types=(value); end
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def trigger_type=(value); end
 
     sig { returns(T.nilable(T::Array[String])) }
     def preferred_columns; end

data/rbi/retab/workflow_run.rbi

@@ -15,16 +15,22 @@ module Retab
     sig { params(value: String).returns(String) }
     def id=(value); end
 
-    sig { returns(Retab::WorkflowSnapshotRef) }
-    def workflow; end
+    sig { returns(String) }
+    def workflow_id; end
+
+    sig { params(value: String).returns(String) }
+    def workflow_id=(value); end
 
-    sig { params(value: Retab::WorkflowSnapshotRef).returns(Retab::WorkflowSnapshotRef) }
-    def workflow=(value); end
+    sig { returns(String) }
+    def workflow_version_id; end
+
+    sig { params(value: String).returns(String) }
+    def workflow_version_id=(value); end
 
-    sig { returns(T.any(Retab::ManualTrigger, Retab::ApiTrigger, Retab::ScheduleTrigger, Retab::WebhookTrigger, Retab::EmailTrigger, Retab::RestartTrigger)) }
+    sig { returns(Retab::TriggerInfo) }
     def trigger; end
 
-    sig { params(value: T.any(Retab::ManualTrigger, Retab::ApiTrigger, Retab::ScheduleTrigger, Retab::WebhookTrigger, Retab::EmailTrigger, Retab::RestartTrigger)).returns(T.any(Retab::ManualTrigger, Retab::ApiTrigger, Retab::ScheduleTrigger, Retab::WebhookTrigger, Retab::EmailTrigger, Retab::RestartTrigger)) }
+    sig { params(value: Retab::TriggerInfo).returns(Retab::TriggerInfo) }
     def trigger=(value); end
 
     sig { returns(T.any(Retab::PendingRun, Retab::RunningRun, Retab::AwaitingReviewRun, Retab::CompletedTerminal, Retab::ErrorTerminal, Retab::CancelledTerminal)) }

data/rbi/retab/workflow_runs.rbi

@@ -13,10 +13,8 @@ module Retab
       params(
         workflow_id: T.nilable(String),
         status: T.nilable(String),
-        statuses: T.nilable(String),
         exclude_status: T.nilable(String),
         trigger_type: T.nilable(String),
-        trigger_types: T.nilable(String),
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         min_duration_ms: T.nilable(Integer),
@@ -30,7 +28,7 @@ module Retab
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::PaginatedList[Retab::WorkflowRun])
     end
-    def list(workflow_id:, status:, statuses:, exclude_status:, trigger_type:, trigger_types:, from_date:, to_date:, min_duration_ms:, max_duration_ms:, search:, before:, after:, limit:, order:, sort_by:, request_options:); end
+    def list(workflow_id:, status:, exclude_status:, trigger_type:, from_date:, to_date:, min_duration_ms:, max_duration_ms:, search:, before:, after:, limit:, order:, sort_by:, request_options:); end
 
     sig do
       params(
@@ -54,7 +52,7 @@ module Retab
         exclude_status: T.nilable(String),
         from_date: T.nilable(String),
         to_date: T.nilable(String),
-        trigger_types: T.nilable(T::Array[String]),
+        trigger_type: T.nilable(String),
         preferred_columns: T.nilable(T::Array[String]),
         delimiter: T.nilable(String),
         line_delimiter: T.nilable(String),
@@ -62,7 +60,7 @@ module Retab
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::WorkflowExportPayloadResponse)
     end
-    def export(workflow_id:, block_id:, export_source:, selected_run_ids:, selected_doc_types:, status:, exclude_status:, from_date:, to_date:, trigger_types:, preferred_columns:, delimiter:, line_delimiter:, quote:, request_options:); end
+    def export(workflow_id:, block_id:, export_source:, selected_run_ids:, selected_doc_types:, status:, exclude_status:, from_date:, to_date:, trigger_type:, preferred_columns:, delimiter:, line_delimiter:, quote:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflow_spec.rbi

@@ -13,9 +13,9 @@ module Retab
       params(
         yaml_definition: String,
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::DeclarativeValidationResponse)
+      ).returns(Retab::DeclarativeApplyResponse)
     end
-    def validate(yaml_definition:, request_options:); end
+    def apply(yaml_definition:, request_options:); end
 
     sig do
       params(
@@ -29,9 +29,9 @@ module Retab
       params(
         yaml_definition: String,
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::DeclarativeApplyResponse)
+      ).returns(Retab::DeclarativeValidationResponse)
     end
-    def apply(yaml_definition:, request_options:); end
+    def validate(yaml_definition:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflow_steps.rbi

@@ -13,7 +13,6 @@ module Retab
       params(
         run_id: T.nilable(String),
         block_id: T.nilable(String),
-        block_ids: T.nilable(T::Array[String]),
         step_id: T.nilable(String),
         block_type: T.nilable(T::Array[String]),
         status: T.nilable(T::Array[String]),
@@ -23,7 +22,7 @@ module Retab
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::PaginatedList[Retab::WorkflowRunStep])
     end
-    def list(run_id:, block_id:, block_ids:, step_id:, block_type:, status:, before:, after:, limit:, request_options:); end
+    def list(run_id:, block_id:, step_id:, block_type:, status:, before:, after:, limit:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflow_test_result.rbi

@@ -94,10 +94,10 @@ module Retab
     def outputs=(value); end
 
     sig { returns(T.nilable(T::Array[String])) }
-    def routing_decision; end
+    def routing_decisions; end
 
     sig { params(value: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
-    def routing_decision=(value); end
+    def routing_decisions=(value); end
 
     sig { returns(T.nilable(T::Array[String])) }
     def warnings; end

data/rbi/retab/workflow_test_run.rbi

@@ -15,16 +15,22 @@ module Retab
     sig { params(value: String).returns(String) }
     def id=(value); end
 
-    sig { returns(Retab::WorkflowSnapshotRef) }
-    def workflow; end
+    sig { returns(String) }
+    def workflow_id; end
+
+    sig { params(value: String).returns(String) }
+    def workflow_id=(value); end
 
-    sig { params(value: Retab::WorkflowSnapshotRef).returns(Retab::WorkflowSnapshotRef) }
-    def workflow=(value); end
+    sig { returns(String) }
+    def workflow_version_id; end
+
+    sig { params(value: String).returns(String) }
+    def workflow_version_id=(value); end
 
-    sig { returns(T.any(Retab::ManualTrigger, Retab::ApiTrigger, Retab::ScheduleTrigger, Retab::WebhookTrigger, Retab::EmailTrigger, Retab::RestartTrigger)) }
+    sig { returns(Retab::TriggerInfo) }
     def trigger; end
 
-    sig { params(value: T.any(Retab::ManualTrigger, Retab::ApiTrigger, Retab::ScheduleTrigger, Retab::WebhookTrigger, Retab::EmailTrigger, Retab::RestartTrigger)).returns(T.any(Retab::ManualTrigger, Retab::ApiTrigger, Retab::ScheduleTrigger, Retab::WebhookTrigger, Retab::EmailTrigger, Retab::RestartTrigger)) }
+    sig { params(value: Retab::TriggerInfo).returns(Retab::TriggerInfo) }
     def trigger=(value); end
 
     sig { returns(T.any(Retab::PendingWorkflowTestRun, Retab::QueuedWorkflowTestRun, Retab::RunningWorkflowTestRun, Retab::CompletedWorkflowTestRun, Retab::ErrorWorkflowTestRun, Retab::CancelledWorkflowTestRun)) }