retab 0.1.4 → 0.1.5

data/lib/retab/workflow_artifacts/split_workflow_artifact.rb

@@ -13,6 +13,8 @@ module Retab
       n_consensus: :n_consensus,
       instructions: :instructions,
       output: :output,
+      status: :status,
+      error: :error,
       consensus: :consensus,
       usage: :usage,
       created_at: :created_at,
@@ -27,6 +29,8 @@ module Retab
       :n_consensus,
       :instructions,
       :output,
+      :status,
+      :error,
       :consensus,
       :usage,
       :created_at,
@@ -43,6 +47,8 @@ module Retab
       @n_consensus = hash[:n_consensus]
       @instructions = hash[:instructions]
       @output = (hash[:output] || []).map { |item| item ? Retab::SplitResult.new(item) : nil }
+      @status = hash[:status].nil? ? "pending" : hash[:status]
+      @error = hash[:error] ? Retab::PrimitiveError.new(hash[:error]) : nil
       @consensus = hash[:consensus] ? Retab::SplitConsensus.new(hash[:consensus]) : nil
       @usage = hash[:usage] ? Retab::RetabUsage.new(hash[:usage]) : nil
       @created_at = hash[:created_at]

data/lib/retab/workflow_steps.rb

@@ -18,7 +18,7 @@ module Retab
     # @param status [Array<String>, nil] Optional step lifecycle status filter. Repeat the query parameter for multiple values.
     # @param before [String, nil] Step id cursor: return the page before this id (mutually exclusive with `after`).
     # @param after [String, nil] Step id cursor: return the page after this id (mutually exclusive with `before`).
-    # @param limit [Integer, nil] Maximum number of steps to return per page (1-1000). Defaults to 5 because each step hydrates its handle payloads from the artifact store; raise it deliberately when you need a larger page, and use cursor pagination for the rest.
+    # @param limit [Integer, nil] Maximum number of steps to return per page (1-1000). Each step hydrates its handle payloads from the artifact store, so raise it deliberately for larger pages and use cursor pagination for the rest.
     # @param request_options [Hash] (see Retab::Types::RequestOptions)
     # @return [Retab::PaginatedList<Retab::WorkflowRunStep>]
     def list(
@@ -29,7 +29,7 @@ module Retab
       status: nil,
       before: nil,
       after: nil,
-      limit: 5,
+      limit: 20,
       request_options: {}
     )
       params = {

data/lib/retab.rb

@@ -18,7 +18,6 @@ loader.collapse("#{__dir__}/retab/experiment_run_results")
 loader.collapse("#{__dir__}/retab/experiment_runs")
 loader.collapse("#{__dir__}/retab/extractions")
 loader.collapse("#{__dir__}/retab/files")
-loader.collapse("#{__dir__}/retab/jobs")
 loader.collapse("#{__dir__}/retab/parses")
 loader.collapse("#{__dir__}/retab/partitions")
 loader.collapse("#{__dir__}/retab/schemas")

data/rbi/retab/classification.rbi

@@ -45,12 +45,24 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def instructions=(value); end
 
-    sig { returns(Retab::ClassificationDecision) }
+    sig { returns(T.nilable(Retab::ClassificationDecision)) }
     def output; end
 
-    sig { params(value: Retab::ClassificationDecision).returns(Retab::ClassificationDecision) }
+    sig { params(value: T.nilable(Retab::ClassificationDecision)).returns(T.nilable(Retab::ClassificationDecision)) }
     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::ClassificationConsensus)) }
     def consensus; end
 

data/rbi/retab/classification_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/classification_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(Retab::ClassificationDecision) }
+    sig { returns(T.nilable(Retab::ClassificationDecision)) }
     def output; end
 
-    sig { params(value: Retab::ClassificationDecision).returns(Retab::ClassificationDecision) }
+    sig { params(value: T.nilable(Retab::ClassificationDecision)).returns(T.nilable(Retab::ClassificationDecision)) }
     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::ClassificationConsensus)) }
     def consensus; end
 

data/rbi/retab/classifications.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::Classification])
     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
         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::Classification)
     end
-    def create(document:, categories:, model:, first_n_pages:, instructions:, n_consensus:, bust_cache:, request_options:); end
+    def create(document:, categories:, model:, first_n_pages:, instructions:, n_consensus:, bust_cache:, background:, request_options:); end
 
     sig do
       params(
         classification_id: String,
+        include_output: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Classification)
     end
-    def get(classification_id:, request_options:); end
+    def get(classification_id:, include_output:, request_options:); end
 
     sig do
       params(
@@ -53,5 +56,13 @@ module Retab
     end
     def delete(classification_id:, request_options:); end
 
+    sig do
+      params(
+        classification_id: String,
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::Classification)
+    end
+    def create_classification_cancel(classification_id:, request_options:); end
+
   end
 end

data/rbi/retab/client.rbi

@@ -18,9 +18,6 @@ module Retab
     sig { returns(Retab::Files) }
     def files; end
 
-    sig { returns(Retab::Jobs) }
-    def jobs; end
-
     sig { returns(Retab::Parses) }
     def parses; end
 

data/rbi/retab/edit.rbi

@@ -45,12 +45,24 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def template_id=(value); end
 
-    sig { returns(Retab::EditResult) }
+    sig { returns(T.nilable(Retab::EditResult)) }
     def output; end
 
-    sig { params(value: Retab::EditResult).returns(Retab::EditResult) }
+    sig { params(value: T.nilable(Retab::EditResult)).returns(T.nilable(Retab::EditResult)) }
     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::FileRef)) }
     def filled_document_ref; end
 

