samplehc 0.19.0__tar.gz → 0.21.0__tar.gz

samplehc-0.21.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.21.0"
+}

{samplehc-0.19.0 → samplehc-0.21.0}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.21.0 (2026-02-04)
+
+Full Changelog: [v0.20.0...v0.21.0](https://github.com/samplehc/samplehc-python/compare/v0.20.0...v0.21.0)
+
+### Features
+
+* **api:** api update ([a07b6dd](https://github.com/samplehc/samplehc-python/commit/a07b6dd010210f5e76dfb05122155344de5d378e))
+
+## 0.20.0 (2026-02-03)
+
+Full Changelog: [v0.19.0...v0.20.0](https://github.com/samplehc/samplehc-python/compare/v0.19.0...v0.20.0)
+
+### Features
+
+* **api:** manual updates ([e398ad8](https://github.com/samplehc/samplehc-python/commit/e398ad8aee71fc730ccd91aa2d9db5bbe74e15f6))
+
 ## 0.19.0 (2026-02-03)
 
 Full Changelog: [v0.18.0...v0.19.0](https://github.com/samplehc/samplehc-python/compare/v0.18.0...v0.19.0)

{samplehc-0.19.0 → samplehc-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: samplehc
-Version: 0.19.0
+Version: 0.21.0
 Summary: The official Python library for the Sample Healthcare API
 Project-URL: Homepage, https://github.com/samplehc/samplehc-python
 Project-URL: Repository, https://github.com/samplehc/samplehc-python
@@ -67,10 +67,10 @@ client = SampleHealthcare(
     api_key=os.environ.get("SAMPLEHC_API_KEY"),  # This is the default and can be omitted
 )
 
-response = client.v2.async_results.sleep(
-    delay=1,
+response = client.v2.workflow_runs.resume_when_complete(
+    async_result_id="asyncResultId",
 )
-print(response.async_result_id)
+print(response.message)
 ```
 
 While you can provide an `api_key` keyword argument,
@@ -93,10 +93,10 @@ client = AsyncSampleHealthcare(
 
 
 async def main() -> None:
-    response = await client.v2.async_results.sleep(
-        delay=1,
+    response = await client.v2.workflow_runs.resume_when_complete(
+        async_result_id="asyncResultId",
     )
-    print(response.async_result_id)
+    print(response.message)
 
 
 asyncio.run(main())
@@ -129,10 +129,10 @@ async def main() -> None:
         api_key=os.environ.get("SAMPLEHC_API_KEY"),  # This is the default and can be omitted
         http_client=DefaultAioHttpClient(),
     ) as client:
-        response = await client.v2.async_results.sleep(
-            delay=1,
+        response = await client.v2.workflow_runs.resume_when_complete(
+            async_result_id="asyncResultId",
         )
-        print(response.async_result_id)
+        print(response.message)
 
 
 asyncio.run(main())
@@ -182,8 +182,8 @@ from samplehc import SampleHealthcare
 client = SampleHealthcare()
 
 try:
-    client.v2.async_results.sleep(
-        delay=1,
+    client.v2.workflow_runs.resume_when_complete(
+        async_result_id="asyncResultId",
     )
 except samplehc.APIConnectionError as e:
     print("The server could not be reached")
@@ -227,8 +227,8 @@ client = SampleHealthcare(
 )
 
 # Or, configure per-request:
-client.with_options(max_retries=5).v2.async_results.sleep(
-    delay=1,
+client.with_options(max_retries=5).v2.workflow_runs.resume_when_complete(
+    async_result_id="asyncResultId",
 )
 ```
 
@@ -252,8 +252,8 @@ client = SampleHealthcare(
 )
 
 # Override per-request:
-client.with_options(timeout=5.0).v2.async_results.sleep(
-    delay=1,
+client.with_options(timeout=5.0).v2.workflow_runs.resume_when_complete(
+    async_result_id="asyncResultId",
 )
 ```
 
@@ -295,13 +295,13 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to
 from samplehc import SampleHealthcare
 
 client = SampleHealthcare()
-response = client.v2.async_results.with_raw_response.sleep(
-    delay=1,
+response = client.v2.workflow_runs.with_raw_response.resume_when_complete(
+    async_result_id="asyncResultId",
 )
 print(response.headers.get('X-My-Header'))
 
-async_result = response.parse()  # get the object that `v2.async_results.sleep()` would have returned
-print(async_result.async_result_id)
+workflow_run = response.parse()  # get the object that `v2.workflow_runs.resume_when_complete()` would have returned
+print(workflow_run.message)
 ```
 
 These methods return an [`APIResponse`](https://github.com/samplehc/samplehc-python/tree/main/src/samplehc/_response.py) object.
@@ -315,8 +315,8 @@ The above interface eagerly reads the full response body when you make the reque
 To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
 
 ```python
-with client.v2.async_results.with_streaming_response.sleep(
-    delay=1,
+with client.v2.workflow_runs.with_streaming_response.resume_when_complete(
+    async_result_id="asyncResultId",
 ) as response:
     print(response.headers.get("X-My-Header"))
 

{samplehc-0.19.0 → samplehc-0.21.0}/README.md

@@ -32,10 +32,10 @@ client = SampleHealthcare(
     api_key=os.environ.get("SAMPLEHC_API_KEY"),  # This is the default and can be omitted
 )
 
-response = client.v2.async_results.sleep(
-    delay=1,
+response = client.v2.workflow_runs.resume_when_complete(
+    async_result_id="asyncResultId",
 )
-print(response.async_result_id)
+print(response.message)
 ```
 
 While you can provide an `api_key` keyword argument,
@@ -58,10 +58,10 @@ client = AsyncSampleHealthcare(
 
 
 async def main() -> None:
-    response = await client.v2.async_results.sleep(
-        delay=1,
+    response = await client.v2.workflow_runs.resume_when_complete(
+        async_result_id="asyncResultId",
     )
-    print(response.async_result_id)
+    print(response.message)
 
 
 asyncio.run(main())
@@ -94,10 +94,10 @@ async def main() -> None:
         api_key=os.environ.get("SAMPLEHC_API_KEY"),  # This is the default and can be omitted
         http_client=DefaultAioHttpClient(),
     ) as client:
-        response = await client.v2.async_results.sleep(
-            delay=1,
+        response = await client.v2.workflow_runs.resume_when_complete(
+            async_result_id="asyncResultId",
         )
-        print(response.async_result_id)
+        print(response.message)
 
 
 asyncio.run(main())
@@ -147,8 +147,8 @@ from samplehc import SampleHealthcare
 client = SampleHealthcare()
 
 try:
-    client.v2.async_results.sleep(
-        delay=1,
+    client.v2.workflow_runs.resume_when_complete(
+        async_result_id="asyncResultId",
     )
 except samplehc.APIConnectionError as e:
     print("The server could not be reached")
@@ -192,8 +192,8 @@ client = SampleHealthcare(
 )
 
 # Or, configure per-request:
-client.with_options(max_retries=5).v2.async_results.sleep(
-    delay=1,
+client.with_options(max_retries=5).v2.workflow_runs.resume_when_complete(
+    async_result_id="asyncResultId",
 )
 ```
 
@@ -217,8 +217,8 @@ client = SampleHealthcare(
 )
 
 # Override per-request:
-client.with_options(timeout=5.0).v2.async_results.sleep(
-    delay=1,
+client.with_options(timeout=5.0).v2.workflow_runs.resume_when_complete(
+    async_result_id="asyncResultId",
 )
 ```
 
@@ -260,13 +260,13 @@ The "raw" Response object can be accessed by prefixing `.with_raw_response.` to
 from samplehc import SampleHealthcare
 
 client = SampleHealthcare()
-response = client.v2.async_results.with_raw_response.sleep(
-    delay=1,
+response = client.v2.workflow_runs.with_raw_response.resume_when_complete(
+    async_result_id="asyncResultId",
 )
 print(response.headers.get('X-My-Header'))
 
-async_result = response.parse()  # get the object that `v2.async_results.sleep()` would have returned
-print(async_result.async_result_id)
+workflow_run = response.parse()  # get the object that `v2.workflow_runs.resume_when_complete()` would have returned
+print(workflow_run.message)
 ```
 
 These methods return an [`APIResponse`](https://github.com/samplehc/samplehc-python/tree/main/src/samplehc/_response.py) object.
@@ -280,8 +280,8 @@ The above interface eagerly reads the full response body when you make the reque
 To stream the response body, use `.with_streaming_response` instead, which requires a context manager and only reads the response body once you call `.read()`, `.text()`, `.json()`, `.iter_bytes()`, `.iter_text()`, `.iter_lines()` or `.parse()`. In the async client, these are async methods.
 
 ```python
-with client.v2.async_results.with_streaming_response.sleep(
-    delay=1,
+with client.v2.workflow_runs.with_streaming_response.resume_when_complete(
+    async_result_id="asyncResultId",
 ) as response:
     print(response.headers.get("X-My-Header"))
 

{samplehc-0.19.0 → samplehc-0.21.0}/api.md

@@ -1,5 +1,17 @@
 # V2
 
+## WorkflowRuns
+
+Types:
+
+```python
+from samplehc.types.v2 import WorkflowRunResumeWhenCompleteResponse
+```
+
+Methods:
+
+- <code title="post /api/v2/workflow-runs/resume-when-complete">client.v2.workflow_runs.<a href="./src/samplehc/resources/v2/workflow_runs.py">resume_when_complete</a>(\*\*<a href="src/samplehc/types/v2/workflow_run_resume_when_complete_params.py">params</a>) -> <a href="./src/samplehc/types/v2/workflow_run_resume_when_complete_response.py">WorkflowRunResumeWhenCompleteResponse</a></code>
+
 ## AsyncResults
 
 Types:

{samplehc-0.19.0 → samplehc-0.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "samplehc"
-version = "0.19.0"
+version = "0.21.0"
 description = "The official Python library for the Sample Healthcare API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{samplehc-0.19.0 → samplehc-0.21.0}/src/samplehc/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "samplehc"
-__version__ = "0.19.0"  # x-release-please-version
+__version__ = "0.21.0"  # x-release-please-version

{samplehc-0.19.0 → samplehc-0.21.0}/src/samplehc/resources/v2/__init__.py

@@ -48,8 +48,22 @@ from .communication import (
     CommunicationResourceWithStreamingResponse,
     AsyncCommunicationResourceWithStreamingResponse,
 )
+from .workflow_runs import (
+    WorkflowRunsResource,
+    AsyncWorkflowRunsResource,
+    WorkflowRunsResourceWithRawResponse,
+    AsyncWorkflowRunsResourceWithRawResponse,
+    WorkflowRunsResourceWithStreamingResponse,
+    AsyncWorkflowRunsResourceWithStreamingResponse,
+)
 
 __all__ = [
+    "WorkflowRunsResource",
+    "AsyncWorkflowRunsResource",
+    "WorkflowRunsResourceWithRawResponse",
+    "AsyncWorkflowRunsResourceWithRawResponse",
+    "WorkflowRunsResourceWithStreamingResponse",
+    "AsyncWorkflowRunsResourceWithStreamingResponse",
     "AsyncResultsResource",
     "AsyncAsyncResultsResource",
     "AsyncResultsResourceWithRawResponse",

{samplehc-0.19.0 → samplehc-0.21.0}/src/samplehc/resources/v2/documents/documents.py

@@ -298,7 +298,7 @@ class DocumentsResource(SyncAPIResource):
         | Omit = omit,
         ocr_enhance: document_extract_params.OcrEnhance | Omit = omit,
         ocr_quality: Literal["high", "low"] | Omit = omit,
-        priority: Literal["interactive", "non-interactive"] | Omit = omit,
+        priority: Literal["interactive", "non-interactive", "background"] | Omit = omit,
         reasoning_effort: Literal["low", "medium", "high"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -325,6 +325,8 @@ class DocumentsResource(SyncAPIResource):
           ocr_quality: OCR quality setting
 
           priority: The priority of the extraction task. Non-interactive is lower priority.
+              Background are tasks that can be run in the background while the user is doing
+              other things.
 
           reasoning_effort: Optional control over the reasoning effort for extraction.
 
@@ -891,7 +893,7 @@ class AsyncDocumentsResource(AsyncAPIResource):
         | Omit = omit,
         ocr_enhance: document_extract_params.OcrEnhance | Omit = omit,
         ocr_quality: Literal["high", "low"] | Omit = omit,
-        priority: Literal["interactive", "non-interactive"] | Omit = omit,
+        priority: Literal["interactive", "non-interactive", "background"] | Omit = omit,
         reasoning_effort: Literal["low", "medium", "high"] | Omit = omit,
         # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
         # The extra values given here take precedence over values defined on the client or passed to this method.
@@ -918,6 +920,8 @@ class AsyncDocumentsResource(AsyncAPIResource):
           ocr_quality: OCR quality setting
 
           priority: The priority of the extraction task. Non-interactive is lower priority.
+              Background are tasks that can be run in the background while the user is doing
+              other things.
 
           reasoning_effort: Optional control over the reasoning effort for extraction.
 

{samplehc-0.19.0 → samplehc-0.21.0}/src/samplehc/resources/v2/v2.py

@@ -36,6 +36,14 @@ from .communication import (
     CommunicationResourceWithStreamingResponse,
     AsyncCommunicationResourceWithStreamingResponse,
 )
+from .workflow_runs import (
+    WorkflowRunsResource,
+    AsyncWorkflowRunsResource,
+    WorkflowRunsResourceWithRawResponse,
+    AsyncWorkflowRunsResourceWithRawResponse,
+    WorkflowRunsResourceWithStreamingResponse,
+    AsyncWorkflowRunsResourceWithStreamingResponse,
+)
 from .documents.documents import (
     DocumentsResource,
     AsyncDocumentsResource,
@@ -49,6 +57,10 @@ __all__ = ["V2Resource", "AsyncV2Resource"]
 
 
 class V2Resource(SyncAPIResource):
+    @cached_property
+    def workflow_runs(self) -> WorkflowRunsResource:
+        return WorkflowRunsResource(self._client)
+
     @cached_property
     def async_results(self) -> AsyncResultsResource:
         return AsyncResultsResource(self._client)
@@ -90,6 +102,10 @@ class V2Resource(SyncAPIResource):
 
 
 class AsyncV2Resource(AsyncAPIResource):
+    @cached_property
+    def workflow_runs(self) -> AsyncWorkflowRunsResource:
+        return AsyncWorkflowRunsResource(self._client)
+
     @cached_property
     def async_results(self) -> AsyncAsyncResultsResource:
         return AsyncAsyncResultsResource(self._client)
@@ -134,6 +150,10 @@ class V2ResourceWithRawResponse:
     def __init__(self, v2: V2Resource) -> None:
         self._v2 = v2
 
+    @cached_property
+    def workflow_runs(self) -> WorkflowRunsResourceWithRawResponse:
+        return WorkflowRunsResourceWithRawResponse(self._v2.workflow_runs)
+
     @cached_property
     def async_results(self) -> AsyncResultsResourceWithRawResponse:
         return AsyncResultsResourceWithRawResponse(self._v2.async_results)
@@ -159,6 +179,10 @@ class AsyncV2ResourceWithRawResponse:
     def __init__(self, v2: AsyncV2Resource) -> None:
         self._v2 = v2
 
+    @cached_property
+    def workflow_runs(self) -> AsyncWorkflowRunsResourceWithRawResponse:
+        return AsyncWorkflowRunsResourceWithRawResponse(self._v2.workflow_runs)
+
     @cached_property
     def async_results(self) -> AsyncAsyncResultsResourceWithRawResponse:
         return AsyncAsyncResultsResourceWithRawResponse(self._v2.async_results)
@@ -184,6 +208,10 @@ class V2ResourceWithStreamingResponse:
     def __init__(self, v2: V2Resource) -> None:
         self._v2 = v2
 
+    @cached_property
+    def workflow_runs(self) -> WorkflowRunsResourceWithStreamingResponse:
+        return WorkflowRunsResourceWithStreamingResponse(self._v2.workflow_runs)
+
     @cached_property
     def async_results(self) -> AsyncResultsResourceWithStreamingResponse:
         return AsyncResultsResourceWithStreamingResponse(self._v2.async_results)
@@ -209,6 +237,10 @@ class AsyncV2ResourceWithStreamingResponse:
     def __init__(self, v2: AsyncV2Resource) -> None:
         self._v2 = v2
 
+    @cached_property
+    def workflow_runs(self) -> AsyncWorkflowRunsResourceWithStreamingResponse:
+        return AsyncWorkflowRunsResourceWithStreamingResponse(self._v2.workflow_runs)
+
     @cached_property
     def async_results(self) -> AsyncAsyncResultsResourceWithStreamingResponse:
         return AsyncAsyncResultsResourceWithStreamingResponse(self._v2.async_results)

samplehc-0.21.0/src/samplehc/resources/v2/workflow_runs.py

@@ -0,0 +1,177 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from ..._types import Body, Query, Headers, NotGiven, not_given
+from ..._utils import maybe_transform, async_maybe_transform
+from ..._compat import cached_property
+from ...types.v2 import workflow_run_resume_when_complete_params
+from ..._resource import SyncAPIResource, AsyncAPIResource
+from ..._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..._base_client import make_request_options
+from ...types.v2.workflow_run_resume_when_complete_response import WorkflowRunResumeWhenCompleteResponse
+
+__all__ = ["WorkflowRunsResource", "AsyncWorkflowRunsResource"]
+
+
+class WorkflowRunsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> WorkflowRunsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/samplehc/samplehc-python#accessing-raw-response-data-eg-headers
+        """
+        return WorkflowRunsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> WorkflowRunsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/samplehc/samplehc-python#with_streaming_response
+        """
+        return WorkflowRunsResourceWithStreamingResponse(self)
+
+    def resume_when_complete(
+        self,
+        *,
+        async_result_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> WorkflowRunResumeWhenCompleteResponse:
+        """
+        Registers an asynchronous task's result ID to resume a workflow run upon its
+        completion. This endpoint requires an ExecuteStepRequestContext with
+        `workflowRunId` and `stepAddr`.
+
+        Args:
+          async_result_id: The unique identifier of the asynchronous result to monitor before resuming.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            "/api/v2/workflow-runs/resume-when-complete",
+            body=maybe_transform(
+                {"async_result_id": async_result_id},
+                workflow_run_resume_when_complete_params.WorkflowRunResumeWhenCompleteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WorkflowRunResumeWhenCompleteResponse,
+        )
+
+
+class AsyncWorkflowRunsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncWorkflowRunsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/samplehc/samplehc-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncWorkflowRunsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncWorkflowRunsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/samplehc/samplehc-python#with_streaming_response
+        """
+        return AsyncWorkflowRunsResourceWithStreamingResponse(self)
+
+    async def resume_when_complete(
+        self,
+        *,
+        async_result_id: str,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> WorkflowRunResumeWhenCompleteResponse:
+        """
+        Registers an asynchronous task's result ID to resume a workflow run upon its
+        completion. This endpoint requires an ExecuteStepRequestContext with
+        `workflowRunId` and `stepAddr`.
+
+        Args:
+          async_result_id: The unique identifier of the asynchronous result to monitor before resuming.
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            "/api/v2/workflow-runs/resume-when-complete",
+            body=await async_maybe_transform(
+                {"async_result_id": async_result_id},
+                workflow_run_resume_when_complete_params.WorkflowRunResumeWhenCompleteParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=WorkflowRunResumeWhenCompleteResponse,
+        )
+
+
+class WorkflowRunsResourceWithRawResponse:
+    def __init__(self, workflow_runs: WorkflowRunsResource) -> None:
+        self._workflow_runs = workflow_runs
+
+        self.resume_when_complete = to_raw_response_wrapper(
+            workflow_runs.resume_when_complete,
+        )
+
+
+class AsyncWorkflowRunsResourceWithRawResponse:
+    def __init__(self, workflow_runs: AsyncWorkflowRunsResource) -> None:
+        self._workflow_runs = workflow_runs
+
+        self.resume_when_complete = async_to_raw_response_wrapper(
+            workflow_runs.resume_when_complete,
+        )
+
+
+class WorkflowRunsResourceWithStreamingResponse:
+    def __init__(self, workflow_runs: WorkflowRunsResource) -> None:
+        self._workflow_runs = workflow_runs
+
+        self.resume_when_complete = to_streamed_response_wrapper(
+            workflow_runs.resume_when_complete,
+        )
+
+
+class AsyncWorkflowRunsResourceWithStreamingResponse:
+    def __init__(self, workflow_runs: AsyncWorkflowRunsResource) -> None:
+        self._workflow_runs = workflow_runs
+
+        self.resume_when_complete = async_to_streamed_response_wrapper(
+            workflow_runs.resume_when_complete,
+        )

{samplehc-0.19.0 → samplehc-0.21.0}/src/samplehc/types/v2/__init__.py

@@ -43,3 +43,9 @@ from .document_transform_json_to_html_params import (
 from .document_transform_json_to_html_response import (
     DocumentTransformJsonToHTMLResponse as DocumentTransformJsonToHTMLResponse,
 )
+from .workflow_run_resume_when_complete_params import (
+    WorkflowRunResumeWhenCompleteParams as WorkflowRunResumeWhenCompleteParams,
+)
+from .workflow_run_resume_when_complete_response import (
+    WorkflowRunResumeWhenCompleteResponse as WorkflowRunResumeWhenCompleteResponse,
+)

{samplehc-0.19.0 → samplehc-0.21.0}/src/samplehc/types/v2/document_extract_params.py

@@ -52,8 +52,12 @@ class DocumentExtractParams(TypedDict, total=False):
     ocr_quality: Annotated[Literal["high", "low"], PropertyInfo(alias="ocrQuality")]
     """OCR quality setting"""
 
-    priority: Literal["interactive", "non-interactive"]
-    """The priority of the extraction task. Non-interactive is lower priority."""
+    priority: Literal["interactive", "non-interactive", "background"]
+    """The priority of the extraction task.
+
+    Non-interactive is lower priority. Background are tasks that can be run in the
+    background while the user is doing other things.
+    """
 
     reasoning_effort: Annotated[Literal["low", "medium", "high"], PropertyInfo(alias="reasoningEffort")]
     """Optional control over the reasoning effort for extraction."""

samplehc-0.21.0/src/samplehc/types/v2/workflow_run_resume_when_complete_params.py

@@ -0,0 +1,14 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+
+__all__ = ["WorkflowRunResumeWhenCompleteParams"]
+
+
+class WorkflowRunResumeWhenCompleteParams(TypedDict, total=False):
+    async_result_id: Required[Annotated[str, PropertyInfo(alias="asyncResultId")]]
+    """The unique identifier of the asynchronous result to monitor before resuming."""

samplehc-0.21.0/src/samplehc/types/v2/workflow_run_resume_when_complete_response.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from ..._models import BaseModel
+
+__all__ = ["WorkflowRunResumeWhenCompleteResponse"]
+
+
+class WorkflowRunResumeWhenCompleteResponse(BaseModel):
+    """Request accepted, processing to resume workflow has been initiated."""
+
+    message: str
+    """A message indicating the request has been accepted for processing."""