nimble_python 0.19.0__tar.gz → 0.21.0__tar.gz

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

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

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

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.21.0 (2026-06-22)
+
+Full Changelog: [v0.20.0...v0.21.0](https://github.com/Nimbleway/nimble-python/compare/v0.20.0...v0.21.0)
+
+### Features
+
+* **api:** manual updates ([9bade2f](https://github.com/Nimbleway/nimble-python/commit/9bade2fd7b7618e15200f4143c16cddf5b6b992c))
+
+## 0.20.0 (2026-06-18)
+
+Full Changelog: [v0.19.0...v0.20.0](https://github.com/Nimbleway/nimble-python/compare/v0.19.0...v0.20.0)
+
+### Features
+
+* **api:** Add jobs api ([9065317](https://github.com/Nimbleway/nimble-python/commit/90653176f426f3566d6b596ab46573dfa5d6bf23))
+* **api:** api update ([0dd31cd](https://github.com/Nimbleway/nimble-python/commit/0dd31cd413a4f9803d95d087a17db47c7fd2cac1))
+
 ## 0.19.0 (2026-06-11)
 
 Full Changelog: [v0.18.0...v0.19.0](https://github.com/Nimbleway/nimble-python/compare/v0.18.0...v0.19.0)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nimble_python
-Version: 0.19.0
+Version: 0.21.0
 Summary: The official Python library for the nimble API
 Project-URL: Homepage, https://github.com/Nimbleway/nimble-python
 Project-URL: Repository, https://github.com/Nimbleway/nimble-python

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

@@ -153,6 +153,18 @@ Methods:
 - <code title="post /v1/serp/async">client.serp.<a href="./src/nimble_python/resources/serp.py">run_async</a>(\*\*<a href="src/nimble_python/types/serp_run_async_params.py">params</a>) -> <a href="./src/nimble_python/types/serp_run_async_response.py">SerpRunAsyncResponse</a></code>
 - <code title="post /v1/serp/batch">client.serp.<a href="./src/nimble_python/resources/serp.py">run_batch</a>(\*\*<a href="src/nimble_python/types/serp_run_batch_params.py">params</a>) -> <a href="./src/nimble_python/types/serp_run_batch_response.py">SerpRunBatchResponse</a></code>
 
+# FastSerp
+
+Types:
+
+```python
+from nimble_python.types import FastSerpRunResponse
+```
+
+Methods:
+
+- <code title="post /v1/fast-serp">client.fast_serp.<a href="./src/nimble_python/resources/fast_serp.py">run</a>(\*\*<a href="src/nimble_python/types/fast_serp_run_params.py">params</a>) -> <a href="./src/nimble_python/types/fast_serp_run_response.py">FastSerpRunResponse</a></code>
+
 # TaskAgent
 
 Types:
@@ -204,3 +216,60 @@ Methods:
 - <code title="get /v1/task-agents/{agent_id}/runs/{run_id}">client.task_agent.runs.<a href="./src/nimble_python/resources/task_agent/runs.py">get</a>(run_id, \*, agent_id) -> <a href="./src/nimble_python/types/task_agent/run_get_response.py">RunGetResponse</a></code>
 - <code title="get /v1/task-agents/{agent_id}/runs/{run_id}/result">client.task_agent.runs.<a href="./src/nimble_python/resources/task_agent/runs.py">get_result</a>(run_id, \*, agent_id) -> <a href="./src/nimble_python/types/task_agent/run_get_result_response.py">RunGetResultResponse</a></code>
 - <code title="get /v1/task-agents/{agent_id}/runs/{run_id}/events">client.task_agent.runs.<a href="./src/nimble_python/resources/task_agent/runs.py">stream_events</a>(run_id, \*, agent_id) -> object</code>
+
+# Jobs
+
+Types:
+
+```python
+from nimble_python.types import (
+    JobCreateResponse,
+    JobUpdateResponse,
+    JobListResponse,
+    JobGetResponse,
+    JobRunResponse,
+)
+```
+
+Methods:
+
+- <code title="post /v1/jobs">client.jobs.<a href="./src/nimble_python/resources/jobs/jobs.py">create</a>(\*\*<a href="src/nimble_python/types/job_create_params.py">params</a>) -> <a href="./src/nimble_python/types/job_create_response.py">JobCreateResponse</a></code>
+- <code title="patch /v1/jobs/{job_id}">client.jobs.<a href="./src/nimble_python/resources/jobs/jobs.py">update</a>(job_id, \*\*<a href="src/nimble_python/types/job_update_params.py">params</a>) -> <a href="./src/nimble_python/types/job_update_response.py">JobUpdateResponse</a></code>
+- <code title="get /v1/jobs">client.jobs.<a href="./src/nimble_python/resources/jobs/jobs.py">list</a>(\*\*<a href="src/nimble_python/types/job_list_params.py">params</a>) -> <a href="./src/nimble_python/types/job_list_response.py">JobListResponse</a></code>
+- <code title="delete /v1/jobs/{job_id}">client.jobs.<a href="./src/nimble_python/resources/jobs/jobs.py">delete</a>(job_id) -> None</code>
+- <code title="get /v1/jobs/{job_id}">client.jobs.<a href="./src/nimble_python/resources/jobs/jobs.py">get</a>(job_id) -> <a href="./src/nimble_python/types/job_get_response.py">JobGetResponse</a></code>
+- <code title="post /v1/jobs/{job_id}/runs">client.jobs.<a href="./src/nimble_python/resources/jobs/jobs.py">run</a>(job_id) -> <a href="./src/nimble_python/types/job_run_response.py">JobRunResponse</a></code>
+
+## Runs
+
+Types:
+
+```python
+from nimble_python.types.jobs import RunListResponse, RunCancelResponse, RunGetResponse
+```
+
+Methods:
+
+- <code title="get /v1/jobs/{job_id}/runs">client.jobs.runs.<a href="./src/nimble_python/resources/jobs/runs/runs.py">list</a>(job_id, \*\*<a href="src/nimble_python/types/jobs/run_list_params.py">params</a>) -> <a href="./src/nimble_python/types/jobs/run_list_response.py">RunListResponse</a></code>
+- <code title="post /v1/jobs/runs/{run_id}/cancel">client.jobs.runs.<a href="./src/nimble_python/resources/jobs/runs/runs.py">cancel</a>(run_id) -> <a href="./src/nimble_python/types/jobs/run_cancel_response.py">RunCancelResponse</a></code>
+- <code title="get /v1/jobs/runs/{run_id}">client.jobs.runs.<a href="./src/nimble_python/resources/jobs/runs/runs.py">get</a>(run_id) -> <a href="./src/nimble_python/types/jobs/run_get_response.py">RunGetResponse</a></code>
+
+### Artifacts
+
+Types:
+
+```python
+from nimble_python.types.jobs.runs import (
+    ArtifactListResponse,
+    ArtifactDownloadURLResponse,
+    ArtifactGetResponse,
+    ArtifactPreviewResponse,
+)
+```
+
+Methods:
+
+- <code title="get /v1/jobs/runs/{run_id}/artifacts">client.jobs.runs.artifacts.<a href="./src/nimble_python/resources/jobs/runs/artifacts.py">list</a>(run_id) -> <a href="./src/nimble_python/types/jobs/runs/artifact_list_response.py">ArtifactListResponse</a></code>
+- <code title="get /v1/jobs/runs/{run_id}/artifacts/{artifact_id}/download-url">client.jobs.runs.artifacts.<a href="./src/nimble_python/resources/jobs/runs/artifacts.py">download_url</a>(artifact_id, \*, run_id) -> <a href="./src/nimble_python/types/jobs/runs/artifact_download_url_response.py">ArtifactDownloadURLResponse</a></code>
+- <code title="get /v1/jobs/runs/{run_id}/artifacts/{artifact_id}">client.jobs.runs.artifacts.<a href="./src/nimble_python/resources/jobs/runs/artifacts.py">get</a>(artifact_id, \*, run_id) -> <a href="./src/nimble_python/types/jobs/runs/artifact_get_response.py">ArtifactGetResponse</a></code>
+- <code title="get /v1/jobs/runs/{run_id}/artifacts/{artifact_id}/preview">client.jobs.runs.artifacts.<a href="./src/nimble_python/resources/jobs/runs/artifacts.py">preview</a>(artifact_id, \*, run_id) -> <a href="./src/nimble_python/types/jobs/runs/artifact_preview_response.py">ArtifactPreviewResponse</a></code>

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

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

{nimble_python-0.19.0 → nimble_python-0.21.0}/src/nimble_python/_client.py

@@ -61,13 +61,15 @@ from .types.extract_async_response import ExtractAsyncResponse
 from .types.extract_batch_response import ExtractBatchResponse
 
 if TYPE_CHECKING:
-    from .resources import serp, agent, crawl, media, tasks, batches, task_agent, domain_knowledge
+    from .resources import jobs, serp, agent, crawl, media, tasks, batches, fast_serp, task_agent, domain_knowledge
     from .resources.serp import SerpResource, AsyncSerpResource
     from .resources.agent import AgentResource, AsyncAgentResource
     from .resources.crawl import CrawlResource, AsyncCrawlResource
     from .resources.media import MediaResource, AsyncMediaResource
     from .resources.tasks import TasksResource, AsyncTasksResource
     from .resources.batches import BatchesResource, AsyncBatchesResource
+    from .resources.fast_serp import FastSerpResource, AsyncFastSerpResource
+    from .resources.jobs.jobs import JobsResource, AsyncJobsResource
     from .resources.domain_knowledge import DomainKnowledgeResource, AsyncDomainKnowledgeResource
     from .resources.task_agent.task_agent import TaskAgentResource, AsyncTaskAgentResource
 
@@ -184,12 +186,24 @@ class Nimble(SyncAPIClient):
 
         return SerpResource(self)
 
+    @cached_property
+    def fast_serp(self) -> FastSerpResource:
+        from .resources.fast_serp import FastSerpResource
+
+        return FastSerpResource(self)
+
     @cached_property
     def task_agent(self) -> TaskAgentResource:
         from .resources.task_agent import TaskAgentResource
 
         return TaskAgentResource(self)
 
+    @cached_property
+    def jobs(self) -> JobsResource:
+        from .resources.jobs import JobsResource
+
+        return JobsResource(self)
+
     @cached_property
     def with_raw_response(self) -> NimbleWithRawResponse:
         return NimbleWithRawResponse(self)
@@ -1100,7 +1114,7 @@ class Nimble(SyncAPIClient):
             "random", "no-referer", "same-origin", "google", "bing", "facebook", "twitter", "instagram"
         ]
         | Omit = omit,
-        render: bool | Omit = omit,
+        render: Union[bool, Literal["auto"]] | Omit = omit,
         request_timeout: float | Omit = omit,
         session: client_extract_params.Session | Omit = omit,
         skill: Union[str, SequenceNotStr[str]] | Omit = omit,
@@ -2101,7 +2115,7 @@ class Nimble(SyncAPIClient):
             "random", "no-referer", "same-origin", "google", "bing", "facebook", "twitter", "instagram"
         ]
         | Omit = omit,
-        render: bool | Omit = omit,
+        render: Union[bool, Literal["auto"]] | Omit = omit,
         request_timeout: float | Omit = omit,
         session: client_extract_async_params.Session | Omit = omit,
         skill: Union[str, SequenceNotStr[str]] | Omit = omit,
@@ -3452,12 +3466,24 @@ class AsyncNimble(AsyncAPIClient):
 
         return AsyncSerpResource(self)
 
+    @cached_property
+    def fast_serp(self) -> AsyncFastSerpResource:
+        from .resources.fast_serp import AsyncFastSerpResource
+
+        return AsyncFastSerpResource(self)
+
     @cached_property
     def task_agent(self) -> AsyncTaskAgentResource:
         from .resources.task_agent import AsyncTaskAgentResource
 
         return AsyncTaskAgentResource(self)
 
+    @cached_property
+    def jobs(self) -> AsyncJobsResource:
+        from .resources.jobs import AsyncJobsResource
+
+        return AsyncJobsResource(self)
+
     @cached_property
     def with_raw_response(self) -> AsyncNimbleWithRawResponse:
         return AsyncNimbleWithRawResponse(self)
@@ -4368,7 +4394,7 @@ class AsyncNimble(AsyncAPIClient):
             "random", "no-referer", "same-origin", "google", "bing", "facebook", "twitter", "instagram"
         ]
         | Omit = omit,
-        render: bool | Omit = omit,
+        render: Union[bool, Literal["auto"]] | Omit = omit,
         request_timeout: float | Omit = omit,
         session: client_extract_params.Session | Omit = omit,
         skill: Union[str, SequenceNotStr[str]] | Omit = omit,
@@ -5369,7 +5395,7 @@ class AsyncNimble(AsyncAPIClient):
             "random", "no-referer", "same-origin", "google", "bing", "facebook", "twitter", "instagram"
         ]
         | Omit = omit,
-        render: bool | Omit = omit,
+        render: Union[bool, Literal["auto"]] | Omit = omit,
         request_timeout: float | Omit = omit,
         session: client_extract_async_params.Session | Omit = omit,
         skill: Union[str, SequenceNotStr[str]] | Omit = omit,
@@ -6674,12 +6700,24 @@ class NimbleWithRawResponse:
 
         return SerpResourceWithRawResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.FastSerpResourceWithRawResponse:
+        from .resources.fast_serp import FastSerpResourceWithRawResponse
+
+        return FastSerpResourceWithRawResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.TaskAgentResourceWithRawResponse:
         from .resources.task_agent import TaskAgentResourceWithRawResponse
 
         return TaskAgentResourceWithRawResponse(self._client.task_agent)
 
+    @cached_property
+    def jobs(self) -> jobs.JobsResourceWithRawResponse:
+        from .resources.jobs import JobsResourceWithRawResponse
+
+        return JobsResourceWithRawResponse(self._client.jobs)
+
 
 class AsyncNimbleWithRawResponse:
     _client: AsyncNimble
@@ -6745,12 +6783,24 @@ class AsyncNimbleWithRawResponse:
 
         return AsyncSerpResourceWithRawResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.AsyncFastSerpResourceWithRawResponse:
+        from .resources.fast_serp import AsyncFastSerpResourceWithRawResponse
+
+        return AsyncFastSerpResourceWithRawResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.AsyncTaskAgentResourceWithRawResponse:
         from .resources.task_agent import AsyncTaskAgentResourceWithRawResponse
 
         return AsyncTaskAgentResourceWithRawResponse(self._client.task_agent)
 
+    @cached_property
+    def jobs(self) -> jobs.AsyncJobsResourceWithRawResponse:
+        from .resources.jobs import AsyncJobsResourceWithRawResponse
+
+        return AsyncJobsResourceWithRawResponse(self._client.jobs)
+
 
 class NimbleWithStreamedResponse:
     _client: Nimble
@@ -6816,12 +6866,24 @@ class NimbleWithStreamedResponse:
 
         return SerpResourceWithStreamingResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.FastSerpResourceWithStreamingResponse:
+        from .resources.fast_serp import FastSerpResourceWithStreamingResponse
+
+        return FastSerpResourceWithStreamingResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.TaskAgentResourceWithStreamingResponse:
         from .resources.task_agent import TaskAgentResourceWithStreamingResponse
 
         return TaskAgentResourceWithStreamingResponse(self._client.task_agent)
 
+    @cached_property
+    def jobs(self) -> jobs.JobsResourceWithStreamingResponse:
+        from .resources.jobs import JobsResourceWithStreamingResponse
+
+        return JobsResourceWithStreamingResponse(self._client.jobs)
+
 
 class AsyncNimbleWithStreamedResponse:
     _client: AsyncNimble
@@ -6887,12 +6949,24 @@ class AsyncNimbleWithStreamedResponse:
 
         return AsyncSerpResourceWithStreamingResponse(self._client.serp)
 
+    @cached_property
+    def fast_serp(self) -> fast_serp.AsyncFastSerpResourceWithStreamingResponse:
+        from .resources.fast_serp import AsyncFastSerpResourceWithStreamingResponse
+
+        return AsyncFastSerpResourceWithStreamingResponse(self._client.fast_serp)
+
     @cached_property
     def task_agent(self) -> task_agent.AsyncTaskAgentResourceWithStreamingResponse:
         from .resources.task_agent import AsyncTaskAgentResourceWithStreamingResponse
 
         return AsyncTaskAgentResourceWithStreamingResponse(self._client.task_agent)
 
+    @cached_property
+    def jobs(self) -> jobs.AsyncJobsResourceWithStreamingResponse:
+        from .resources.jobs import AsyncJobsResourceWithStreamingResponse
+
+        return AsyncJobsResourceWithStreamingResponse(self._client.jobs)
+
 
 Client = Nimble
 

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

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

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

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .jobs import (
+    JobsResource,
+    AsyncJobsResource,
+    JobsResourceWithRawResponse,
+    AsyncJobsResourceWithRawResponse,
+    JobsResourceWithStreamingResponse,
+    AsyncJobsResourceWithStreamingResponse,
+)
 from .serp import (
     SerpResource,
     AsyncSerpResource,
@@ -48,6 +56,14 @@ from .batches import (
     BatchesResourceWithStreamingResponse,
     AsyncBatchesResourceWithStreamingResponse,
 )
+from .fast_serp import (
+    FastSerpResource,
+    AsyncFastSerpResource,
+    FastSerpResourceWithRawResponse,
+    AsyncFastSerpResourceWithRawResponse,
+    FastSerpResourceWithStreamingResponse,
+    AsyncFastSerpResourceWithStreamingResponse,
+)
 from .task_agent import (
     TaskAgentResource,
     AsyncTaskAgentResource,
@@ -108,10 +124,22 @@ __all__ = [
     "AsyncSerpResourceWithRawResponse",
     "SerpResourceWithStreamingResponse",
     "AsyncSerpResourceWithStreamingResponse",
+    "FastSerpResource",
+    "AsyncFastSerpResource",
+    "FastSerpResourceWithRawResponse",
+    "AsyncFastSerpResourceWithRawResponse",
+    "FastSerpResourceWithStreamingResponse",
+    "AsyncFastSerpResourceWithStreamingResponse",
     "TaskAgentResource",
     "AsyncTaskAgentResource",
     "TaskAgentResourceWithRawResponse",
     "AsyncTaskAgentResourceWithRawResponse",
     "TaskAgentResourceWithStreamingResponse",
     "AsyncTaskAgentResourceWithStreamingResponse",
+    "JobsResource",
+    "AsyncJobsResource",
+    "JobsResourceWithRawResponse",
+    "AsyncJobsResourceWithRawResponse",
+    "JobsResourceWithStreamingResponse",
+    "AsyncJobsResourceWithStreamingResponse",
 ]

nimble_python-0.21.0/src/nimble_python/resources/fast_serp.py

@@ -0,0 +1,293 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal
+
+import httpx
+
+from ..types import fast_serp_run_params
+from .._types import Body, Omit, Query, Headers, NotGiven, omit, not_given
+from .._utils import maybe_transform, async_maybe_transform
+from .._compat import cached_property
+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.fast_serp_run_response import FastSerpRunResponse
+
+__all__ = ["FastSerpResource", "AsyncFastSerpResource"]
+
+
+class FastSerpResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> FastSerpResourceWithRawResponse:
+        """
+        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/Nimbleway/nimble-python#accessing-raw-response-data-eg-headers
+        """
+        return FastSerpResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FastSerpResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Nimbleway/nimble-python#with_streaming_response
+        """
+        return FastSerpResourceWithStreamingResponse(self)
+
+    def run(
+        self,
+        *,
+        search_engine: Literal[
+            "google_search",
+            "google_sge",
+            "google_aio",
+            "google_maps_search",
+            "google_maps_reviews",
+            "google_maps_place",
+            "google_news",
+            "google_images",
+            "bing_search",
+            "yandex_search",
+        ],
+        country: str | Omit = omit,
+        device: Literal["desktop", "mobile"] | Omit = omit,
+        domain: str | Omit = omit,
+        locale: str | Omit = omit,
+        location: str | Omit = omit,
+        num_results: int | Omit = omit,
+        page: int | Omit = omit,
+        parse: bool | Omit = omit,
+        query: str | Omit = omit,
+        render: bool | Omit = omit,
+        show_hidden_results: bool | 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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FastSerpRunResponse:
+        """
+        Fast SERP
+
+        Args:
+          search_engine: The search engine to query.
+
+          country: ISO Alpha-2 country code used to access the target search engine (e.g. US, DE,
+              GB).
+
+          device: Device type used for the search request.
+
+          domain: Top-level domain for the search engine (e.g. "com", "co.uk", "de").
+
+          locale: Locale used for the search request.
+
+          location: Geo-location for the search (canonical Google location name).
+
+          num_results: Number of results to return (1–100).
+
+          page: The result page number for pagination.
+
+          parse: When true, the SERP response is parsed into structured JSON.
+
+          query: The search keyword or phrase to query.
+
+          render: Whether to render the page in a browser before extracting.
+
+          show_hidden_results: When true, disables Google result filtering (filter=0) so omitted/duplicate and
+              highly similar pages are also returned. Applies to Google search engines.
+
+          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(
+            "/v1/fast-serp",
+            body=maybe_transform(
+                {
+                    "search_engine": search_engine,
+                    "country": country,
+                    "device": device,
+                    "domain": domain,
+                    "locale": locale,
+                    "location": location,
+                    "num_results": num_results,
+                    "page": page,
+                    "parse": parse,
+                    "query": query,
+                    "render": render,
+                    "show_hidden_results": show_hidden_results,
+                },
+                fast_serp_run_params.FastSerpRunParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FastSerpRunResponse,
+        )
+
+
+class AsyncFastSerpResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncFastSerpResourceWithRawResponse:
+        """
+        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/Nimbleway/nimble-python#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFastSerpResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncFastSerpResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/Nimbleway/nimble-python#with_streaming_response
+        """
+        return AsyncFastSerpResourceWithStreamingResponse(self)
+
+    async def run(
+        self,
+        *,
+        search_engine: Literal[
+            "google_search",
+            "google_sge",
+            "google_aio",
+            "google_maps_search",
+            "google_maps_reviews",
+            "google_maps_place",
+            "google_news",
+            "google_images",
+            "bing_search",
+            "yandex_search",
+        ],
+        country: str | Omit = omit,
+        device: Literal["desktop", "mobile"] | Omit = omit,
+        domain: str | Omit = omit,
+        locale: str | Omit = omit,
+        location: str | Omit = omit,
+        num_results: int | Omit = omit,
+        page: int | Omit = omit,
+        parse: bool | Omit = omit,
+        query: str | Omit = omit,
+        render: bool | Omit = omit,
+        show_hidden_results: bool | 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.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FastSerpRunResponse:
+        """
+        Fast SERP
+
+        Args:
+          search_engine: The search engine to query.
+
+          country: ISO Alpha-2 country code used to access the target search engine (e.g. US, DE,
+              GB).
+
+          device: Device type used for the search request.
+
+          domain: Top-level domain for the search engine (e.g. "com", "co.uk", "de").
+
+          locale: Locale used for the search request.
+
+          location: Geo-location for the search (canonical Google location name).
+
+          num_results: Number of results to return (1–100).
+
+          page: The result page number for pagination.
+
+          parse: When true, the SERP response is parsed into structured JSON.
+
+          query: The search keyword or phrase to query.
+
+          render: Whether to render the page in a browser before extracting.
+
+          show_hidden_results: When true, disables Google result filtering (filter=0) so omitted/duplicate and
+              highly similar pages are also returned. Applies to Google search engines.
+
+          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(
+            "/v1/fast-serp",
+            body=await async_maybe_transform(
+                {
+                    "search_engine": search_engine,
+                    "country": country,
+                    "device": device,
+                    "domain": domain,
+                    "locale": locale,
+                    "location": location,
+                    "num_results": num_results,
+                    "page": page,
+                    "parse": parse,
+                    "query": query,
+                    "render": render,
+                    "show_hidden_results": show_hidden_results,
+                },
+                fast_serp_run_params.FastSerpRunParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FastSerpRunResponse,
+        )
+
+
+class FastSerpResourceWithRawResponse:
+    def __init__(self, fast_serp: FastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = to_raw_response_wrapper(
+            fast_serp.run,
+        )
+
+
+class AsyncFastSerpResourceWithRawResponse:
+    def __init__(self, fast_serp: AsyncFastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = async_to_raw_response_wrapper(
+            fast_serp.run,
+        )
+
+
+class FastSerpResourceWithStreamingResponse:
+    def __init__(self, fast_serp: FastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = to_streamed_response_wrapper(
+            fast_serp.run,
+        )
+
+
+class AsyncFastSerpResourceWithStreamingResponse:
+    def __init__(self, fast_serp: AsyncFastSerpResource) -> None:
+        self._fast_serp = fast_serp
+
+        self.run = async_to_streamed_response_wrapper(
+            fast_serp.run,
+        )