retab 0.1.3 → 0.1.5

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

@@ -6,14 +6,17 @@
 
 module Retab
   class Client < BaseClient
-    sig { returns(Retab::Schemas) }
-    def schemas; end
+    sig { returns(Retab::Classifications) }
+    def classifications; end
+
+    sig { returns(Retab::Edits) }
+    def edits; end
 
     sig { returns(Retab::Extractions) }
     def extractions; end
 
-    sig { returns(Retab::Classifications) }
-    def classifications; end
+    sig { returns(Retab::Files) }
+    def files; end
 
     sig { returns(Retab::Parses) }
     def parses; end
@@ -21,20 +24,14 @@ module Retab
     sig { returns(Retab::Partitions) }
     def partitions; end
 
+    sig { returns(Retab::Schemas) }
+    def schemas; end
+
     sig { returns(Retab::Splits) }
     def splits; end
 
-    sig { returns(Retab::Files) }
-    def files; end
-
     sig { returns(Retab::Workflows) }
     def workflows; end
 
-    sig { returns(Retab::Edits) }
-    def edits; end
-
-    sig { returns(Retab::Jobs) }
-    def jobs; end
-
   end
 end

data/rbi/retab/condition_evaluation_details.rbi

@@ -40,10 +40,10 @@ module Retab
     def matched=(value); end
 
     sig { returns(T.nilable(T::Array[Retab::ConditionEvaluationPerItem])) }
-    def per_item; end
+    def items; end
 
     sig { params(value: T.nilable(T::Array[Retab::ConditionEvaluationPerItem])).returns(T.nilable(T::Array[Retab::ConditionEvaluationPerItem])) }
-    def per_item=(value); end
+    def items=(value); end
 
     sig { returns(T.nilable(T::Array[Retab::ConditionEvaluationSubCondition])) }
     def sub_conditions; end

data/rbi/retab/condition_evaluation_result.rbi

@@ -58,10 +58,10 @@ module Retab
     def logical_operator=(value); end
 
     sig { returns(T.nilable(T::Array[Retab::ConditionEvaluationPerItem])) }
-    def per_item; end
+    def items; end
 
     sig { params(value: T.nilable(T::Array[Retab::ConditionEvaluationPerItem])).returns(T.nilable(T::Array[Retab::ConditionEvaluationPerItem])) }
-    def per_item=(value); end
+    def items=(value); end
 
     sig { returns(T.nilable(T::Array[Retab::ConditionEvaluationSubCondition])) }
     def sub_evaluations; end

data/rbi/retab/condition_evaluation_sub_condition.rbi

@@ -46,10 +46,10 @@ module Retab
     def matched=(value); end
 
     sig { returns(T.nilable(T::Array[Retab::ConditionEvaluationPerItem])) }
-    def per_item; end
+    def items; end
 
     sig { params(value: T.nilable(T::Array[Retab::ConditionEvaluationPerItem])).returns(T.nilable(T::Array[Retab::ConditionEvaluationPerItem])) }
-    def per_item=(value); end
+    def items=(value); end
 
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end

data/rbi/retab/conditional_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
@@ -57,10 +57,10 @@ module Retab
     sig { params(value: T.nilable(T::Array[String])).returns(T.nilable(T::Array[String])) }
     def matched_condition_ids=(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::Hash[Symbol, T.untyped]) }

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
 
@@ -63,10 +75,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/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/experiment_document_capture_request.rbi

@@ -10,10 +10,10 @@ module Retab
     def initialize(json); 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(T.nilable(String)) }
     def step_id; end

data/rbi/retab/experiment_document_provenance.rbi

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

data/rbi/retab/experiment_result.rbi

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

data/rbi/retab/experiment_run.rbi

@@ -15,11 +15,17 @@ 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(Retab::ExperimentRunTrigger) }
     def trigger; end

data/rbi/retab/experiment_runs.rbi

@@ -15,10 +15,8 @@ module Retab
         experiment_id: T.nilable(String),
         block_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),
         sort_by: T.nilable(String),
@@ -29,7 +27,7 @@ module Retab
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::PaginatedList[Retab::ExperimentRun])
     end
-    def list(workflow_id:, experiment_id:, block_id:, status:, statuses:, exclude_status:, trigger_type:, trigger_types:, from_date:, to_date:, sort_by:, before:, after:, limit:, order:, request_options:); end
+    def list(workflow_id:, experiment_id:, block_id:, status:, exclude_status:, trigger_type:, from_date:, to_date:, sort_by:, before:, after:, limit:, order:, request_options:); end
 
     sig do
       params(

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
 
@@ -75,10 +87,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/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/files.rbi

@@ -9,6 +9,23 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
+    sig do
+      params(
+        before: T.nilable(String),
+        after: T.nilable(String),
+        limit: T.nilable(Integer),
+        order: T.nilable(String),
+        filename: T.nilable(String),
+        mime_type: T.nilable(String),
+        from_date: T.nilable(String),
+        to_date: T.nilable(String),
+        include_embeddings: T.nilable(T::Boolean),
+        sort_by: T.nilable(String),
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::PaginatedList[Retab::FileModel])
+    end
+    def list(before:, after:, limit:, order:, filename:, mime_type:, from_date:, to_date:, include_embeddings:, sort_by:, request_options:); end
+
     sig do
       params(
         filename: String,
@@ -29,23 +46,6 @@ module Retab
     end
     def complete_upload(file_id:, sha_256:, request_options:); end
 
-    sig do
-      params(
-        before: T.nilable(String),
-        after: T.nilable(String),
-        limit: T.nilable(Integer),
-        order: T.nilable(String),
-        filename: T.nilable(String),
-        mime_type: T.nilable(String),
-        from_date: T.nilable(String),
-        to_date: T.nilable(String),
-        include_embeddings: T.nilable(T::Boolean),
-        sort_by: T.nilable(String),
-        request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::PaginatedList[Retab::FileModel])
-    end
-    def list(before:, after:, limit:, order:, filename:, mime_type:, from_date:, to_date:, include_embeddings:, sort_by:, request_options:); end
-
     sig do
       params(
         file_id: String,

data/rbi/retab/function_invocation.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
@@ -57,10 +57,10 @@ module Retab
     sig { params(value: T.nilable(Retab::ErrorDetails)).returns(T.nilable(Retab::ErrorDetails)) }
     def error=(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::Hash[Symbol, T.untyped]) }

data/rbi/retab/generate_schema_request.rbi

@@ -21,12 +21,6 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def model=(value); end
 
-    sig { returns(T.nilable(String)) }
-    def reasoning_effort; end
-
-    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
-    def reasoning_effort=(value); end
-
     sig { returns(T.nilable(String)) }
     def instructions; end
 

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