retab 0.1.0 → 0.1.1

data/rbi/retab/edit_templates.rbi

@@ -18,7 +18,7 @@ module Retab
         name: T.nilable(String),
         sort_by: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::EditTemplate])
     end
     def list(before:, after:, limit:, order:, name:, sort_by:, request_options:); end
 

data/rbi/retab/edit_workflow_artifact.rbi

@@ -51,6 +51,12 @@ module Retab
     sig { params(value: Retab::EditResult).returns(Retab::EditResult) }
     def output=(value); end
 
+    sig { returns(T.nilable(Retab::FileRef)) }
+    def filled_document_ref; end
+
+    sig { params(value: T.nilable(Retab::FileRef)).returns(T.nilable(Retab::FileRef)) }
+    def filled_document_ref=(value); end
+
     sig { returns(T.nilable(Retab::RetabUsage)) }
     def usage; end
 

data/rbi/retab/edits.rbi

@@ -9,6 +9,9 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
+    sig { returns(Retab::EditTemplates) }
+    def templates; end
+
     sig do
       params(
         before: T.nilable(String),
@@ -20,7 +23,7 @@ module Retab
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::Edit])
     end
     def list(before:, after:, limit:, order:, filename:, template_id:, from_date:, to_date:, request_options:); end
 

data/rbi/retab/email_trigger.rbi

@@ -15,10 +15,10 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def type=(value); end
 
-    sig { returns(String) }
+    sig { returns(T.nilable(String)) }
     def sender; end
 
-    sig { params(value: String).returns(String) }
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def sender=(value); end
 
     sig { returns(T.nilable(String)) }

data/rbi/retab/experiment_run_results.rbi

@@ -12,11 +12,14 @@ module Retab
     sig do
       params(
         run_id: String,
+        before: T.nilable(String),
+        after: T.nilable(String),
         limit: T.nilable(Integer),
+        order: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::ExperimentResult])
     end
-    def list(run_id:, limit:, request_options:); end
+    def list(run_id:, before:, after:, limit:, order:, request_options:); end
 
     sig do
       params(

data/rbi/retab/experiment_runs.rbi

@@ -22,15 +22,14 @@ module Retab
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         sort_by: T.nilable(String),
-        fields: T.nilable(String),
         before: T.nilable(String),
         after: T.nilable(String),
         limit: T.nilable(Integer),
         order: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).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:, fields:, before:, after:, limit:, order:, request_options:); 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
 
     sig do
       params(

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::Hash[String, String])) }
+    def chunking_keys; end
+
+    sig { params(value: T.nilable(T::Hash[String, String])).returns(T.nilable(T::Hash[String, String])) }
+    def chunking_keys=(value); end
+
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end
 

data/rbi/retab/extractions.rbi

@@ -23,7 +23,7 @@ module Retab
         to_date: T.nilable(String),
         metadata: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).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
 
@@ -39,10 +39,11 @@ module Retab
         additional_messages: T.nilable(T::Array[T::Hash[String, T.untyped]]),
         bust_cache: T.nilable(T::Boolean),
         stream: 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:, request_options:); end
+    def create(document:, json_schema:, model:, image_resolution_dpi:, instructions:, n_consensus:, metadata:, additional_messages:, bust_cache:, stream:, chunking_keys:, request_options:); end
 
     sig do
       params(

data/rbi/retab/file.rbi

@@ -27,16 +27,22 @@ module Retab
     sig { params(value: String).returns(String) }
     def filename=(value); end
 
-    sig { returns(String) }
+    sig { returns(T.nilable(String)) }
+    def mime_type; end
+
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def mime_type=(value); end
+
+    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(String) }
+    sig { returns(T.nilable(String)) }
     def updated_at; end
 
-    sig { params(value: String).returns(String) }
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def updated_at=(value); end
 
     sig { returns(T.nilable(Integer)) }

data/rbi/retab/files.rbi

@@ -18,7 +18,7 @@ module Retab
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::CreateUploadResponse)
     end