data/rbi/retab/edit_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/edit_workflow_artifact.rbi

@@ -45,12 +45,24 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def template_id=(value); end
 
-    sig { returns(Retab::EditResult) }
+    sig { returns(T.nilable(Retab::EditResult)) }
     def output; end
 
-    sig { params(value: Retab::EditResult).returns(Retab::EditResult) }
+    sig { params(value: T.nilable(Retab::EditResult)).returns(T.nilable(Retab::EditResult)) }
     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::FileRef)) }
     def filled_document_ref; end
 

data/rbi/retab/edits.rbi

@@ -20,12 +20,13 @@ module Retab
         order: T.nilable(String),
         filename: T.nilable(String),
         template_id: 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::Edit])
     end
-    def list(before:, after:, limit:, order:, filename:, template_id:, from_date:, to_date:, request_options:); end
+    def list(before:, after:, limit:, order:, filename:, template_id:, status:, from_date:, to_date:, request_options:); end
 
     sig do
       params(
@@ -35,18 +36,20 @@ module Retab
         model: T.nilable(String),
         config: T.nilable(Retab::EditConfig),
         bust_cache: T.nilable(T::Boolean),
+        background: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Edit)
     end
-    def create(instructions:, document:, template_id:, model:, config:, bust_cache:, request_options:); end
+    def create(instructions:, document:, template_id:, model:, config:, bust_cache:, background:, request_options:); end
 
     sig do
       params(
         edit_id: String,
+        include_output: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Edit)
     end
-    def get(edit_id:, request_options:); end
+    def get(edit_id:, include_output:, request_options:); end
 
     sig do
       params(
@@ -56,5 +59,13 @@ module Retab
     end
     def delete(edit_id:, request_options:); end
 
+    sig do
+      params(
+        edit_id: String,
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::Edit)
+    end
+    def create_edit_cancel(edit_id:, request_options:); end
+
   end
 end

data/rbi/retab/extraction.rbi

@@ -57,6 +57,18 @@ module Retab
     sig { params(value: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
     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::ExtractionConsensus)) }
     def consensus; end
 

data/rbi/retab/extraction_request.rbi

@@ -69,6 +69,12 @@ module Retab
     sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
     def stream=(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.nilable(T::Hash[String, String])) }
     def chunking_keys; end
 

data/rbi/retab/extraction_workflow_artifact.rbi

@@ -57,6 +57,18 @@ module Retab
     sig { params(value: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
     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::ExtractionConsensus)) }
     def consensus; end
 

data/rbi/retab/extractions.rbi

@@ -19,13 +19,14 @@ module Retab
         filename_regex: T.nilable(String),
         filename_contains: T.nilable(String),
         document_type: T.nilable(T::Array[String]),
+        status: T.nilable(String),
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         metadata: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::PaginatedList[Retab::Extraction])
     end
-    def list(before:, after:, limit:, order:, filename:, filename_regex:, filename_contains:, document_type:, from_date:, to_date:, metadata:, request_options:); end
+    def list(before:, after:, limit:, order:, filename:, filename_regex:, filename_contains:, document_type:, status:, from_date:, to_date:, metadata:, request_options:); end
 
     sig do
       params(
@@ -39,19 +40,21 @@ module Retab
         additional_messages: T.nilable(T::Array[T::Hash[String, T.untyped]]),
         bust_cache: T.nilable(T::Boolean),
         stream: T.nilable(T::Boolean),
+        background: T.nilable(T::Boolean),
         chunking_keys: T.nilable(T::Hash[String, String]),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Extraction)
     end
-    def create(document:, json_schema:, model:, image_resolution_dpi:, instructions:, n_consensus:, metadata:, additional_messages:, bust_cache:, stream:, chunking_keys:, request_options:); end
+    def create(document:, json_schema:, model:, image_resolution_dpi:, instructions:, n_consensus:, metadata:, additional_messages:, bust_cache:, stream:, background:, chunking_keys:, request_options:); end
 
     sig do
       params(
         extraction_id: String,
+        include_output: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Extraction)
     end
-    def get(extraction_id:, request_options:); end
+    def get(extraction_id:, include_output:, request_options:); end
 
     sig do
       params(
@@ -61,6 +64,14 @@ module Retab
     end
     def delete(extraction_id:, request_options:); end
 
+    sig do
+      params(
+        extraction_id: String,
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::Extraction)
+    end
+    def create_extraction_cancel(extraction_id:, request_options:); end
+
     sig do
       params(
         extraction_id: String,

data/rbi/retab/parse.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/parse_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/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
 

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_error.rbi → primitive_error.rbi}

@@ -5,7 +5,7 @@
 # typed: strong
 
 module Retab
-  class JobError
+  class PrimitiveError
     sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
     def initialize(json); 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