-    def upload(filename:, size_bytes:, content_type:, sha_256:, request_options:); end
+    def create_upload(filename:, size_bytes:, content_type:, sha_256:, request_options:); end
 
     sig do
       params(
@@ -42,7 +42,7 @@ module Retab
         include_embeddings: T.nilable(T::Boolean),
         sort_by: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).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
 

data/rbi/retab/jobs.rbi

@@ -32,7 +32,7 @@ module Retab
         include_request: T.nilable(T::Boolean),
         include_response: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::Job])
     end
     def list(before:, after:, limit:, order:, job_id:, status:, endpoint:, source:, project_id:, workflow_id:, workflow_block_id:, model:, filename_regex:, filename_contains:, document_type:, from_date:, to_date:, metadata:, include_request:, include_response:, request_options:); end
 

data/rbi/retab/parses.rbi

@@ -19,7 +19,7 @@ module Retab
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::Parse])
     end
     def list(before:, after:, limit:, order:, filename:, from_date:, to_date:, request_options:); end
 

data/rbi/retab/partitions.rbi

@@ -19,7 +19,7 @@ module Retab
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::Partition])
     end
     def list(before:, after:, limit:, order:, filename:, from_date:, to_date:, request_options:); end
 

data/rbi/retab/splits.rbi

@@ -19,7 +19,7 @@ module Retab
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::Split])
     end
     def list(before:, after:, limit:, order:, filename:, from_date:, to_date:, request_options:); end
 

data/rbi/retab/workflow.rbi

@@ -33,12 +33,6 @@ module Retab
     sig { params(value: T.nilable(Retab::WorkflowPublished)).returns(T.nilable(Retab::WorkflowPublished)) }
     def published=(value); end
 
-    sig { returns(T.nilable(Retab::WorkflowEmailTrigger)) }
-    def email_trigger; end
-
-    sig { params(value: T.nilable(Retab::WorkflowEmailTrigger)).returns(T.nilable(Retab::WorkflowEmailTrigger)) }
-    def email_trigger=(value); end
-
     sig { returns(String) }
     def created_at; end
 

data/rbi/retab/workflow_artifacts.rbi

@@ -27,7 +27,7 @@ module Retab
         after: T.nilable(String),
         limit: T.nilable(Integer),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowArtifact])
     end
     def list(run_id:, operation:, block_id:, step_id:, before:, after:, limit:, request_options:); end
 

data/rbi/retab/workflow_block_executions.rbi

@@ -13,11 +13,14 @@ module Retab
       params(
         run_id: String,
         block_id: String,
+        before: T.nilable(String),
+        after: T.nilable(String),
         limit: T.nilable(Integer),
+        order: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::StoredBlockExecution])
     end
-    def list(run_id:, block_id:, limit:, request_options:); end
+    def list(run_id:, block_id:, before:, after:, limit:, order:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflow_blocks.rbi

@@ -9,6 +9,9 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
+    sig { returns(Retab::WorkflowBlockExecutions) }
+    def executions; end
+
     sig do
       params(
         workflow_id: String,
@@ -16,7 +19,7 @@ module Retab
         after: T.nilable(String),
         limit: T.nilable(Integer),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowBlock])
     end
     def list(workflow_id:, before:, after:, limit:, request_options:); end
 

data/rbi/retab/workflow_edges.rbi

@@ -18,7 +18,7 @@ module Retab
         after: T.nilable(String),
         limit: T.nilable(Integer),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowEdgeDoc])
     end
     def list(workflow_id:, source_block:, target_block:, before:, after:, limit:, request_options:); end
 

data/rbi/retab/workflow_experiments.rbi

@@ -9,13 +9,26 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
+    sig { returns(Retab::ExperimentRunMetrics) }
+    def metrics; end
+
+    sig { returns(Retab::ExperimentRunResults) }
+    def results; end
+
+    sig { returns(Retab::ExperimentRuns) }
+    def runs; end
+
     sig do
       params(
         workflow_id: String,
+        before: T.nilable(String),
+        after: T.nilable(String),
+        limit: T.nilable(Integer),
+        order: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowExperiment])
     end
-    def list(workflow_id:, request_options:); end
+    def list(workflow_id:, before:, after:, limit:, order:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflow_review_versions.rbi

@@ -16,7 +16,7 @@ module Retab
         after: T.nilable(String),
         limit: T.nilable(Integer),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::ReviewVersion])
     end
     def list(review_id:, before:, after:, limit:, request_options:); end
 

data/rbi/retab/workflow_reviews.rbi

@@ -9,6 +9,9 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
+    sig { returns(Retab::WorkflowReviewVersions) }
+    def versions; end
+
     sig do
       params(
         workflow_id: T.nilable(String),
@@ -21,7 +24,7 @@ module Retab
         after: T.nilable(String),
         limit: T.nilable(Integer),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::Review])
     end
     def list(workflow_id:, run_id:, block_id:, step_id:, iteration_key:, decision_status:, before:, after:, limit:, request_options:); end
 

data/rbi/retab/workflow_runs.rbi

@@ -28,16 +28,20 @@ module Retab
         order: T.nilable(String),
         sort_by: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).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
 
     sig do
       params(
+        workflow_id: String,
+        documents: T.nilable(T::Hash[String, T.any(Retab::MimeData, Retab::FileRef, Pathname, IO, String, T::Hash[Symbol, T.untyped])]),
+        json_inputs: T.nilable(T::Hash[String, T.untyped]),
+        version: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::WorkflowRun)
     end
-    def create(request_options:); end
+    def create(workflow_id:, documents:, json_inputs:, version:, request_options:); end
 
     sig do
       params(

data/rbi/retab/{workflow_specs.rbi → workflow_spec.rbi}

@@ -5,7 +5,7 @@
 # typed: strong
 
 module Retab
-  class WorkflowSpecs
+  class WorkflowSpec
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 

data/rbi/retab/workflow_steps.rbi

@@ -13,6 +13,7 @@ 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]),
@@ -20,9 +21,9 @@ module Retab
         after: T.nilable(String),
         limit: T.nilable(Integer),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowRunStep])
     end
-    def list(run_id:, block_id:, step_id:, block_type:, status:, before:, after:, limit:, request_options:); end
+    def list(run_id:, block_id:, block_ids:, step_id:, block_type:, status:, before:, after:, limit:, request_options:); end
 
     sig do
       params(

data/rbi/retab/{workflow_diagnosis_issue.rbi → workflow_test_run_block_scope.rbi}

@@ -5,32 +5,20 @@
 # typed: strong
 
 module Retab
-  class WorkflowDiagnosisIssue
+  class WorkflowTestRunBlockScope
     sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
     def initialize(json); end
 
     sig { returns(String) }
-    def severity; end
+    def type; end
 
     sig { params(value: String).returns(String) }
-    def severity=(value); end
+    def type=(value); end
 
     sig { returns(String) }
-    def code; end
-
-    sig { params(value: String).returns(String) }
-    def code=(value); end
-
-    sig { returns(String) }
-    def message; end
-
-    sig { params(value: String).returns(String) }
-    def message=(value); end
-
-    sig { returns(T.nilable(String)) }
     def block_id; end
 
-    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    sig { params(value: String).returns(String) }
     def block_id=(value); end
 
     sig { returns(T::Hash[Symbol, T.untyped]) }

data/rbi/retab/workflow_test_run_results.rbi

@@ -12,10 +12,14 @@ module Retab
     sig do
       params(
         run_id: String,
+        before: T.nilable(String),
+        after: T.nilable(String),
+        limit: T.nilable(Integer),
+        order: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowTestResult])
     end
-    def list(run_id:, request_options:); end
+    def list(run_id:, before:, after:, limit:, order:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflow_test_run_single_scope.rbi

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class WorkflowTestRunSingleScope
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(String) }
+    def type; end
+
+    sig { params(value: String).returns(String) }
+    def type=(value); end
+
+    sig { returns(String) }
+    def test_id; end
+
+    sig { params(value: String).returns(String) }
+    def test_id=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/{workflow_block_position.rbi → workflow_test_run_workflow_scope.rbi}

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

data/rbi/retab/workflow_test_runs.rbi

@@ -22,22 +22,23 @@ module Retab
         from_date: T.nilable(String),
         to_date: T.nilable(String),
         sort_by: T.nilable(String),
-        fields: T.nilable(String),
         before: T.nilable(String),
         after: T.nilable(String),
         limit: T.nilable(Integer),
         order: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowTestRun])
     end
-    def list(workflow_id:, test_id:, target_block_id:, status:, statuses:, exclude_status:, trigger_type:, trigger_types:, from_date:, to_date:, sort_by:, fields:, before:, after:, limit:, order:, request_options:); end
+    def list(workflow_id:, test_id:, target_block_id:, status:, statuses:, exclude_status:, trigger_type:, trigger_types:, from_date:, to_date:, sort_by:, before:, after:, limit:, order:, request_options:); end
 
     sig do
       params(
+        workflow_id: String,
+        scope: T.nilable(T.any(Retab::WorkflowTestRunSingleScope, Retab::WorkflowTestRunWorkflowScope, Retab::WorkflowTestRunBlockScope)),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::WorkflowTestRun)
     end
-    def create(request_options:); end
+    def create(workflow_id:, scope:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflow_tests.rbi

@@ -9,15 +9,24 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
+    sig { returns(Retab::WorkflowTestRunResults) }
+    def results; end
+
+    sig { returns(Retab::WorkflowTestRuns) }
+    def runs; end
+
     sig do
       params(
         workflow_id: String,
         target_block_id: T.nilable(String),
+        before: T.nilable(String),
+        after: T.nilable(String),
         limit: T.nilable(Integer),
+        order: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::WorkflowTest])
     end
-    def list(workflow_id:, target_block_id:, limit:, request_options:); end
+    def list(workflow_id:, target_block_id:, before:, after:, limit:, order:, request_options:); end
 
     sig do
       params(

data/rbi/retab/workflows.rbi

@@ -9,6 +9,33 @@ module Retab
     sig { params(client: Retab::BaseClient).void }
     def initialize(client); end
 
+    sig { returns(Retab::WorkflowArtifacts) }
+    def artifacts; end
+
+    sig { returns(Retab::WorkflowBlocks) }
+    def blocks; end
+
+    sig { returns(Retab::WorkflowEdges) }
+    def edges; end
+
+    sig { returns(Retab::WorkflowExperiments) }
+    def experiments; end
+
+    sig { returns(Retab::WorkflowReviews) }
+    def reviews; end
+
+    sig { returns(Retab::WorkflowRuns) }
+    def runs; end
+
+    sig { returns(Retab::WorkflowSpec) }
+    def spec; end
+
+    sig { returns(Retab::WorkflowSteps) }
+    def steps; end
+
+    sig { returns(Retab::WorkflowTests) }
+    def tests; end
+
     sig do
       params(
         before: T.nilable(String),
@@ -17,7 +44,7 @@ module Retab
         order: T.nilable(String),
         sort_by: T.nilable(String),
         request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::Types::ListStruct)
+      ).returns(Retab::PaginatedList[Retab::Workflow])
     end
     def list(before:, after:, limit:, order:, sort_by:, request_options:); end
 
@@ -56,17 +83,6 @@ module Retab
     end
     def delete(workflow_id:, request_options:); end
 
-    sig do
-      params(
-        workflow_id: String,
-        blocks: T.nilable(T::Array[Retab::WorkflowConfigBlock]),
-        edges: T.nilable(T::Array[Retab::WorkflowConfigEdge]),
-        re_propagate: T.nilable(T::Boolean),
-        request_options: T::Hash[Symbol, T.untyped]
-      ).returns(Retab::WorkflowDiagnosisResponse)
-    end
-    def diagnose(workflow_id:, blocks:, edges:, re_propagate:, request_options:); end
-
     sig do
       params(
         workflow_id: String,